ippa-chingu 0.4.8 → 0.5

data/lib/chingu/parallax.rb

@@ -30,9 +30,9 @@ module Chingu
     end
     
     #
-    # TODO: make use of time here!
+    # TODO: make use of $window.milliseconds_since_last_update here!
     #
-    def update(time)
+    def update
       @backgrounds.each do |background|
         background.x = -@x / background.damping
         background.y =  @y / background.damping

data/lib/chingu/particle.rb

@@ -1,18 +1,19 @@
 #
 # Our basic particle class
 #
-include Chingu
 module Chingu
-  class Particle < Chingu::GameObject      
+  class Particle < Chingu::GameObject
+    add_component :effect
+    
     def initialize(options)
       super({:mode => :additive}.merge(options))
       @rotation = options[:rotation] || 0
       @zoom = options[:zoom] || 0
-      @fade = options[:fade] || 0      
+      @fade = options[:fade] || 0
       @animation = options[:animation] || nil      
     end
       
-    def update(time)
+    def update
       self.image = @animation.next!   if @animation
       self.rotate(@rotation)
       self.zoom(@zoom)

data/lib/chingu/traits/collision_detection.rb

@@ -0,0 +1,33 @@
+module Chingu
+  module Components
+    #
+    # TODO: everything. convert to class?
+    # 
+    # Use QuadTrees: http://lab.polygonal.de/2007/09/09/quadtree-demonstration/
+    #
+    module CollisionDetection
+    
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      def collision?(object2)
+        self.rect.collide_rect?(object2.rect)
+      end
+      
+      module ClassMethods
+        def each_collision(klasses = [])
+          # Make sure klasses is always an array.
+          Array(klasses).each do |klass|
+            self.all.each do |object1|
+              klass.all.each do |object2|
+                yield object1, object2  if object1.collision?(object2)
+              end
+            end
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/chingu/traits/deprecated_module_visual.rb

@@ -0,0 +1,108 @@
+module Chingu
+  module Components
+    module Visual
+      attr_accessor :image, :x, :y, :angle, :center_x, :center_y, :factor_x, :factor_y, :color, :mode, :zorder
+
+      #
+      #   :x        screen x-coordinate (default 0, to the left)
+      #   :y        screen y-coordinate (default 0, top of screen)
+      #   :angle    angle of object, used in draw_rot, (default 0, no rotation)
+      #   :zorder   a gameclass "foo" with higher zorder then gameclass "bar" is drawn on top of "foo".
+      #   :center_x relative horizontal position of the rotation center on the image. 
+      #               0 is the left border, 1 is the right border, 0.5 is the center (default 0.5)
+      #   :center_y see center_x. (default 0.5)
+      #   :factor_x horizontal zoom-factor, use >1.0 to zoom in. (default 1.0, no zoom).
+      #   :factor_y vertical zoom-factor, use >1.0 to zoom in. (default 1.0, no zoom).
+      #
+      #   :update [true|false] Automaticly call #update on object each gameloop. Default +true+.
+      #   :draw   [true|false] Automaticly call #update on object each gameloop. Default +true+.
+      #
+      
+      def self.included(base)
+        #base.__send__(:alias_method, :orig_initialize, :initialize)
+        #base.__send__(:alias_method, :initialize, :orig_initialize)
+        
+        #base.__send__( :alias_method, :initialize_without_extras, :initialize )
+        #base.__send__( :alias_method, :initialize, :initialize_with_extras )
+      end
+      
+      alias_method :orig_initialize, :initialize
+      def initialize(options = {})
+        
+        puts "Visual#initialize"
+        
+        # draw_rot arguments
+        @image = options[:image]          if options[:image].is_a? Gosu::Image
+        @image = Image[options[:image]]   if options[:image].is_a? String
+        @x = options[:x] || 0
+        @y = options[:y] || 0
+        @angle = options[:angle] || 0
+        @zorder = options[:zorder] || 100
+        @center_x = options[:center_x] || options[:center] || 0.5
+        @center_y = options[:center_y] || options[:center] || 0.5
+        @factor_x = options[:factor_x] || options[:factor] || 1.0
+        @factor_y = options[:factor_y] || options[:factor] || 1.0
+        @mode = options[:mode] || :default # :additive is also available.    
+        @color = Gosu::Color.new(options[:color]) if options[:color].is_a? Bignum
+        @color = options[:color]                  if options[:color].respond_to?(:alpha)
+        @color = Gosu::Color.new(0xFFFFFFFF)      if @color.nil?
+          
+        # Shortcuts for draw_rot arguments
+        @factor = 1
+            
+        # gameloop/framework logic
+        @update = options[:update] || true
+        @draw = options[:draw] || true
+        
+        orig_initialize(options)
+        #orig_initialize
+      end
+            
+      #
+      # Quick way of setting both factor_x and factor_y
+      #
+      def factor=(factor)
+        @factor_x = @factor_y = factor
+      end
+
+      #
+      # Quick way of setting both center_x and center_y
+      #
+      def center=(factor)
+        @center_x = @center_y = factor
+      end
+    
+      #
+      # Returns true if object is inside the game window, false if outside
+      #
+      def inside_window?(x = @x, y = @y)
+        x >= 0 && x <= $window.width && y >= 0 && y <= $window.height
+      end
+
+      #
+      # Returns true object is outside the game window 
+      #
+      def outside_window?(x = @x, y = @y)
+        not inside_window?(x,y)
+      end
+      
+      #
+      # The core of the gameclass, the draw_rot encapsulation. Draws the sprite on screen.
+      # Calling #to_i on @x and @y enables thoose to be Float's, for subpixel slow movement in #update
+      #
+      def draw(parent)
+        @image.draw_rot(@x.to_i, @y.to_i, @zorder, @angle, @center_x, @center_y, @factor_x, @factor_y, @color, @mode)
+        #parent.image.draw_rot(  parent.x.to_i, 
+        #                        parent.y.to_i, 
+        #                        parent.zorder, 
+        #                        parent.angle, 
+        #                        parent.center_x, 
+        #                        parent.center_y, 
+        #                        parent.factor_x, 
+        #                        parent.factor_y, 
+        #                        parent.color, 
+        #                        parent.mode)
+      end
+    end
+  end
+end

data/lib/chingu/traits/deprecated_visual.rb

@@ -0,0 +1,100 @@
+module Chingu
+  module Components
+    class Visual
+      
+      def initialize(parent_class, options)
+        @parent_class = parent_class        
+        @parent_class.class_eval do
+          attr_accessor :image, :x, :y, :angle, :center_x, :center_y, :factor_x, :factor_y, :color, :mode, :zorder
+
+          # Quick way of setting both factor_x and factor_y
+          def factor=(factor)
+            @factor_x = @factor_y = factor
+          end
+          
+          # Quick way of setting both center_x and center_y
+          def center=(factor)
+            @center_x = @center_y = factor
+          end
+
+          # Returns true if object is inside the game window, false if outside
+          def inside_window?(x = @x, y = @y)
+            x >= 0 && x <= $window.width && y >= 0 && y <= $window.height
+          end
+
+          # Returns true object is outside the game window 
+          def outside_window?(x = @x, y = @y)
+            not inside_window?(x,y)
+          end
+        end
+        
+      end
+
+      #
+      #   :x        screen x-coordinate (default 0, to the left)
+      #   :y        screen y-coordinate (default 0, top of screen)
+      #   :angle    angle of object, used in draw_rot, (default 0, no rotation)
+      #   :zorder   a gameclass "foo" with higher zorder then gameclass "bar" is drawn on top of "foo".
+      #   :center_x relative horizontal position of the rotation center on the image. 
+      #               0 is the left border, 1 is the right border, 0.5 is the center (default 0.5)
+      #   :center_y see center_x. (default 0.5)
+      #   :factor_x horizontal zoom-factor, use >1.0 to zoom in. (default 1.0, no zoom).
+      #   :factor_y vertical zoom-factor, use >1.0 to zoom in. (default 1.0, no zoom).
+      #
+      #   :update [true|false] Automaticly call #update on object each gameloop. Default +true+.
+      #   :draw   [true|false] Automaticly call #update on object each gameloop. Default +true+.
+      #      
+      def setup(parent_instance, options)
+        @parent_instance = parent_instance
+        @parent_instance.instance_eval do
+          # draw_rot arguments
+          @image = options[:image]          if options[:image].is_a? Gosu::Image
+          @image = Image[options[:image]]   if options[:image].is_a? String
+          @x = options[:x] || 0
+          @y = options[:y] || 0
+          @angle = options[:angle] || 0
+          @zorder = options[:zorder] || 100
+          @center_x = options[:center_x] || options[:center] || 0.5
+          @center_y = options[:center_y] || options[:center] || 0.5
+          @factor_x = options[:factor_x] || options[:factor] || 1.0
+          @factor_y = options[:factor_y] || options[:factor] || 1.0
+            
+          @color = Gosu::Color.new(options[:color]) if options[:color].is_a? Bignum
+          @color = options[:color]                  if options[:color].respond_to?(:alpha)
+          @color = Gosu::Color.new(0xFFFFFFFF)      if @color.nil?
+          
+          @mode = options[:mode] || :default # :additive is also available.
+            
+          # Shortcuts for draw_rot arguments
+          @factor = 1
+            
+          # gameloop/framework logic
+          @update = options[:update] || true
+          @draw = options[:draw] || true
+        end
+        
+      end
+          
+      def update(parent)
+      end
+      
+      #
+      # The core of the gameclass, the draw_rot encapsulation. Draws the sprite on screen.
+      # Calling #to_i on @x and @y enables thoose to be Float's, for subpixel slow movement in #update
+      #
+      def draw(parent)
+        ## @image.draw_rot(@x.to_i, @y.to_i, @zorder, @angle, @center_x, @center_y, @factor_x, @factor_y, @color, @mode)
+        parent.image.draw_rot(  parent.x.to_i, 
+                                parent.y.to_i, 
+                                parent.zorder, 
+                                parent.angle, 
+                                parent.center_x, 
+                                parent.center_y, 
+                                parent.factor_x, 
+                                parent.factor_y, 
+                                parent.color, 
+                                parent.mode)
+      end
+    end
+  end
+end

data/lib/chingu/traits/effect.rb

@@ -0,0 +1,80 @@
+module Chingu
+  module Components
+    class 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
+      #
+      def initialize(parent_class, options)
+        @parent_class = parent_class        
+        @parent_class.class_eval do
+          attr_accessor :rotating, :fading, :zooming
+          
+          # 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
+      
+      #
+      # Setup
+      #
+      def setup(parent_instance, options)
+        @parent_instance = parent_instance
+        @parent_instance.instance_eval do
+          @rotating = options[:rotating] || nil
+          @zooming = options[:zooming] || nil
+          @fading = options[:fading] || nil
+        end
+      end
+      
+      def update(parent)
+        parent.rotate(parent.rotating)    if parent.rotating
+        parent.fade(parent.fading)        if parent.fading
+        parent.zoom(parent.zooming)       if parent.zooming
+      end
+    end
+  end
+end

data/lib/chingu/traits/input.rb

@@ -0,0 +1,15 @@
+module Chingu
+  module Components
+    module Input
+    
+      def input=(input_map)
+        @input = input_map
+        @parent.add_input_client(self)  if @parent
+      end
+      
+      def input
+        @input
+      end
+    end
+  end
+end

data/lib/chingu/traits/velocity.rb

@@ -0,0 +1,59 @@
+module Chingu
+  module Components
+    #
+    # A chingu component providing velocity and acceleration logic. 
+    #
+    class Velocity
+      
+      def initialize(parent_class, options)
+        @parent_class = parent_class        
+        @parent_class.class_eval do
+          attr_accessor :velocity_x, :velocity_y, :acceleration_x, :acceleration_y, :max_velocity
+          
+          def stop
+            @acceleration_y = @acceleration_x = @velocity_y = @acceleration_y = 0
+          end
+        end
+      end
+      
+      #
+      # Setup
+      #
+      def setup(parent_instance, options)
+        @parent_instance = parent_instance
+        @parent_instance.instance_eval do
+          @velocity_x = options[:velocity_x] || 0
+          @velocity_y = options[:velocity_y] || 0
+          @acceleration_x = options[:acceleration_x] || 0
+          @acceleration_y = options[:acceleration_y] || 0
+          @max_velocity = options[:max_velocity] || 1000
+        end
+      end
+      
+      #
+      # Modifies X & Y of parent
+      #
+      def update(parent)
+        #
+        # This is slower oddly enough?
+        #
+        #parent.velocity_y += parent.acceleration_y		if	(parent.velocity_y + parent.acceleration_y).abs < parent.max_velocity
+        #parent.velocity_x += parent.acceleration_x		if	(parent.velocity_x + parent.acceleration_x).abs < parent.max_velocity
+        #parent.y += parent.velocity_y
+        #parent.x += parent.velocity_x
+        
+        parent.instance_eval do
+          @velocity_y += @acceleration_y		if	(@velocity_y + @acceleration_y).abs < @max_velocity
+          @velocity_x += @acceleration_x		if	(@velocity_x + @acceleration_x).abs < @max_velocity
+          #vel_y = (@velocity_y + @acceleration_y).abs
+          #@velocity_y = vel_y		if vel_y  < @max_velocity
+          #vel_x = (@velocity_x + @acceleration_x).abs
+          #@velocity_x  = vel_x  if vel_x  < @max_velocity
+          
+          @y += @velocity_y
+          @x += @velocity_x
+        end
+      end
+    end
+  end
+end

data/lib/chingu/window.rb

@@ -44,6 +44,7 @@ module Chingu
       
       @fps_counter = FPSCounter.new
       @game_state_manager = GameStateManager.new
+      @milliseconds_since_last_tick = 0
     end
     
     def add_game_object(object)
@@ -67,6 +68,13 @@ module Chingu
     def ticks
       @fps_counter.ticks
     end
+    
+    #
+    # Mathematical short name for "milliseconds since last tick"
+    #
+    def dt
+      @milliseconds_since_last_tick
+    end
 
     #
     # Chingus core-logic / loop. Gosu will call this each game-iteration.
@@ -78,8 +86,15 @@ module Chingu
       # Without this self.fps would return an incorrect value.
       # If you override this in your Chingu::Window class, make sure to call super.
       #
-      @milliseconds_since_last_tick = @fps_counter.register_tick
+      @milliseconds_since_last_tick = @fps_counter.register_tick      
       
+      intermediate_update
+    end
+    
+    #
+    # "game logic" update that is safe to call even between Gosus update-calls
+    #
+    def intermediate_update
       #
       # Dispatch inputmap for main window
       #
@@ -123,7 +138,7 @@ module Chingu
     # Call update() on all game objects in main game window.
     #
     def update_game_objects
-      @game_objects.each { |object| object.update(@milliseconds_since_last_tick) }
+      @game_objects.each { |object| object.update }
     end
     
     #
@@ -132,7 +147,7 @@ module Chingu
     # -> call update on all game objects in that state
     #
     def update_game_state_manager
-      @game_state_manager.update(@milliseconds_since_last_tick)
+      @game_state_manager.update
     end
 
     #