chingu 0.7.0 → 0.7.5

data/lib/chingu/traits/animation.rb

@@ -0,0 +1,84 @@
+#--
+#
+# 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
+    #
+    # A chingu trait providing automatic loading of tile-animations
+    #
+    # For example:
+    # 	class FireBall; has_traits :animation; end;
+    #
+    # Will automatically load:
+    # - fire_ball.png into self.animations[:default]
+    # - fire_ball_exploding.png into self.animations[:exploding]
+    #
+    # Adds accessors animations -> Hash with all animations, hash-key is the name of the animation
+    #
+    module Animation
+    
+      module ClassMethods
+    
+        def initialize_trait(options = {})
+          trait_options[:animation] = {:directory => "media", :play => true, :delay => 100}.merge(options)
+        end
+        
+      end
+			
+      def setup_trait(options)			
+        @animation_options = {:debug => false}.merge(options)        
+        @animations = load_animations
+        super
+      end
+
+      #
+      # Try loading animation from class-name
+      #
+      def load_animations
+        animations = {}
+        glob = "#{trait_options[:animation][:directory]}/#{self.filename}_*"
+        puts "Animations? #{glob}" if trait_options[:animation][:debug]
+        Dir[glob].each do |tile_file|
+          #state = :default
+          if tile_file =~ /[a-zA-Z\_+]_*(\d+)x(\d+)_*([a-zA-Z]*)\.(bmp|png)/
+          #if tile_file =~ /_*([a-zA-Z]*)\.(bmp|png)\Z/
+          #if tile_file =~ /#{self.filename}\.(bmp|png)/
+            state = $3.length > 0 ? $3 : "default"            
+            animations[state.to_sym] = Chingu::Animation.new(trait_options[:animation].merge(:file => tile_file))
+          end
+        end
+        return animations
+      end
+      
+      def animation
+        @animations[:default]
+      end
+      
+      #
+      # Returns all animations, then access invidual states with animations[:explode] etc.
+      #
+      def animations
+        @animations
+      end
+      
+    end
+  end
+end

data/lib/chingu/traits/bounding_box.rb

@@ -38,6 +38,10 @@ module Chingu
         super
       end
       
+      def collision_at?(x, y)
+        bounding_box.collide_point?(x,y)
+      end
+      
       #
       # Returns an instance of class Rect
       #
@@ -77,12 +81,21 @@ module Chingu
       #end
       
       def draw_trait      
-        if trait_options[:bounding_box][:debug]
-          $window.draw_rect(self.bounding_box, Chingu::DEBUG_COLOR, Chingu::DEBUG_ZORDER)
-        end
+        draw_debug if trait_options[:bounding_box][:debug]
         super
       end
       
+      #
+      # Visualises the bounding box as a red rectangle.
+      #
+      def draw_debug
+        if defined?(parent.viewport)
+          $window.draw_rect(self.bounding_box.move(-parent.viewport.x, -parent.viewport.y), Chingu::DEBUG_COLOR, Chingu::DEBUG_ZORDER)
+        else
+          $window.draw_rect(self.bounding_box, Chingu::DEBUG_COLOR, Chingu::DEBUG_ZORDER)
+        end        
+      end
+      
     end
   end
 end

data/lib/chingu/traits/bounding_circle.rb

@@ -40,6 +40,10 @@ module Chingu
         super
       end
       
+      def collision_at?(x, y)
+        Gosu.distance(self.x, self.y, x, y) < radius
+      end
+      
       def radius
         return @cached_radius if @cached_radius
         
@@ -70,12 +74,22 @@ module Chingu
       def circle_bottom;  self.y + self.radius; end
       
       def draw_trait
-        if trait_options[:bounding_circle][:debug]
-          $window.draw_circle(self.x, self.y, self.radius, Chingu::DEBUG_COLOR)
-        end
+        draw_debug  if trait_options[:bounding_circle][:debug]
         super
       end
-      
+
+      #
+      # Visualises the bounding circle as a red circle.
+      #
+      def draw_debug
+        x,y = self.x, self.y          # Do we need to take center_x/center_y into consideration here?
+        if defined?(parent.viewport)
+          $window.draw_circle(x - parent.viewport.x, y - parent.viewport.y, self.radius, Chingu::DEBUG_COLOR)
+        else
+          $window.draw_circle(x, y, self.radius, Chingu::DEBUG_COLOR)
+        end
+      end
+        
     end
   end
 end

data/lib/chingu/traits/collision_detection.rb

@@ -106,7 +106,16 @@ module Chingu
           end
         end
       end
-      
+
+      def first_collision(*klasses)
+        Array(klasses).each do |klass|
+          klass.all.each do |object|
+            return object   if collides?(object)
+          end
+        end
+        return nil
+      end
+
       #
       # Explicit radius-collision
       # Works like each_collsion but with inline-code for speedups

data/lib/chingu/traits/velocity.rb

@@ -38,20 +38,42 @@ module Chingu
       end
       
       def setup_trait(options)
-        @velocity_options = {:debug => false}.merge(options)        
+        @velocity_options = {:debug => false}.merge(options)
         
         @velocity_x = options[:velocity_x] || 0
         @velocity_y = options[:velocity_y] || 0
+				self.velocity = options[:velocity] if options[:velocity]
+				
         @acceleration_x = options[:acceleration_x] || 0
         @acceleration_y = options[:acceleration_y] || 0
+				self.acceleration = options[:acceleration] if options[:acceleration]
+				
         @max_velocity = options[:max_velocity] || 1000
         super
       end
       
+			#
+			# Sets X and Y velocity with one single call. Takes an Array-argument with 2 values.
+			#
+			def velocity=(velocity)
+				@velocity_x, @velocity_y = velocity
+			end
+			
+			def velocity; [@velocity_x, @velocity_y]; end
+
+			#
+			# Sets X and Y acceleration with one single call. Takes an Array-argument with 2 values.
+			#
+			def acceleration=(acceleration)
+				@acceleration_x, @acceleration_y = acceleration
+			end
+	
+			def acceleration; [@acceleration_x, @acceleration_y]; end
+
       #
       # Modifies X & Y of parent
       #
-      def update_trait        
+      def update_trait
         @velocity_y += @acceleration_y		if	(@velocity_y + @acceleration_y).abs < @max_velocity
         @velocity_x += @acceleration_x		if	(@velocity_x + @acceleration_x).abs < @max_velocity
         
@@ -61,10 +83,11 @@ module Chingu
         #
         # if option :apply is false, just calculate velocities, don't apply them to x/y
         #
-        if trait_options[:velocity][:apply]          
+        unless trait_options[:velocity][:apply] == false
           self.y += @velocity_y
           self.x += @velocity_x
         end
+        
         super
       end
       

data/lib/chingu/traits/viewport.rb

@@ -45,24 +45,25 @@ module Chingu
         
         super
       end
-            
-      #
-      # Returns true if object is inside view port, false if outside
-      # TODO: add view port height and width! (and use clip_to when painting?)
-      #
-      # This is a very flawed implementation, it Should take inte account objects 
-      # height,width,factor_x,factor_y,center_x,center_y as well...
-      #
+      
       def inside_viewport?(object)
-        object.x >= @viewport.x && object.x <= (@viewport.x + $window.width) && 
+        puts "Deprecated, use self.viewport.inside?() instead"
+        object.x >= @viewport.x && object.x <= (@viewport.x + $window.width) &&
         object.y >= @viewport.y && object.y <= (@viewport.y + $window.height)
       end
 
       # Returns true object is outside the view port
       def outside_viewport?(object)
+        puts "Deprecated, use self.viewport.outside?() instead"
         not inside_viewport?(object)
       end
       
+			# Take care of laggy viewport movements
+      def update_trait
+				@viewport.move_towards_target
+				super
+      end
+      
       #
       # Override game states default draw that draws objects relative to the viewport.
       # It only draws game objects inside the viewport. (GOSU does no such optimizations)

data/lib/chingu/viewport.rb

@@ -21,47 +21,128 @@
 
 module Chingu
   #
-  # A basic Viewport class
+  # A basic viewport class
   #
   # TODO:
   # Implement use of viewports angle, center_x, center_y, factor_x, factor_y
   #
   class Viewport
-    attr_accessor :x, :y, :x_min, :x_max, :y_min, :y_max
-    #attr_accessor :angle, :center_x, :center_y, :factor_x, :factor_y
+    attr_accessor :x, :y, :x_target, :y_target, :x_lag, :y_lag, :game_area
     
     def initialize(options = {})
       @x = options[:x] || 0
-      @y = options[:y] || 0
-      @angle = options[:angle] || 0
-      
-      #self.factor = options[:factor] || options[:scale] || 1.0
-      #@factor_x = options[:factor_x] if options[:factor_x]
-      #@factor_y = options[:factor_y] if options[:factor_y]
+      @y = options[:y] || 0 
+      @x_target = options[:x_target]
+      @y_target = options[:y_target]
+      @x_lag = options[:x_lag] || 0
+      @y_lag = options[:y_lag] || 0
+      @game_area = Chingu::Rect.new(options[:game_area]||[@x, @y, $window.width, $window.height])       
+    end
+    
+    #
+    # Set x_lag and y_lag to value 'lag'
+    #
+    def lag=(lag)
+      @x_lag = @y_lag = lag
+    end
+
+    #
+    # Center the viewport around the given object (it must respont to x/y)
+    # Center will fail if object is in the corners of the game area
+    #
+    def center_around(object)
+      self.x = object.x - $window.width / 2
+      self.y = object.y - $window.height / 2
+    end
+    
+    #
+    # Set a Rect that represents the borders of the game world.
+    # The viewport can only move within this Rect.
+    #
+    def game_area=(rect)
+      @game_area = Rect.new(rect)
+    end
+    
+    #
+    # Set a game world by giving it a game object
+    # The game objects image will be the rectangle the viewport can move within.
+    #
+    def game_area_object=(game_object)
+      image = (game_object.is_a? Gosu::Image) ? game_object : game_object.image
+      @game_area = Rect.new(0,0,
+                            (image.width*$window.factor) - $window.width, 
+                            (image.height*$window.factor) - $window.height
+                            )
+    end
+    
+    #
+    # Returns true if object is inside view port, false if outside
+    # TODO: add view port height and width! (and use clip_to when painting?)
+    #
+    # This is a very flawed implementation, it Should take inte account objects 
+    # height,width,factor_x,factor_y,center_x,center_y as well...
+    #
+    def inside?(object)
+      object.x >= @x && object.x <= (@x + $window.width) &&
+      object.y >= @y && object.y <= (@y + $window.height)
+    end
+
+    # Returns true object is outside the view port
+    def outside?(object)
+      not inside_viewport?(object)
+    end
       
-      #self.center = options[:center] || 0.5
-      #@rotation_center = options[:rotation_center]
-      #self.rotation_center(options[:rotation_center]) if options[:rotation_center]
+    #
+    # Returns true object is inside the game area
+    # The "game area" is the full map/world/area from which the viewport shows a slice
+    # The viewport can't show anything outside the game area
+    #
+    def inside_game_area?(object)        
+      object.x >= @game_area.x && object.x <= (@game_area.width + $window.width) &&
+      object.y >= @game_area.x && object.y <= (@game_area.height + $window.height)
+    end
       
-      #@center_x = options[:center_x] if options[:center_x]
-      #@center_y = options[:center_y] if options[:center_y]
+    # Returns true object is outside the game area
+    def outside_game_area?(object)
+      not inside_game_area?(object)
+    end
+
+    #
+    # Modify viewports x and y from target_x / target_y and x_lag / y_lag 
+    # Use this to have the viewport "slide" after the player
+    #
+    def move_towards_target			
+      if @x_target && @x != @x_target
+        x_step = @x_target - @x
+        self.x = @x + x_step * (1.0 - @x_lag)
+      end
       
-      @x_min = nil
-      @x_max = nil
-      @y_min = nil
-      @y_max = nil      
+      if @y_target && @y != @y_target
+        y_step = @y_target - @y
+        self.y = @y + y_step * (1.0 - @y_lag)
+      end
     end
     
+    #
+    # Viewports X setter with boundschecking
+    #
     def x=(x)
       @x = x
-      @x = @x_min   if @x_min && @x < @x_min
-      @x = @x_max   if @x_max && @x > @x_max
+      if @game_area
+        @x = @game_area.x       if @x < @game_area.x
+        @x = @game_area.width   if @x > @game_area.width
+      end 
     end
 
+		#
+		# Viewports Y setter with boundschecking
+		#
     def y=(y)
       @y = y
-      @y = @y_min   if @y_min && @y < @y_min
-      @y = @y_max   if @y_max && @y > @y_max
+      if @game_area
+        @y = @game_area.y       if @y < @game_area.y
+        @y = @game_area.height  if @y > @game_area.height
+      end
     end
     
   end

data/lib/chingu/window.rb

@@ -20,7 +20,6 @@
 #++
 
 module Chingu
-
   #
   # See http://www.libgosu.org/rdoc/classes/Gosu/Window.html
   #
@@ -40,6 +39,7 @@ module Chingu
     include Chingu::Helpers::InputClient        # Window has its own inputmap
     
     attr_reader :root, :game_state_manager, :game_objects, :milliseconds_since_last_tick
+    attr_accessor :factor
     
     def initialize(width = 800, height = 600, fullscreen = false, update_interval = 16.666666)
       fullscreen ||= ARGV.include?("--fullscreen")
@@ -56,9 +56,15 @@ module Chingu
       
       @fps_counter = FPSCounter.new
       @game_state_manager = GameStateManager.new
-      @milliseconds_since_last_tick = 0      
+      @milliseconds_since_last_tick = 0
+      @factor = 1
+      
+      setup
     end
     
+    # Placeholder to be overwritten
+    def setup; end;
+    
     #
     # 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)