chingu 0.8.0.5 → 0.8.1

data/lib/chingu/basic_game_object.rb

@@ -8,6 +8,8 @@ module Chingu
   # It will also acts as a container for the trait-system of chingu.
   #
   class BasicGameObject
+    class << self; attr_accessor :instances; end
+    
     include Chingu::Helpers::ClassInheritableAccessor # adds classmethod class_inheritable_accessor
     
     attr_reader :options, :paused
@@ -16,7 +18,7 @@ module Chingu
     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
@@ -66,7 +68,10 @@ module Chingu
     def initialize(options = {})
       @options = options
       @parent = options[:parent]
-      
+       
+      self.class.instances ||= Array.new
+      self.class.instances << self
+
       #
       # A GameObject either belong to a GameState or our mainwindow ($window)
       #
@@ -79,7 +84,7 @@ module Chingu
       # which then will pass it on to the next setup_trait() with a super-call.
       setup_trait(options)
       
-      setup if respond_to?(:setup)
+      setup
     end
 
     #
@@ -99,6 +104,12 @@ module Chingu
       #
       instance.parent.add_game_object(instance) if instance.parent
       
+      #
+      # Keep track of instances in class-variable
+      # Used for quick access to all isntances of a certain class, for example Enemy.all
+      #
+      #instances ||= Array.new
+      #instances << instance
       
       return instance
     end
@@ -107,6 +118,7 @@ module Chingu
     # Disable automatic calling of update() and update_trait() each game loop
     #
     def pause!
+      @parent.game_objects.pause_game_object(self)    if @parent && @paused == false
       @paused = true
     end
     alias :pause :pause!
@@ -115,6 +127,7 @@ module Chingu
     # Enable automatic calling of update() and update_trait() each game loop
     #
     def unpause!
+      @parent.game_objects.unpause_game_object(self)  if @parent && @paused == true
       @paused = false
     end
     alias :unpause :unpause!
@@ -153,8 +166,10 @@ module Chingu
     #   Bullet.all.each do {}  # Iterate through all bullets in current game state
     #
     def self.all
-      $window.current_scope.game_objects.of_class(self).dup
-    end
+      instances ? instances.dup : []
+      # instances ? instances.keys : []                         # for hash instance
+      #  $window.current_scope.game_objects.of_class(self).dup  # old school way
+    end    
     
     #
     # As Array.each on the instances of the current class
@@ -177,12 +192,11 @@ module Chingu
       all.select { |object| yield object }
     end
     
-    
     #
     # Returns the total amount of game objects based on this class
     #
     def self.size
-      $window.current_scope.game_objects.of_class(self).size
+      all.size
     end
     
     #
@@ -200,7 +214,8 @@ module Chingu
     #   Bullet.destroy_all    # Removes all Bullet objects from the game
     #
     def self.destroy_all
-      self.all.each { |object| object.destroy! }
+      all.each { |game_object| game_object.parent.remove_game_object(game_object) }
+      instances.clear if  instances
     end
 
     #
@@ -208,7 +223,8 @@ module Chingu
     # If the object isn't being managed by Chingu (ie. you're doing manual update/draw calls) the object is only frozen, not removed from any updae cycle (because you are controlling that).
     #
     def destroy
-      @parent.remove_game_object(self) if @parent
+      @parent.remove_game_object(self)  if @parent
+      self.class.instances.delete(self)
     end
     alias :destroy! :destroy
   end

data/lib/chingu/game_object_list.rb

@@ -26,11 +26,16 @@ module Chingu
   # An instance of GameObjectList is automaticly created as "game_objects" if using Chingu::Window
   #
   class GameObjectList
+    attr_reader :visible_game_objects, :unpaused_game_objects
         
     def initialize(options = {})
       @game_objects = options[:game_objects] || []
-      @add_game_objects = []
-      @remove_game_objects = []      
+      @visible_game_objects = []
+      @unpaused_game_objects = []
+      
+      #@game_objects = {}
+      #@visible_game_objects = {}
+      #@unpaused_game_objects = {}
     end
     
     def to_s
@@ -42,23 +47,42 @@ module Chingu
     end
     
     def destroy_all
-      @game_objects.clear
+      @game_objects.each { |game_object| game_object.destroy }
     end
     alias :clear :destroy_all
     alias :remove_all :destroy_all
     
+    def show_game_object(object)
+      @visible_game_objects.push(object)
+    end    
+    def hide_game_object(object)
+      @visible_game_objects.delete(object)
+    end
+    def pause_game_object(object)
+      @unpaused_game_objects.delete(object)
+    end
+    def unpause_game_object(object)
+      @unpaused_game_objects.push(object)
+    end
+    
     def add_game_object(object)
       @game_objects.push(object)
-      #@add_game_objects.push(object)
+      @visible_game_objects.push(object)  if object.respond_to?(:visible)  && object.visible
+      @unpaused_game_objects.push(object) if object.respond_to?(:paused)   && !object.paused
+      
+      #@game_objects[object] = true
+      #@visible_game_objects[object] = true  if object.respond_to?(:visible)  && object.visible
+      #@unpaused_game_objects[object] = true if object.respond_to?(:paused)   && !object.paused
     end
     
     def remove_game_object(object)
       @game_objects.delete(object)
-      #@remove_game_objects.push(object)
+      @visible_game_objects.delete(object)
+      @unpaused_game_objects.delete(object)
     end
     
     def destroy_if
-      @game_objects.reject! { |object| yield(object) }
+      @game_objects.select { |object| object.destroy if yield(object) }
     end
     
     def size
@@ -68,27 +92,28 @@ module Chingu
     def empty?
       @game_objects.empty?
     end
+
+    def update
+      @unpaused_game_objects.each { |go| go.update_trait; go.update; }
+    end
+    def force_update
+      @game_objects.each { |go| go.update_trait; go.update; }
+    end
     
     def draw
-      @game_objects.select { |object| object.visible }.each do |object|
-        object.draw_trait
-        object.draw
-      end
+      @visible_game_objects.each { |go| go.draw_trait; go.draw; }
+    end
+    def force_draw
+      @game_objects.each { |go| go.draw_trait; go.draw }
     end
 
     def draw_relative(x=0, y=0, zorder=0, angle=0, center_x=0, center_y=0, factor_x=0, factor_y=0)
-      @game_objects.select { |object| object.visible }.each do |object| 
+      @visible_game_objects.each do |object| 
         object.draw_trait
         object.draw_relative(x, y, zorder, angle, center_x, center_y, factor_x, factor_y)
       end
     end
           
-    def update
-      @game_objects.select { |object| not object.paused }.each do |object| 
-        object.update_trait 
-        object.update
-      end
-    end
     
     def each
       @game_objects.dup.each { |object| yield object }
@@ -146,14 +171,5 @@ module Chingu
     end
     alias :show :show!
     
-    private
-    
-    def sync
-      @game_objects += @add_game_objects
-      @add_game_objects.clear
-      
-      @game_objects -= @remove_game_objects
-      @remove_game_objects.clear      
-    end    
   end  
 end

data/lib/chingu/game_object_map.rb

@@ -23,14 +23,32 @@ module Chingu
   #
   # ** This class is under heavy development, API will most likely change! **
   #
-  # GameObjectMap can convert any set of game objects into a 2D-array for fast lookup
-  # You can set any gridsize with :grid, defaults to [32,32]. The smaller the grid the more memory it will eat.
+  # GameObjectMap can map any set of game objects into a 2D-array for fast lookup.
+  # You can choose gridsize with the :grid-parameter, defaults to [32,32]. 
+  # The smaller the grid the more memory GameObjectMap will eat.
+  #
+  # The game objects sent to GameObjectMap must respond to #bb (as provided by trait :bounding_box)
+  # This is needed to calcuate what cells in the grid each game object covers.
   #
   # Basic usage:
   #   @map = GameObjectMap.new(:game_objects => TerrainObject.all, :grid => [32, 32])
   #   @map.at(100, 100)         # returns one TerrainObject at x/y: 100/100
   #   @map.game_object(player)  # returns one TerrainObject which collides with player.bounding_box
   #
+  # A GameObjectMap is ment to be used for static non-moving objects, where a map can be calculated once and then used for fast lookups.
+  # This makes GameObjectMap very well suited for terrain for a player to walk on / collide with.
+  #
+  # One cell in the GameObjectMap can only be occupied by one game object.
+  # If you need many objects at the same cell, use 2 GameObjectMaps, something like:
+  #
+  #   @terrain = GameObjectMap.new(:game_objects => Terrain.all)
+  #   @mines = GameObjectMap.new(:game_objects => Mine.all)
+  #
+  #   @player.stop_falling  if @terrain.at(@player.x, @player)
+  #   @player.die           if @mine.at(@player.x, @player)
+  #
+  # Take note, since there can be only 1 game object per cell a huge game object could very well "cover out" another smaller game objects occupying the same cells.
+  #
   # ** This class is under heavy development, API will most likely change! **
   #
   class GameObjectMap
@@ -52,7 +70,7 @@ module Chingu
       @game_object_positions = {}
             
       @game_objects.each do |game_object|
-        puts "#{game_object.class} @ #{game_object.x} / #{game_object.y}" if @debug
+        puts "#{game_object.class} @ #{game_object.x}/#{game_object.y} - #{game_object.bb}" if @debug
         insert(game_object)                
       end
     end
@@ -73,15 +91,17 @@ module Chingu
         @map[x] ||= []
         (start_y ... stop_y).each do |y|
           @map[x][y] = game_object
+          puts "#{game_object.class} => map[#{x}][#{y}]" if @debug
         end
       end      
     end
         
     #
-    # Removes a specific game object from the map
+    # Removes a specific game object from the map, replace the cell-value with nil
     #
     def delete(game_object)
       range_x, range_y = @game_object_positions[game_object]
+      return unless range_x && range_y
       
       range_x.each do |x|
         range_y.each do |y|
@@ -92,7 +112,7 @@ module Chingu
     alias :clear_game_object :delete
       
     #
-    # Clear game object from the array-map on a certain X/Y
+    # Clear the game object residing in the cell given by real world coordinates x/y
     #
     def clear_at(x, y)
       lookup_x = (x / @grid[0]).to_i
@@ -101,14 +121,17 @@ module Chingu
     end
 
     #
-    # Gets a game object from the array-map on a certain X/Y
+    # Gets game object from map that resides on real world coordinates x/y
     #
     def at(x, y)
       lookup_x = (x / @grid[0]).to_i
       lookup_y = (y / @grid[1]).to_i
-      @map[lookup_x][lookup_y]  rescue nil
+      @map[lookup_x][lookup_y]  rescue nil  # Benchmark this against @map[lookup_x] && @map[lookup_x][lookup_y] => prob faster
     end
 
+    #
+    # Return the first game object occupying any of the cells that given 'game_object' covers
+    #
     def from_game_object(game_object)
       start_x = (game_object.bb.left / @grid[0]).to_i
       stop_x =  (game_object.bb.right / @grid[0]).to_i
@@ -126,7 +149,7 @@ module Chingu
     end
     
     #
-    # Yields each object in the map colliding with the given game object
+    # Yields all game objects occupying any of the cells that given 'game_object' covers
     #
     def each_collision(game_object)
       start_x = (game_object.bb.left / @grid[0]).to_i

data/lib/chingu/helpers/game_object.rb

@@ -40,6 +40,20 @@ module Chingu
       @game_objects
     end
     
+    def show_game_object(object)
+      @game_objects.show_game_object(object)
+    end    
+    def hide_game_object(object)
+      @game_objects.hide_game_object(object)
+    end
+    def pause_game_object(object)
+      @game_objects.pause_game_object(object)
+    end
+    def unpause_game_object(object)
+      @game_objects.unpause_game_object(object)
+    end 
+    
+    
     #
     # Fetch game objects of a certain type/class
     #

data/lib/chingu/traits/retrofy.rb

@@ -29,24 +29,32 @@ module Chingu
     #
     module Retrofy
     
-      def setup_trait(options)
-        @retrofy_options = {:debug => false}.merge(options)        
-        super
+      #def setup_trait(options)
+      #  @retrofy_options = {:debug => false}.merge(options)        
+      #  super
+      #end
+
+      def retrofied_x=(x)
+        self.x = x / self.factor
       end
-      
-      def screen_width
-        (self.image.width * self.factor).to_i
+
+      def retrofied_y=(y)
+        self.y = y / self.factor
+      end
+
+      def real_x
+        (self.x / self.factor).to_i
       end
 
-      def screen_height
-        (self.image.heigt * self.factor).to_i
+      def real_y
+        (self.y / self.factor).to_i
       end
 
-      def screen_x
+      def retrofied_x
         (self.x * self.factor).to_i
       end
 
-      def screen_y
+      def retrofied_y
         (self.y * self.factor).to_i
       end
 

data/lib/chingu/traits/simple_sprite.rb

@@ -0,0 +1,252 @@
+#--
+# Part of Chingu -- OpenGL accelerated 2D game framework for Ruby
+# Copyright (C) 2009 ippa / ippa@rubylicio.us
+#
+# Written/Refactored by Jakub Hozak - jakub.hozak@gmail.com
+#
+#++
+
+module Chingu
+  module Traits
+
+    #
+    # A Chingu trait providing ability to be drawn as an image.
+    #
+    # Example:
+    # 
+    #   class Rocket < BasicGameObject
+    #     trait :simple_sprite
+    #   end
+    #
+    #   Rocket.create(:x => 100, :y => 200)
+    #
+    # Options:
+    #  :image - actual sprite to draw
+    #         - see #image= for details as this method is used to set this option
+    #  
+    # Introducing Variables:
+    #  :x, :y, :zorder, :factor_x, :factor_y, :mode, :color, :visible
+    #
+    module SimpleSprite      
+      module ClassMethods
+        def initialize_trait(options = {})
+          trait_options[:sprite] = options
+        end
+      end
+      
+      attr_accessor :x, :y, :angle, :factor_x, :factor_y, :zorder, :mode, :color
+      attr_reader :factor, :center, :height, :width, :image     
+      attr_accessor :visible # kill this? force use of setter      
+
+      def setup_trait(object_options = {})        
+        @visible = true   unless options[:visible] == false
+        self.image =  options[:image]  if options[:image]
+        self.color =  options[:color] || ::Gosu::Color::WHITE.dup
+        self.alpha =  options[:alpha]  if options[:alpha]
+        self.mode =   options[:mode] || :default
+        self.x =      options[:x] || 0
+        self.y =      options[:y] || 0
+        self.zorder = options[:zorder] || 100
+        
+        self.factor = options[:factor] || options[:scale] || $window.factor || 1.0
+        self.factor_x = options[:factor_x].to_f if options[:factor_x]
+        self.factor_y = options[:factor_y].to_f if options[:factor_y]
+        
+        if self.image
+          self.width  = options[:width]   if options[:width]
+          self.height = options[:height]  if options[:height]
+          self.size   = options[:size]    if options[:size]
+        end
+        
+        super
+      end
+      
+      #
+      # Let's have some useful information in to_s()
+      #
+      def to_s
+        "#{self.class.to_s} @ #{x.to_i} / #{y.to_i} " <<
+        "(#{width.to_i} x #{height.to_i}) - " <<
+        " ratio: #{sprintf("%.2f",width/height)} scale: #{sprintf("%.2f", factor_x)}/#{sprintf("%.2f", factor_y)} angle: #{angle.to_i} zorder: #{zorder} alpha: #{alpha}"
+      end
+
+      def color=(color)
+        @color = color.is_a?(Gosu::Color) ? color : Gosu::Color.new(color || 0xFFFFFFFF)
+      end
+
+      #
+      # Accepts String, callable object or any-other non-nil capable
+      # of drawing itself on screen.
+      #
+      # Examples:
+      #   image = 'rocket.png'
+      #   image = Gosu::Image.new($window, 'rocket.png')
+      #     
+      #    image = lambda do
+      #      # TexPlay is library for Gosu image generation
+      #      TexPlay.create_image($window,10,10).paint { circle(5,5,5, :color => :red) }
+      #    end
+      #
+      def image=(image)
+        raise ArgumentError.new("No image set") if image.nil?
+        
+        @image = if String === image
+                   # 1) Try loading the image the normal way
+                   # 2) Try looking up the picture using Chingus Image-cache
+                   Gosu::Image.new($window, image,false) rescue Gosu::Image[image]
+                 elsif image.respond_to? :call
+                   image.call
+                 else
+                   image
+                 end
+      end
+
+      #
+      # Get all settings from a game object in one array.
+      # Complemented by the GameObject#attributes= setter.
+      # Makes it easy to clone a objects x,y,angle etc.
+      #
+      def attributes
+        [@x, @y, @angle, @factor_x, @factor_y, @color, @mode, @zorder]
+      end
+  
+      #
+      # Set all attributes on 1 line
+      # Mainly used in combination with game_object1.attributes = game_object2.attributes
+      #
+      def attributes=(attributes)
+        self.x, self.y, self.angle, self.factor_x, self.factor_y, self.color, self.mode, self.zorder = *attributes
+      end
+
+      #
+      # Set an effective width for the object on screen.
+      # Chingu does this by setting factor_x depending on imge.width and width given.
+      # Usually better to have a large image and make it smaller then the other way around.
+      #
+      def width=(width)
+        @factor_x = width.to_f / @image.width.to_f  if @image
+      end
+      
+      #
+      # Get effective  width by calculating it from image-width and factor_x
+      #
+      def width
+        (@image.width * @factor_x).abs              if @image
+      end
+
+      #
+      # Set an effective height for the object on screen.
+      # Chingu does this by setting factor_x depending on imge.width and width given.
+      # Usually better to have a large image and make it smaller then the other way around.
+      #
+      def height=(height)
+        @factor_y = height.to_f / @image.height.to_f  if @image
+      end
+    
+      #
+      # Get effective height by calculating it from image-width and factor
+      #
+      def height
+        (@image.height.to_f * @factor_y).abs        if @image
+      end
+
+      # Set width and height in one swoop
+      def size=(size)
+        self.width, self.height = *size
+      end
+    
+      # Get objects width and height in an array
+      def size
+        [self.width, self.height]
+      end
+      
+      # Quick way of setting both factor_x and factor_y
+      def factor=(factor)
+        @factor = @factor_x = @factor_y = factor
+      end
+      alias scale= factor=
+      alias scale factor
+      
+    
+      # Get objects alpha-value (internally stored in @color.alpha)
+      def alpha
+        @color.alpha
+      end
+    
+      # Set objects alpha-value (internally stored in @color.alpha)
+      # If out of range, set to closest working value. this makes fading simpler.
+      def alpha=(value)
+        value = 0   if value < 0
+        value = 255 if value > 255
+        @color.alpha = value
+      end
+
+      #
+      # Sets angle, normalize it to between 0..360
+      #
+      def angle=(value)
+        if value < 0
+          value = 360+value
+        elsif value > 360
+          value = value-360
+        end
+        @angle = value
+      end
+
+      #
+      # Disable automatic calling of draw and draw_trait each game loop
+      #
+      def hide!
+        @parent.game_objects.hide_game_object(self)  if @parent && @visible == true
+        @visible = false
+      end
+    
+      #
+      # Enable automatic calling of draw and draw_trait each game loop
+      #
+      def show!
+        @parent.game_objects.show_game_object(self)  if @parent && @visible == false
+        @visible = true
+      end
+    
+      #
+      # Returns true if visible (not hidden)
+      #
+      def visible?
+        @visible == true
+      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
+
+      #
+      # Our encapsulation of GOSU's image.draw_rot, uses the objects variables to draw it on screen if @visible is true
+      #
+      def draw
+        @image.draw(@x, @y, @zorder, @factor_x, @factor_y, @color, @mode)  if @image
+      end
+
+      #
+      # Works as #draw() but takes offsets for all draw_rot()-arguments. Used among others by the viewport-trait.
+      #      
+      def draw_relative(x=0, y=0, zorder=0,  factor_x=0, factor_y=0)
+        @image.draw(@x+x, @y+y, @zorder+zorder, @factor_x+factor_x, @factor_y+factor_y, @color, @mode)  if @image
+      end
+
+      #
+      # Works as #draw() but takes x/y arguments. Used among others by the edit-game state.
+      #      
+      def draw_at(x, y)
+        draw_relative(x,y)
+      end
+    end
+  end
+end