chingu 0.6.2 → 0.6.3

data.tar.gz.sig

@@ -1,2 +1,3 @@
-[H��7��ųhE�u��5�AMܐR��ä'
-B��©r@	
+���M���ʜ��G��5mǂ��tz��5��~	:kLJ����_�Qˡ��e�z��(
+2�7����qh�y�rA�d
+q�G_"Z\��{�N:g�k��	��Y�m�Aĺ��a��RZ_bW���Fп��".�s��AQ7�~�㏉A�R� �]$k�a��D-�1����N#�S�_�u�@og�k��J �</J��ҋ�!�*a�4�!HL�8vG�J7�.��t}��7��x!p��L�ϙ��e�)�Z�Ž�

data/README.rdoc

@@ -90,6 +90,8 @@ Both $window and game states gets some new graphical helpers, currently only 3,
   fill()          # Fills whole window with color 'color'.
   fill_rect()     # Fills a given Rect 'rect' with Color 'color'
   fill_gradient() # Fills window or a given rect with a gradient between two colors.
+  draw_circle()   # Draws a circle
+  draw_rect()     # Draws a rect
 
 If you base your models on GameObject (or BasicGameObject) you get:
   Enemy.all                 # Returns an Array of all Enemy-instances
@@ -445,13 +447,41 @@ Chingus inputhandler will detect that Menu is a GameState-class, create a new in
 
 === Traits
 Traits (often called behaivors) is a way of adding logic to any class inheriting from BasicGameObject / GameObject.
-Chingus trait-implementation is just ordinary ruby modules with 3 special methods: 
+Chingus trait-implementation is just ordinary ruby modules with 3 special methods:
  - setup_trait 
  - update_trait 
  - draw_trait
 Each of those 3 methods must call "super" to continue the trait-chain.
 
-Example:
+Inside a certian trait-module you can also have a module called ClassMethods, methods inside that module will be added,
+yes you guessed it, as class methods. If initialize_trait is defined inside ClassMethods it will be called class-evaluation time
+(basicly on the has_trait :some_trait line).
+
+A simple trait could be:
+
+module Chingu
+  module Trait
+    module Inspect
+      module ClassMethods
+        def initialize_trait(options)
+            # possible initialize stuff here
+        end
+      
+        def inspect
+          "There's {self.size} active instances of class {self.to_s}"
+        end
+    end
+  end
+end
+
+class Enemy < GameObject
+  has_trait :inspect    # includes Chingu::Trait::Inspect and extends Chingu::Trait::Inspect::ClassMethods
+end
+10.times { Enemy.create }
+Enemy.inspect           # => There's 10 active instances of class Enemy
+
+
+Example of using traits :velocity and :timer:
 
   class Ogre < Chingu::GameObject
     has_traits :velocity, :timer
@@ -466,8 +496,8 @@ Example:
       # These 2 parameters will affect @x and @y every game-iteration
       # So if your ogre is standing on the ground, make sure you cancel out the effect of @acceleration_y
       #
-      @velocity_x = 1       # move constantly to the right
-      @acceleration_y = 0.4 # gravity is basicly a downwards acceleration
+      self.velocity_x = 1       # move constantly to the right
+      self.acceleration_y = 0.4 # gravity is basicly a downwards acceleration
     end
     
     def hit_by(object)
@@ -475,7 +505,7 @@ Example:
       # during() and then() is provided by the timer-trait
       # flash red for 300 millisec when hit, then go back to normal
       #
-      during(100) { @color = @red; @mode = :additive }.then { @color = @white; @mode = :default }
+      during(100) { self.color = @red; self.mode = :additive }.then { self.color = @white; self.mode = :default }
     end
   end
   
@@ -483,7 +513,7 @@ The flow for a game object then becomes:
 
   -- creating a GameObject class X  ( with a "has_trait :bounding_box, :scale => 0.80" )
   1) trait gets merged into X, instance and class methods are added
-  2) GameObject.initialize_trait(:scale => 0.80)
+  2) GameObject.initialize_trait(:scale => 0.80)   (initialize_trait is a class-method!)
   -- creating an instance of X
   1) GameObject#initialize(options)
   2) GameObject#setup_trait(options)
@@ -497,7 +527,7 @@ There's a couple of traits included as default in Chingu:
 
 ==== Trait "timer"
 Adds timer functionality to your game object
-  during(300) { @color = Color.new(0xFFFFFFFF) }   # forces @color to white every update for 300 ms
+  during(300) { self.color = Color.new(0xFFFFFFFF) }   # forces @color to white every update for 300 ms
   after(400) { self.destroy }                      # destroy object after 400 ms
   between(1000,2000) { self.rotate(10) }           # starting after 1 second, call rotate(10) every update during 1 second
   every(2000) { Sound["bleep.wav"].play }          # play bleep.wav every 2 seconds
@@ -514,7 +544,7 @@ You can also scale the calculated rect with has_trait-options:
   # Make player think he's better @ dodging bullets then he really is ;)
   has_trait :bounding_box, :scale => 0.80 
 
-==== Trait "radius"
+==== Trait "bounding_circle"
 Adds accessor 'radius', which returns a Fixnum based on current image size,factor_x and factor_y
 You can also scale the calculated radius with has_trait-options:
 
@@ -530,14 +560,23 @@ Adds class and instance methods for basic collision detection.
   
   # Class method example
   # This will collide all Enemy-instances with all Bullet-instances using the attribute #radius from each object.
-  Enemy.each_radius_collision(Bullet) do |enemy, bullet|
+  Enemy.each_bounding_circle_collision(Bullet) do |enemy, bullet|
   end
   
   # You can also use the instance methods. This will use the Rect bounding_box from @player and each EnemyRocket-object.
   @player.each_bounding_box_collision(EnemyRocket) do |player, enemyrocket|
     player.die!
   end
+
+  #
+  # each_collision automatically tries to access #radius and #bounding_box to see what a certain game object provides
+  # It knows how to collide radius/radius, bounding_box/bounding_box and radius/bounding_box !
+  # Since You're not explicity telling what collision type to use it might be slighty slower.
+  #
+  [Player, PlayerBullet].each_collision(Enemy, EnemyBullet) do |friend, foe|
   
+  end
+
 * API isn't stabilized yet! *
 
 ==== (IN DEVELOPMENT) Trait "retrofy"
@@ -562,7 +601,7 @@ Chingu solves this problem behind the scenes for the most common assets. The 2 l
   Image["player.png"]
 
 You also have:
-  Sound["shot.png"]
+  Sound["shot.wav"]
   Song["intromusic.ogg"]
 
 The default settings are like this:
@@ -589,7 +628,7 @@ Text is a class to give the use of Gosu::Font more rubyish feel and fit it bette
   @font.draw("A Text", 200, 50, 55, 2.0)
   
 # Chingu
-  @text = Chingu::Text.create(:text => "A Text", :x => 200, :y => 50, :zorder => 55, :factor_x => 2.0)
+  @text = Chingu::Text.create("A Text", :x => 200, :y => 50, :zorder => 55, :factor_x => 2.0)
   @text.draw
 
 @text.draw is usually not needed as Text is a GameObject and therefore automaticly updated/drawn (it #create is used instead of #new)
@@ -610,7 +649,7 @@ GameObject.all is naming straight from rails for example. Most stuff in GameObje
 
 As far as possible, use correct rubyfied english game_objects, not gameobjects. class HighScore, not Highscore.
 
-== TODO:
+== TODO - this list is discontinued and no longer updated
 * add :padding and :align => :topleft etc to class Text
 * (skip) rename Chingu::Window so 'include Chingu' and 'include Gosu' wont make Window collide
 * (done) BasicObject vs GameObject vs ScreenObject => Became BasicGameObject and GameObject
@@ -656,9 +695,11 @@ As far as possible, use correct rubyfied english game_objects, not gameobjects.
 
 == CREDITS:
 * Jacius of Rubygame (For doing cool stuff that's well documented as re-usable). So far rect.rb and named_resource.rb is straight outta Rubygame.
+* Banister (of texplay fame) for general feedeback and help with ruby-internals and building the trait-system
 * Jduff for input / commits
 * Jlnr,Philymore,Shawn24,JamesKilton for constructive feedback/discussions
 * Ariel Pillet for codesuggestions and cleanups
+* Deps for making the first real full game with Chingu (and making it better in the process)
 * Thanks to http://github.com/tarcieri for require_all code, good stuff
 
 == REQUIREMENTS:

data/chingu.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{chingu}
-  s.version = "0.6.2"
+  s.version = "0.6.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["ippa"]
-  s.date = %q{2009-11-25}
+  s.date = %q{2009-11-26}
   s.description = %q{OpenGL accelerated 2D game framework for Ruby.
 Builds on the awesome Gosu (Ruby/C++) which provides all the core functionality.
 It adds simple yet powerful game states, prettier input handling, deployment safe asset-handling, a basic re-usable game object and automation of common task.}

data/examples/example14.rb

@@ -11,8 +11,8 @@ class Game < Chingu::Window
     super(640,400)
     self.input = {:esc => :exit, :q => :decrease_size, :w => :increase_size, :a => :decrease_speed, :s => :increase_speed}
     
-    10.times { Circle.create(:x => width/2, :y => height/2) }
-    10.times { Box.create(:x => width/2, :y => height/2) }
+    20.times { Circle.create(:x => width/2, :y => height/2) }
+    20.times { Box.create(:x => width/2, :y => height/2) }
     @blue = Color.new(0xFF0000FF)
     @white = Color.new(0xFFFFFFFF)
   end
@@ -38,7 +38,10 @@ class Game < Chingu::Window
     #
     # Collide Boxes/Circles, Boxes/Boxes and Circles/Circles (basicly all objects on screen)
     #
-    [Box, Circle].each_collision(Box, Circle) { |o, o2| o.color, o2.color = @blue, @blue }
+    # Before optmization: 25 FPS  (20 boxes and 20 circles)
+    # Cached radius and rects:
+    #
+    #[Box, Circle].each_collision(Box, Circle) { |o, o2| o.color, o2.color = @blue, @blue }
     
     #
     # Only collide boxes with other boxes
@@ -69,8 +72,8 @@ class Circle < GameObject
     self.velocity_x = 3 - rand * 6
     self.velocity_y = 3 - rand * 6
     self.factor = 2
-    
-    self.input = [:holding_left, :holding_right, :holding_down, :holding_up]
+    self.input = [:holding_left, :holding_right, :holding_down, :holding_up]  # NOTE: giving input an Array, not a Hash 
+    cache_bounding_circle
   end
   
   def holding_left; @x -= 1; end
@@ -94,11 +97,14 @@ class Box < GameObject
     self.velocity_x = 3 - rand * 6
     self.velocity_y = 3 - rand * 6
     self.factor = 2
+    cache_bounding_box
   end
   
   def update
     self.velocity_x = -self.velocity_x  if @x < 0 || @x > $window.width
     self.velocity_y = -self.velocity_y  if @y < 0 || @y > $window.height
+    #@x = @x.to_i
+    #@y = @y.to_i
   end
 end
 

data/examples/example4.rb

@@ -34,7 +34,7 @@ class Game < Chingu::Window
     push_game_state(Intro)
     
     # Yes you can do crazy things like this :)
-    self.input = { :left_mouse_button => lambda{Chingu::Text.create(:text => "Woff!")}, :esc => :exit}    
+    self.input = { :left_mouse_button => lambda{Chingu::Text.create(:text => "Woff!")}, :esc => :exit}
   end
 end
 
@@ -51,8 +51,8 @@ class Player < Chingu::GameObject
   def move_down;  @y += 1; end 
 
   def fire
-    #puts $window.current_parent.to_s
-    #puts $window.game_state_manager.inside_state
+    #puts "current_scope: #{$window.current_scope.to_s}"
+    #puts "inside_state: #{$window.game_state_manager.inside_state}"
     Bullet.create(:x => @x - 20, :y => @y)
     Bullet.create(:x => @x, :y => @y) 
     Bullet.create(:x => @x + 20, :y => @y)

data/examples/example6.rb

@@ -43,9 +43,18 @@ class Game < Chingu::Window
 end
 
 class State1 < Chingu::GameState
-  def draw
-    Image["ruby.png"].draw(0,0,0)
+  
+  #
+  # This is another way of achieving the same thing as the out-commeted draw-code
+  # Since .create is used, it's automatically updated and drawn
+  #
+  def setup
+    Chingu::GameObject.create(:image => "ruby.png", :rotation_center => :top_left)
   end
+  
+  #def draw
+  #  Image["ruby.png"].draw(0,0,0)
+  #end
 end
 
 class State2 < Chingu::GameState 

data/examples/example9.rb

@@ -76,9 +76,13 @@ class ParticleState < Chingu::GameState
     end
     
     #
-    # GameObject.each_collsion / each_radius_collision wont collide an object with itself
+    # GameObject.each_collsion / each_bounding_box_collision wont collide an object with itself
     #
-    FireCube.each_radius_collision(FireCube) do |cube1, cube2|
+    # FireCube.each_bounding_circle_collision(FireCube) do |cube1, cube2|  # 30 FPS on my computer
+    #
+    # Let's see if we can optimize each_collision, starts with 19 FPS
+    #
+    FireCube.each_collision(FireCube) do |cube1, cube2|
       cube1.die!
       cube2.die!
     end

data/examples/game1.rb

@@ -35,12 +35,10 @@ class Level < Chingu::GameState
   def initialize(options = {})
     super
     
-    @parallax = Parallax.create
-    #ParallaxLayer.has_trait :retrofy
-    #@parallax << ParallaxLayer.new(:image => Image["city3.png"].retrofy, :center => 0, :damping => 4, :factor => $window.factor)
-    @parallax << ParallaxLayer.new(:image => Image["city2.png"].retrofy, :center => 0, :damping => 2, :factor => $window.factor)
-    @parallax << ParallaxLayer.new(:image => Image["city1.png"].retrofy, :center => 0, :damping => 1, :factor => $window.factor)
-    @player = Player.create(:x => 10, :y => 10)
+    @parallax = Parallax.create(:rotation_center => :top_left)
+    @parallax << { :image => Image["city2.png"].retrofy, :damping => 2, :factor => $window.factor }
+    @parallax << { :image => Image["city1.png"].retrofy, :damping => 1, :factor => $window.factor }
+    @player = Player.create(:x => 30, :y => 10)
     
     @bg1 = Color.new(0xFFCE28FF)
     @bg2 = Color.new(0xFF013E87)
@@ -95,12 +93,12 @@ class Level < Chingu::GameState
     push_game_state(GameOver) if solid_pixel_at?(@player.x, @player.y)
     
     # Collide player with enemies and enemy bullets
-    @player.each_radius_collision(Enemy) do |player, enemy|
+    @player.each_bounding_circle_collision(Enemy) do |player, enemy|
       enemy.die
       push_game_state(GameOver)
     end
     
-    Bullet.each_radius_collision(Enemy) do |bullet, enemy|
+    Bullet.each_bounding_circle_collision(Enemy) do |bullet, enemy|
       bullet.die
       if enemy.hit_by(bullet)
         @player.score += 20

data/examples/high_score_list.yml

@@ -9,6 +9,8 @@
   :score: 9912
 - :name: NEW
   :score: 9900
+- :name: NEW
+  :score: 9886
 - :name: NEW
   :score: 9885
 - :name: NEW
@@ -19,5 +21,3 @@
   :score: 9746
 - :name: NEW
   :score: 9742
-- :name: NEW
-  :score: 9736

data/lib/chingu.rb

@@ -33,7 +33,7 @@ require_all "#{CHINGU_ROOT}/chingu/traits"
 require_all "#{CHINGU_ROOT}/chingu"
 
 module Chingu
-  VERSION = "0.6.2"
+  VERSION = "0.6.3"
   
   DEBUG_COLOR = Gosu::Color.new(0xFFFF0000)
   DEBUG_ZORDER = 9999

data/lib/chingu/basic_game_object.rb

@@ -7,7 +7,7 @@ module Chingu
   # It will also acts as a container for the trait-system of chingu.
   #
   class BasicGameObject
-    include Chingu::ClassInheritableAccessor
+    include Chingu::Helpers::ClassInheritableAccessor # adds classmethod class_inheritable_accessor
     
     attr_reader :options, :paused, :visible
     attr_accessor :parent
@@ -65,9 +65,10 @@ module Chingu
       #
       # A GameObject either belong to a GameState or our mainwindow ($window)
       #
-      if !@parent && $window && $window.respond_to?(:game_state_manager)
-        @parent = $window.game_state_manager.inside_state || $window
-      end
+      #if !@parent && $window && $window.respond_to?(:game_state_manager)
+      #  @parent = $window.game_state_manager.inside_state || $window
+      #end
+      @parent = $window.current_scope if !@parent && $window
       
       # if true, BasicGameObject#update will be called
       @paused = options[:paused] || false
@@ -97,6 +98,7 @@ module Chingu
       #
       instance.parent.add_game_object(instance) if instance.parent
       
+      
       return instance
     end
 
@@ -168,14 +170,14 @@ module Chingu
     #   Bullet.all.each do {}  # Iterate through all bullets in current game state
     #
     def self.all
-      $window.current_parent.game_objects.of_class(self).dup
+      $window.current_scope.game_objects.of_class(self).dup
     end
     
     #
     # Returns
     #
     def self.size
-      $window.current_parent.game_objects.of_class(self).size
+      $window.current_scope.game_objects.of_class(self).size
     end
     
     #

data/lib/chingu/core_ext/array.rb

@@ -9,4 +9,27 @@ class Array
       end
     end
   end
+  
+  def each_bounding_circle_collision(*args)
+    list = (self + args).uniq
+    collide_pair = []
+    list.each_with_index { |nr, i| self[i..size].collect { |nr2| collide_pair << [nr,nr2] } }
+    collide_pair.each do |class1,class2|
+      class1.each_bounding_circle_collision(class2) do |object1, object2|
+        yield object1, object2
+      end
+    end
+  end
+
+  def each_bounding_box_collision(*args)
+    list = (self + args).uniq
+    collide_pair = []
+    list.each_with_index { |nr, i| self[i..size].collect { |nr2| collide_pair << [nr,nr2] } }
+    collide_pair.each do |class1,class2|
+      class1.each_bounding_box_collision(class2) do |object1, object2|
+        yield object1, object2
+      end
+    end
+  end
+
 end

data/lib/chingu/game_object.rb

@@ -37,7 +37,6 @@ module Chingu
     include Chingu::Helpers::InputClient        # Adds input and input=
     include Chingu::Helpers::RotationCenter     # Adds easy and verbose modification of @center_x and @center_y
         
-    
     def initialize(options = {})
       super
 
@@ -45,7 +44,7 @@ module Chingu
       if options[:image].is_a?(Gosu::Image)
         @image = options[:image]
       elsif options[:image].is_a? String
-        @image = Image[options[:image]]
+        @image = Gosu::Image[options[:image]]
       end
       
       @x = options[:x] || 0
@@ -76,7 +75,7 @@ module Chingu
       @mode = options[:mode] || :default # :additive is also available.
       @zorder = options[:zorder] || 100
       
-      ## setup_trait(options)  if self.respond_to?(:setup_trait)
+      #setup_trait(options)  if self.respond_to?(:setup_trait)
     end
     
     # Quick way of setting both factor_x and factor_y

data/lib/chingu/game_state.rb

@@ -54,20 +54,23 @@ module Chingu
     include Chingu::Helpers::GameObject         # Adds game_objects_of_class etc ...
     include Chingu::Helpers::InputDispatcher    # Input dispatch-helpers
     include Chingu::Helpers::InputClient        # GameState can have it's own inputmap
+    include Chingu::Helpers::ClassInheritableAccessor # adds classmethod class_inheritable_accessor
     
     attr_reader :options
     attr_accessor :game_state_manager, :game_objects
     
-    def self.trait_options; @trait_options; end
+    class_inheritable_accessor :trait_options
+    @trait_options = Hash.new
     def trait_options; self.class.trait_options; end
-    
+            
     #
     # Adds a trait or traits to a certain game class
     # Executes a standard ruby "include" the specified module
     #
     def self.has_trait(trait, options = {})
-      @trait_options ||= Hash.new
+      
       if trait.is_a?(::Symbol) || trait.is_a?(::String)
+        ## puts "has_trait #{trait}, #{options}"
         begin
           # Convert user-given symbol (eg. :timer) to a Module (eg. Chingu::Traits::Timer)
           mod = Chingu::Traits.const_get(Chingu::Inflector.camelize(trait))
@@ -75,14 +78,21 @@ module Chingu
           # Include the module, which will add the containing methods as instance methods
           include mod
                    
-          # Add possible classmethods defined in sub-module ClassMethods (eg: Chingu::Traits::Timer::ClassMethods)
-          mod2 = mod.const_get("ClassMethods")
-          extend mod2
+          # Does sub-module "ClessMethods" exists?
+          # (eg: Chingu::Traits::Timer::ClassMethods)
+          if mod.const_defined?("ClassMethods")
+            # Add methods in scope ClassMethods as.. class methods!
+            mod2 = mod.const_get("ClassMethods")
+            extend mod2
           
-          # If the newly included trait has a initialize_trait method...
-          # ... call it with the options provided with the has_trait-call
-          initialize_trait(options)  if mod2.method_defined?(:initialize_trait)
+            # If the newly included trait has a initialize_trait method in the ClassMethods-scope:
+            # ... call it with the options provided with the has_trait-line.
+            if mod2.method_defined?(:initialize_trait)
+              initialize_trait(options)
+            end
+          end
         rescue
+          puts $!
         end
       end
     end

data/lib/chingu/game_state_manager.rb

@@ -114,6 +114,7 @@ module Chingu
         current_game_state.finalize   if current_game_state.respond_to?(:finalize) && options[:finalize]
         
         # So BasicGameObject#create connects object to new state in its setup()
+        # Is this doubled in GameState.initialize() ?
         self.inside_state = new_state
         
         # Call setup
@@ -131,8 +132,10 @@ module Chingu
             @game_states[-1] = new_state
           end
         end
-        ## MOVEDE: self.inside_state = current_game_state
+        ## MOVED: self.inside_state = current_game_state
       end
+      
+      self.inside_state = nil   # no longer 'inside' (as in within initialize() etc) a game state
     end
     alias :switch :switch_game_state
     
@@ -157,6 +160,7 @@ module Chingu
         new_state.setup               if new_state.respond_to?(:setup) && options[:setup]
         
         # Make sure the game state knows about the manager
+        # Is this doubled in GameState.initialize() ?
         new_state.game_state_manager = self
         
         # Give the soon-to-be-disabled state a chance to clean up by calling finalize() on it.
@@ -172,6 +176,8 @@ module Chingu
         end
         ## MOVED: self.inside_state = current_game_state
       end
+      
+      self.inside_state = nil   # no longer 'inside' (as in within initialize() etc) a game state
     end
     alias :push :push_game_state
     
@@ -195,6 +201,7 @@ module Chingu
       @game_states.pop
       
       # So BasicGameObject#create connects object to new state in its setup()
+      # Is this doubled in GameState.initialize() ?
       self.inside_state = current_game_state
       
       # Call setup on the new current state
@@ -205,7 +212,9 @@ module Chingu
         transitional_game_state = @transitional_game_state.new(current_game_state, @transitional_game_state_options)
         self.switch_game_state(transitional_game_state, :transitional => false)
       end
+      
       ## MOVED: self.inside_state = current_game_state
+      self.inside_state = nil   # no longer 'inside' (as in within initialize() etc) a game state
     end
     alias :pop :pop_game_state
 

data/lib/chingu/helpers/class_inheritable_accessor.rb

@@ -3,27 +3,29 @@
 # But we use the rails-name for it, class_inheritable_accessor, which should make ppl more @ home.
 #
 module Chingu
-module ClassInheritableAccessor
-  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
-        )
-      end
-      @cattr_inheritable_attrs
+module Helpers
+  module ClassInheritableAccessor
+    def self.included(base)
+      base.extend(ClassMethods)    
     end
-
-    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))
+  
+    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
+          )
+        end
+        @cattr_inheritable_attrs
+      end
+  
+      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))
+        end
       end
     end
   end

data/lib/chingu/helpers/game_object.rb

@@ -29,6 +29,7 @@ module Chingu
   module GameObject
   
     def add_game_object(object)
+      # puts "#{self.to_s} add_game_object(#{object.to_s})"
       @game_objects.add_game_object(object)
     end
     

data/lib/chingu/helpers/gfx.rb

@@ -115,7 +115,7 @@ module Chingu
     def draw_circle(cx,cy,r,color)      
       0.step(360, CIRCLE_STEP) do |a1|
         a2 = a1 + CIRCLE_STEP
-        $window.draw_line cx + offset_x(a1, r), cy + offset_y(a1, r), color, cx + offset_x(a2, r), cy + offset_y(a2, r), color, 9999
+        $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
     

data/lib/chingu/parallax.rb

@@ -36,7 +36,8 @@ module Chingu
     #
     # Options (in hash-format):
     #
-    # repeat: [true|false]  When one layer ends within the screen, repeat/loop it
+    # repeat_x: [true|false]  repeat layer on X-axis
+    # repeat_y: [true|false]  repeat layer on Y-axis
     #
     def initialize(options = {})
       super(options)
@@ -61,7 +62,7 @@ module Chingu
     # returns true if any part of the parallax-scroller is inside the window
     #
     def inside_window?
-      return true if @repeat
+      return true if @repeat_x || @repeat_y
       @layers.each { |layer| return true if layer.inside_window? }
       return false
     end
@@ -122,31 +123,30 @@ module Chingu
     #
     def draw
       @layers.each do |layer|
-        layer.draw
+        #layer.draw
         
         save_x, save_y = layer.x, layer.y
         
         # If layer lands inside our window and repeat_x is true (defaults to true), draw it until window ends
         while layer.repeat_x && layer.x < $window.width
           while layer.repeat_y && layer.y < $window.height
-            layer.y += layer.image.height
             layer.draw
+            layer.y += layer.image.height
           end
           layer.y = save_y
           
-          layer.x += layer.image.width
           layer.draw
+          layer.x += layer.image.width
         end
         
-        # Special loop for when repeat_y is set but not repeat_x
+        # Special loop for when repeat_y is true but not repeat_x
         if layer.repeat_y && !layer.repeat_x
           while layer.repeat_y && layer.y < $window.height
-            layer.y += layer.image.height
             layer.draw
+            layer.y += layer.image.height
           end
         end
 
-          
         layer.x = save_x
       end
       self

data/lib/chingu/text.rb

@@ -72,7 +72,7 @@ module Chingu
       @align = options[:align] || :left
       @max_width = options[:max_width]
     
-      self.rotation_center(:top_left)
+      self.rotation_center = :top_left
       
       @gosu_font = Gosu::Font.new($window, @font, @height)
       

data/lib/chingu/traits/bounding_box.rb

@@ -32,8 +32,23 @@ module Chingu
           trait_options[:bounding_box] = options
         end
       end
-            
-      def bounding_box
+      
+      def setup_trait(options)
+        @cached_bounding_box = nil
+        super
+      end
+      
+      #
+      # Returns an instance of class Rect
+      #
+      def bounding_box        
+        if @cached_bounding_box
+          @cached_bounding_box.x = self.x + @_x_diff
+          @cached_bounding_box.y = self.y + @_y_diff
+          
+          return @cached_bounding_box
+        end
+        
         width = self.image.width * self.factor_x.abs
         height = self.image.height * self.factor_y.abs
         
@@ -49,6 +64,18 @@ module Chingu
       end
       alias :bb :bounding_box
       
+      def cache_bounding_box
+        @cached_bounding_box = nil
+        @cached_bounding_box = self.bounding_box
+        @_x_diff = @cached_bounding_box.x - self.x
+        @_y_diff = @cached_bounding_box.y - self.y
+      end
+      
+      #def update_trait
+      #  cache_bounding_box  if trait_options[:bounding_box][:cache] && !@cached_bounding_box
+      #  super
+      #end
+      
       def draw_trait      
         if trait_options[:bounding_box][:debug]
           $window.draw_rect(self.bounding_box, Chingu::DEBUG_COLOR, Chingu::DEBUG_ZORDER)

data/lib/chingu/traits/bounding_circle.rb

@@ -31,15 +31,22 @@ module Chingu
     
       module ClassMethods
         def initialize_trait(options = {})
-          trait_options[:radius] = options
+          trait_options[:bounding_circle] = options
         end
       end
       
+      def setup_trait(options)
+        @cached_radius = nil
+        super
+      end
+      
       def radius
+        return @cached_radius if @cached_radius
+        
         width = self.image.width * self.factor_x.abs
         height = self.image.height * self.factor_y.abs
         radius = (width + height) / 4
-        radius = radius * trait_options[:radius][:scale] if  trait_options[:radius][:scale]
+        radius = radius * trait_options[:bounding_circle][:scale] if  trait_options[:bounding_circle][:scale]
         return radius
       end
       
@@ -47,13 +54,23 @@ module Chingu
         radius * 2
       end
       
+      def cache_bounding_circle
+        @cached_radius = nil
+        @cached_radius = self.radius
+      end
+      
+      #def update_trait
+      #  cache_bounding_circle  if trait_options[:bounding_circle][:cache] && !@cached_radius
+      #  super
+      #end
+      
       def circle_left;    self.x - self.radius; end
       def circle_right;   self.x + self.radius; end
       def circle_top;     self.y - self.radius; end
       def circle_bottom;  self.y + self.radius; end
       
       def draw_trait
-        if trait_options[:radius][:debug]
+        if trait_options[:bounding_circle][:debug]
           $window.draw_circle(self.x, self.y, self.radius, Chingu::DEBUG_COLOR)
         end
         super

data/lib/chingu/traits/collision_detection.rb

@@ -49,11 +49,12 @@ module Chingu
         if self.respond_to?(:bounding_box) && object2.respond_to?(:bounding_box)
           bounding_box_collision?(object2)
         elsif self.respond_to?(:radius) && object2.respond_to?(:radius)
-          radius_collision?(object2)
+          bounding_circle_collision?(object2)
         else
-          bounding_box_radius_collision?(object2)
+          bounding_box_bounding_circle_collision?(object2)
         end
       end
+      alias :collision? :collides?
       
       #
       # Collide self with a given game object by checking both objects bounding_box'es
@@ -67,8 +68,8 @@ module Chingu
       # 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
+      def bounding_circle_collision?(object2)
+        Gosu.distance(self.x, self.y, object2.x, object2.y) < self.radius + object2.radius
       end
       
       #
@@ -76,7 +77,7 @@ module Chingu
       #
       # http://stackoverflow.com/questions/401847/circle-rectangle-collision-detection-intersection
       #
-      def bounding_box_radius_collision?(object2)
+      def bounding_box_bounding_circle_collision?(object2)
         rect = self.respond_to?(:bounding_box) ? self.bounding_box : object2.bounding_box
         circle = self.respond_to?(:radius) ? self : object2
         radius = circle.radius.to_i
@@ -110,10 +111,10 @@ module Chingu
       # Explicit radius-collision
       # Works like each_collsion but with inline-code for speedups
       #
-      def each_radius_collision(klasses = [])
+      def each_bounding_circle_collision(klasses = [])
         Array(klasses).each do |klass|
           klass.all.each do |object|
-            yield(self, object) if distance(self.x, self.y, object.x, object.y) < self.radius + object.radius
+            yield(self, object) if Gosu.distance(self.x, self.y, object.x, object.y) < self.radius + object.radius
           end
         end
       end
@@ -135,7 +136,7 @@ module Chingu
         #
         # Works like each_collision but with inline-code for speedups
         #
-        def each_radius_collision(klasses = [])
+        def each_bounding_circle_collision(klasses = [])
           Array(klasses).each do |klass|
             object2_list = klass.all
             #total_radius = object1.radius + object2.radius  # possible optimization?
@@ -143,7 +144,7 @@ module Chingu
             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
+                yield object1, object2  if Gosu.distance(object1.x, object1.y, object2.x, object2.y) < object1.radius + object2.radius
               end
             end
           end
@@ -190,7 +191,7 @@ module Chingu
             #  self.all.each do |object1|
             #    object2_list.each do |object2|
             #      next  if object1 == object2  # Don't collide objects with themselves
-            #      yield object1, object2  if object1.bounding_box_radius_collision?(object2)
+            #      yield object1, object2  if object1.bounding_box_bounding_circle_collision?(object2)
             #    end
             #  end
             #end

data/lib/chingu/window.rb

@@ -59,8 +59,15 @@ module Chingu
       @milliseconds_since_last_tick = 0
     end
     
-    def current_parent
-      game_state_manager.current_game_state || self
+    #
+    # Returns self inside GameState.initialize (a game state is not 'active' inside initialize())
+    # Or returns current active game state (as in a switched to or pushed game state)
+    # ... Falls back to returning $window
+    #
+    # current_scope is used to make GameObject.all and friends work everywhere.
+    #
+    def current_scope
+      game_state_manager.inside_state || game_state_manager.current_game_state || self
     end
     
     #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: chingu
 version: !ruby/object:Gem::Version 
-  version: 0.6.2
+  version: 0.6.3
 platform: ruby
 authors: 
 - ippa
@@ -30,7 +30,7 @@ cert_chain:
   hxtMlw==
   -----END CERTIFICATE-----
 
-date: 2009-11-25 00:00:00 +01:00
+date: 2009-11-26 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency