chingu 0.5.9.4 → 0.6

data/examples/high_score_list.yml

@@ -1,4 +1,6 @@
 --- 
+- :name: NEW
+  :score: 9987
 - :name: NEW
   :score: 9971
 - :name: NEW
@@ -19,5 +21,3 @@
   :score: 9742
 - :name: NEW
   :score: 9736
-- :name: NEW
-  :score: 9706

data/lib/chingu.rb

@@ -28,5 +28,8 @@ require File.join(CHINGU_ROOT,"chingu","require_all") # Thanks to http://github.
 require_all "#{CHINGU_ROOT}/chingu"
 
 module Chingu
-  VERSION = "0.5.9.4"
+  VERSION = "0.6"
+  
+  DEBUG_COLOR = Gosu::Color.new(0xFFFF0000)
+  DEBUG_ZORDER = 9999
 end

data/lib/chingu/basic_game_object.rb

@@ -8,22 +8,38 @@ module Chingu
   class BasicGameObject
     attr_reader :options, :paused, :visible
     attr_accessor :parent
-        
+    
+    def self.trait_options; @trait_options; end
+    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(*traits)
-      has_traits(*traits)
+    def self.has_trait(trait, options = {})
+      @trait_options ||= Hash.new
+      if trait.is_a?(::Symbol) || trait.is_a?(::String)
+        begin
+          # Convert user-given symbol (eg. :timer) to a Module (eg. Chingu::Traits::Timer)
+          mod = Chingu::Traits.const_get(Chingu::Inflector.camelize(trait))
+          
+          # 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
+          
+          # 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)
+        rescue
+        end
+      end
     end
     
-    # See #has_trait
     def self.has_traits(*traits)
-      Array(traits).each do |trait|
-        if trait.is_a?(::Symbol) || trait.is_a?(::String)
-          include Chingu::Traits.const_get(Chingu::Inflector.camelize(trait))
-        end
-      end
+      Array(traits).each { |trait| has_trait trait }
     end
         
     #
@@ -122,20 +138,15 @@ module Chingu
       @visible == true
     end
 
-    def setup_trait(options)
-    end
-    
-    def update_trait
-		end
-    
-    def draw_trait
-    end    
-        
-    def update
-    end
-
-    def draw
-    end
+    #
+    # Empty placeholders to be overridden
+    #
+    def self.initialize_trait(options); end
+    def setup_trait(options); end
+    def update_trait; end
+    def draw_trait; end    
+    def update; end
+    def draw; end
     
         
     #

data/lib/chingu/game_state.rb

@@ -58,21 +58,37 @@ module Chingu
     attr_reader :options
     attr_accessor :game_state_manager, :game_objects
     
+    def self.trait_options; @trait_options; end
+    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(*traits)
-      has_traits(*traits)
+    def self.has_trait(trait, options = {})
+      @trait_options ||= Hash.new
+      if trait.is_a?(::Symbol) || trait.is_a?(::String)
+        begin
+          # Convert user-given symbol (eg. :timer) to a Module (eg. Chingu::Traits::Timer)
+          mod = Chingu::Traits.const_get(Chingu::Inflector.camelize(trait))
+          
+          # 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
+          
+          # 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)
+        rescue
+        end
+      end
     end
     
-    # See #has_trait
     def self.has_traits(*traits)
-      Array(traits).each do |trait|
-        if trait.is_a?(::Symbol) || trait.is_a?(::String)
-          include Chingu::Traits.const_get(Chingu::Inflector.camelize(trait))
-        end
-      end
+      Array(traits).each { |trait| has_trait trait }
     end
 
 

data/lib/chingu/helpers/gfx.rb

@@ -98,7 +98,7 @@ module Chingu
     end
     
     #
-    # Draws a unfilled rect in given color
+    # 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)
@@ -107,6 +107,18 @@ module Chingu
       $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 + offset_x(a1, r), cy + offset_y(a1, r), color, cx + offset_x(a2, r), cy + offset_y(a2, r), color, 9999
+      end
+    end
+    
     #
     # Fills a given Rect 'rect' with Color 'color', drawing with zorder 'zorder'
     #

data/lib/chingu/helpers/input_client.rb

@@ -29,11 +29,48 @@ module Chingu
     # 1) Initialized an inputmap
     # 2) notifies the parent (could be main Window or a GameState) that the object wants input
     #
-    # In Chingu this is mixed into Window, GameState and GameObject
+    # In Chingu this is mixed into Window, GameState and GameObject.
+    #
+    # You can specify input in 3 different natural formats, the bellow 3 lines does the same thing:
+    #
+    # The normal way, this makes left_arrow key call method "left", and the same thing for right.
+    #   self.input = {:left => :left, :right => :right}
+    #
+    # The shortened way, does exaclty as the above.
+    #   self.input = [:left, :right]
+    #  
+    # The multi-way, adds :a as trigger for method left, and :d as trigger for method :right
+    #   self.input = {[:a, :left] => :left, [:right, :d] => :right}
+    #
     #
     module InputClient
       def input=(input_map)
-        @input = input_map
+        @input ||= Hash.new
+        #@input = input_map
+
+        if input_map.is_a? Array
+          #
+          # Un-nest input_map [:left, :right, :space]
+          # Into: { :left => :left, :right => :right, :space => :space}
+          #
+          input_map.each do |symbol|
+            @input[symbol] = symbol
+          end
+        elsif input_map.is_a? Hash
+          #
+          # Un-nest input:  { [:pad_left, :arrow_left, :a] => :move_left }
+          # Into:  { :pad_left => :move_left, :arrow_left => :move_left, :a => :move_left }
+          #
+          input_map.each_pair do |possible_array, action|
+            if possible_array.is_a? Array
+              possible_array.each do |symbol|
+                @input[symbol] = action
+              end
+            elsif possible_array.is_a? Symbol
+              @input[possible_array] = action
+            end
+          end
+        end
         
         if @parent 
           if (@input == nil || @input == {})

data/lib/chingu/helpers/rotation_center.rb

@@ -74,10 +74,16 @@ module Chingu
       # They're also available (hey, hashlookups are speedy) with "middle" instead of "center" since
       # those 2 words basicly have the same meaning and are both understandable.
       #
-      def rotation_center(alignment)
+      def rotation_center(alignment = nil)
+        #return @rotation_center unless alignment
+        #@rotation_center = alignment
         @center_x, @center_y = @@rotation_centers[alignment.to_sym]
       end
       
+      def rotation_center=(alignment)
+        rotation_center(alignment)
+      end
+      
     end
   end
 end

data/lib/chingu/input.rb

@@ -20,13 +20,13 @@
 #++
 
 module Chingu
-	module Input
-		include Gosu::Button
-    
+  module Input
+    include Gosu::Button
+  
     #
     # Ruby symbols describing http://www.libgosu.org/rdoc/classes/Gosu.html
     #
-		CONSTANT_TO_SYMBOL = {
+    CONSTANT_TO_SYMBOL = {
       Kb0 => [:zero],
       Kb1 => [:one],
       Kb2 => [:two],
@@ -75,11 +75,11 @@ module Chingu
       MsWheelDown       => [:mouse_wheel_down, :wheel_down],
       MsWheelUp         => [:mouse_wheel_up, :wheel_up],
       
-      GpDown 	          => [:gamepad_down, :gp_down, :pad_down],
-      GpLeft 	          => [:gamepad_left, :gp_left, :pad_left],
-      GpRight 	        => [:gamepad_right, :gp_right, :pad_right],
+      GpDown            => [:gamepad_down, :gp_down, :pad_down],
+      GpLeft            => [:gamepad_left, :gp_left, :pad_left],
+      GpRight           => [:gamepad_right, :gp_right, :pad_right],
       GpUp              => [:gamepad_up, :gp_up, :pad_up]
-		}
+    }
     
     # Letters, A-Z
     ("A".."Z").each do |letter|
@@ -99,11 +99,16 @@ module Chingu
     #F-keys, F1-F12
     (1..12).each do |number|
       CONSTANT_TO_SYMBOL[eval("KbF#{number.to_s}")] = ["f#{number.to_s}".to_sym]
+      CONSTANT_TO_SYMBOL[eval("KbF#{number.to_s}")] = ["F#{number.to_s}".to_sym]
     end
 
     # Gamepad-buttons 0-15
     (0..15).each do |number|
       CONSTANT_TO_SYMBOL[eval("GpButton#{number.to_s}")] = ["gamepad_button_#{number.to_s}"]
+      CONSTANT_TO_SYMBOL[eval("GpButton#{number.to_s}")] = ["gamepad_#{number.to_s}"]
+      CONSTANT_TO_SYMBOL[eval("GpButton#{number.to_s}")] = ["pad_button_#{number.to_s}"]
+      CONSTANT_TO_SYMBOL[eval("GpButton#{number.to_s}")] = ["pad_#{number.to_s}"]
+      CONSTANT_TO_SYMBOL[eval("GpButton#{number.to_s}")] = ["gp_#{number.to_s}"]
     end
 
     #
@@ -117,5 +122,5 @@ module Chingu
       end
     end
     
-	end
+  end
 end

data/lib/chingu/traits/bounding_box.rb

@@ -0,0 +1,63 @@
+#--
+#
+# 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 Traits
+    #
+    # Providing a bounding_box-method which generates a AABB on the fly from:
+    # x, y, factor_x, factor_y and rotation_center
+    #
+    module BoundingBox
+    
+      module ClassMethods
+        def initialize_trait(options = {})
+          ## puts "bounding_box initialize_trait #{options}"
+          @trait_options[:bounding_box] = options
+        end
+      end
+            
+      def bounding_box
+        width = self.image.width * self.factor_x.abs
+        height = self.image.height * self.factor_y.abs
+        
+        if trait_options[:bounding_box][:scale]
+          width = width * trait_options[:bounding_box][:scale]
+          height = height * trait_options[:bounding_box][:scale]
+        end
+        
+        x = self.x - (width * self.center_x.abs)
+        y = self.y - (height * self.center_y.abs)
+        
+        return Rect.new(x, y, width, height)
+      end
+      alias :bb :bounding_box
+      
+      def draw_trait
+        if trait_options[:bounding_box][:debug]
+          $window.draw_rect(self.bounding_box, Chingu::DEBUG_COLOR, Chingu::DEBUG_ZORDER)
+        end
+        
+        super
+      end
+      
+    end
+  end
+end

data/lib/chingu/traits/collision_detection.rb

@@ -28,33 +28,16 @@ module Chingu
     #
     # 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
+    # Makes use of 2 attributes
+    #   bounding_box      - a Rect-instance, uses in bounding_box collisions
+    #   radius            - a number
     #
     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
+      module ClassMethods
+        def initialize_trait(options = {})
+          @trait_options[:collision_detection] = options
         end
-        
-        ## @detect_collisions = true
-        super
       end
       
       #
@@ -83,18 +66,6 @@ module Chingu
         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
@@ -114,12 +85,11 @@ module Chingu
       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
+            yield(self, object) if distance(self.x, self.y, object.x, object.y) < self.radius + object.radius
           end
         end
       end
 
-
       #
       # Explicit bounding_box-collision
       # Works like each_collision but with inline-code for speedups
@@ -127,14 +97,13 @@ module Chingu
       def each_bounding_box_collision(klasses = [])
         Array(klasses).each do |klass|
           klass.all.each do |object|
-            yield(self, object) if @bounding_box.collide_rect?(object.bounding_box)
+            yield(self, object) if self.bounding_box.collide_rect?(object.bounding_box)
           end
         end
       end
 
       
       module ClassMethods
-      
         #
         # Works like each_collision but with inline-code for speedups
         #