ippa-chingu 0.3.1 → 0.4.0

data/README.rdoc

@@ -227,7 +227,11 @@ Another more complex example:
   
   class Play < Chingu::GameState
     def initialize
-      self.input = { :p => Pause, :escape => :close, :holding_left => :move_left, :holding_right => :move_right, :released_space => :fire }
+      self.input = { :p => Pause, 
+                     :escape => :close, 
+                     :holding_left => :move_left, 
+                     :holding_right => :move_right, 
+                     :released_space => :fire }
     end
   end
   class Pause < Chingu::GameState
@@ -237,12 +241,13 @@ Another more complex example:
 In Gosu the above code would include code in button_up(), button_down() and a check for button_down?() in update().
 
 Every symbol can be prefixed by either "released_" or "holding_" while no prefix at all defaults to pressed once.
+
 So, why not :up_space or :relase_space instead of :released_space?
-Or :hold_left or :down_left instead of :holding_left?
++:up_space+ doesn't sound like english, :release_space sounds more like a command then an event.
 
-:up_space doesn't sound like english, :release_space sounds more like a command then an event.
 
-:holding_left sounds like something that's happening over a period of time, not a single trigger, which corresponds good to what's happening when using it.
+Or +:hold_left+ or :down_left instead of :holding_left?
+:holding_left sounds like something that's happening over a period of time, not a single trigger, which corresponds well to how it works.
 
 And with the default :space => :something youd imagine that :something is called once. You press :space once, :something get's executed once.
 
@@ -271,7 +276,7 @@ Game states aren't complicated. In Chingu a GameState is a class that behaves mo
       @player.angle = 0   # point player upwards
     end
     
-    # Called when we leave the current game state
+    # Called when we leave the game state
     def finalize
       push_game_state(Menu)   # switch to game state "Menu"
     end
@@ -292,23 +297,56 @@ You can activate the above game state in 2 ways
       
       #
       # 2) This leaves the actual object-creation to the game state manager.
-      # This results in only 1 object is ever created of class 'Intro'.
-      # The second time 'push_game_state(Intro)' is called, it will re-use the last one.
-      # This means code in Intro#initialize() is only  called once, Intro#setup() is called everytime Intro is activated though.
+      # Intro#initialize() is called, then Intro#setup()
       #
       push_game_state(Intro)
     end
   end
+
+Another example:
+
+  class Game < Chingu::Window
+    def initialize
+      #
+      # We start by pushing Menu to the game state stack, making it active as the only state on stack.
+      # :setup => :false which will skip setup() from beeing called (standard when switching to a new state)
+      #
+      push_game_state(Menu, :setup => false)
+      
+      #
+      # We push another game state to the stack, Play. We now have 2 states, which active beeing first / active.
+      #
+      # :finalize => false will skip setup() from beeing called on game state 
+      # that's beeing pushed down the stack, in this case Intro.setup().
+      #
+      push_game_state(Play, :finalize => false)
+    
+      #
+      # This would remove Play state from the stack, going back to the Menu-state. But also:
+      # .. skipping the standard call to Menu#setup     (the new game state)
+      # .. skipping the standard call to Play#finalize  (the current game state)
+      #
+      # :setup => false can for example be useful when pop'ing a Pause game state. (see example4.rb)
+      #
+      pop_game_state(:setup => false, :finalize => :false)
+      
+      #
+      # Replace the current game state with a new one.
+      # :setup and :finalize options are available here as well.
+      #
+      switch_game_state(Credits)
+    end
+  end
   
 A GameState in Chingu is just a class with the following instance methods: 
 
-* initialize()  - called only once with push_game_state(Intro) but everytime with push_game_state(Intro.new)
-* setup()       - called each time the game state becomes active. 
+* initialize()    - called only once with push_game_state(Intro) but everytime with push_game_state(Intro.new)
+* setup()         - called each time the game state becomes active. 
 * button_down(id) - Called when a button is down
 * button_up(id)   - Called when a button is released
-* update()    - just as in your normal game loop, put your game logic here.
-* draw()      - just as in your normal game loop, put your screen manipulation here.
-* finalize()  - called when a game state de-activated (for example by pushing a new one on top with push_game_state)
+* update()        - just as in your normal game loop, put your game logic here.
+* draw()          - just as in your normal game loop, put your screen manipulation here.
+* finalize()      - called when a game state de-activated (for example by pushing a new one on top with push_game_state)
 
 Chingu::Window automatically creates a @game_state_manager and makes it accessible in our game loop.
 By default the game loop calls update() / draw() on the the current game state.
@@ -317,6 +355,7 @@ Chingu also has a couple of helpers-methods for handling the game states:
 In a main loop or in a game state:
 * push_game_state(state)        - adds a new gamestate on top of the stack, which then becomes the active one
 * pop_game_state                - removes active gamestate and activates the previous one
+* switch_game_state(state)      - replaces current game state with a new one
 * current_game_state            - returns the current game state
 * previous_game_state           - returns the previous game state (useful for pausing and dialog boxes, see example4.rb)
 * pop_until_game_state(state)   - pop game states until given state is found
@@ -333,10 +372,10 @@ Or Chingus shortcut:
 
   class Intro < Chingu::GameState
     def setup
-      self.input = { :space => Menu }      #  or { :space => Menu.new } if you want to create a new object each time.
+      self.input = { :space => Menu }
     end
   end
-
+  
 Chingus inputhandler will detect that Menu is a gamestate-class, create a new instance, cache it and activate it with push_game_state().
 
 === Assets / Paths
@@ -350,12 +389,23 @@ For a local development version this might not be important, you're likely to st
 But as soon as you try to deploy (for example to windows with OCRA - http://github.com/larsch/ocra/tree/master) you'll run into trouble of you dont do it like that.
  
 Chingu solves this problem behind the scenes for the most common assets. The 2 lines above can be replaced with:
-Image["player.png"]
+  Image["player.png"]
+
+You also have:
+  Sound["shot.png"]
+  Song["intromusic.ogg"]
+
+By default Image, Sound and Sound searches the current directory and directory "media".
+Add your own searchpaths like this:
+  Gosu::Image.autoload_dirs << File.join($window.root, "gfx")
+  Gosu::Sound.autoload_dirs << File.join($window.root, "samples")
 
-You also have Sound["player.png"]
+This will add \path\to\your\game\gfx and \path\to\your\game\samples  to Image and Sound.
+  
+Thanks to Jacious of rubygame-fame (http://rubygame.org/) for his named resource code powering this.
 
 Tiles and fonts are trickier since they require extra parameters so you'll have to do those the ordinary way.
-You'll get $window.root (equivalent to ROOT_PATH above) for free though which points to the dir containing the game.
+You have $window.root (equivalent to ROOT_PATH above) for free though which points to the dir containing the game.
 
 === Text
 Text is a class to give the use of Gosu::Font more rubyish feel and fit it better into Chingu.
@@ -372,6 +422,13 @@ Text is a class to give the use of Gosu::Font more rubyish feel and fit it bette
 It's not only that the second example is readable by ppl now even familiar with Gosu, @text comes with a number of changeable properties, x,y,zorder,angle,factor_x,color,mode etc. Set a new x or angle or color and it will instantly update on screen.
 
 
+== MISC / FAQ
+How do I access my main-window easily?
+
+Chingu keeps a global variable, $window, which contains the Chingu::Window instance. 
+Since Chingu::Window is just Gosu::Window + some cheese you can do your $window.button_down?, $window.draw_line() etc from anywhere.
+See http://www.libgosu.org/rdoc/classes/Gosu/Window.html for a full set of methods.
+
 == TODO:
 * (done) Complete the input-definitions with all possible inputs (keyboard, gamepad, mouse)!
 * (done) Complete input-stuff with released-states etc
@@ -380,21 +437,22 @@ It's not only that the second example is readable by ppl now even familiar with
 * (done) Generate docs @ ippa.github.com-  http://rdoc.info/projects/ippa/chingu !
 * (done) A good scene-manager to manage welcome screens, levels and game flow- GameStateManager / GameState !
 * More docs
-* make a playable simple game in examples\ that really depends on game states
+* (20% done) make a playable simple game in examples\ that really depends on game states
 * (done) Make a gem- first gem made on github
-* Automate gemgenning rake-task even more
+* (done) Automate gemgenning rake-task even more
 * More examples when effects are more complete
 * class ChipmunkObject
 * class Actor/MovingActor with maybe abit more logic then the basic GameObject. Would ppl find is useful?
-* Spell check all docs, sloppy spelling turns ppl off.
+* (40% done) Spell check all docs, sloppy spelling turns ppl off.
 * Tests
 * (done) Streamline fps / tick code
 * (done) Encapsulate Font.new / draw_rot with a "class Text < GameObject"
 * (10% done) Make it possible for ppl to use the parts of Chingu they like
+* At least make GameStateManager really easy to use with pure Gosu / Document it!
 * A more robust game state <-> game_object system to connect them together.
-* Get better at styling rdocs
+* (50% done) Get better at styling rdocs
 * (done) all �gamestate� ? �game state� ?   it's "game state"
-* intergrate rubygame_movie_make (maybe after a rename, GameAutomator? GameSequence?
+* intergrate MovieMaker
 * FIX example4: :p => Pause.new  would Change the "inside_game_state" to Pause and make @player belong to Pause.
 
 == WHY?

data/chingu.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{chingu}
-  s.version = "0.3.1"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["ippa"]
-  s.date = %q{2009-08-14}
+  s.date = %q{2009-08-19}
   s.description = %q{Game framework built on top of the OpenGL accelerated game lib Gosu.  It adds simple yet powerfull game states, prettier inputhandling, deploymentsafe asset-handling, a basic re-usable game object and automation of common task.}
   s.email = ["ippa@rubylicio.us"]
   s.extra_rdoc_files = ["History.txt", "Manifest.txt"]

data/lib/chingu/assets.rb

@@ -4,55 +4,54 @@
 # Quick 'n easy access to sprites, sounds and tiles!
 #
 module Chingu
-
-	def media_path(file)
-		File.join($window.root, "media", file)
-	end
-	
-	def image_path(file)
-		File.join($window.root, "gfx", file)
-	end
-	
-	class ImagePath
-		include Chingu::NamedResource
+  def media_path(file)
+    File.join($window.root, "media", file)  
+  end
+  
+  def image_path(file)
+    File.join($window.root, "gfx", file)
+  end
+  
+  class ImagePath
+    include Chingu::NamedResource
 		
-		def self.autoload(name)
-			find_file(name)
-		end
-	end
+    def self.autoload(name)
+    find_file(name)
+    end
+  end
 end
 
 module Gosu
-	class Image
-		include Chingu::NamedResource
-	
-		def self.autoload(name)
-			(path = find_file(name)) ? Gosu::Image.new($window, path, true) : nil
-		end
-	end
+  class Image
+    include Chingu::NamedResource
+    
+    def self.autoload(name)
+      (path = find_file(name)) ? Gosu::Image.new($window, path, true) : nil
+    end
+  end
 
-	class Song
-		include Chingu::NamedResource
-	
-		def self.autoload(name)
-			(path = find_file(name)) ? Gosu::Song.new($window, path) : nil
-		end
-	end
-
-	class Sample
-		include Chingu::NamedResource
-	
-		def self.autoload(name)
-			(path = find_file(name)) ? Gosu::Sample.new($window, path) : nil
-		end
-	end
-	Sound = Sample
+  class Song
+    include Chingu::NamedResource
+		
+    def self.autoload(name)
+      (path = find_file(name)) ? Gosu::Song.new($window, path) : nil
+    end
+  end
+  
+  class Sample
+    include Chingu::NamedResource
+    
+    def self.autoload(name)
+      (path = find_file(name)) ? Gosu::Sample.new($window, path) : nil
+    end
+  end
+  Sound = Sample
 	
-	class Tile
-		include Chingu::NamedResource	
+  class Tile
+    include Chingu::NamedResource	
 	
-		def self.autoload(name)
-			(path = find_file(name)) ? Gosu::Image.load_tiles($window, path, 32, 32, true) : nil
-		end
-	end
+    def self.autoload(name)
+      (path = find_file(name)) ? Gosu::Image.load_tiles($window, path, 32, 32, true) : nil
+    end
+  end
 end

data/lib/chingu/game_object.rb

@@ -8,7 +8,7 @@ module Chingu
   class GameObject
     attr_accessor :image, :x, :y, :angle, :center_x, :center_y, :factor_x, :factor_y, :color, :mode
     attr_accessor :update, :draw
-    attr_reader :options
+    attr_reader :options, :parent
     
     include Chingu::InputClient
     
@@ -98,15 +98,42 @@ module Chingu
       @parent.add_game_object(self)  if @parent
     end
     
+    #
+    # Quick way of setting both factor_x and factor_y
+    #
     def factor=(factor)
-      @factor = factor
-      @factor_x = @factor_y = @factor
+      @factor_x = @factor_y = factor
     end
-    alias :zoom= :factor=
-    def factor
-      @factor
+
+    #
+    # Quick way of setting both center_x and center_y
+    #
+    def center=(factor)
+      @center_x = @center_y = factor
+    end
+
+    #
+    # Zoom - increase @factor_x and @factor_y at the same time.
+    #
+    def zoom(amount)
+      @factor_x += amount
+      @factor_y += amount
+    end
+
+    #
+    # Zoom Out - decrease @factor_x and @factor_y at the same time.
+    #
+    def zoom_out(amount)
+      @factor_x -= amount
+      @factor_y -= amount
+    end
+
+    #
+    # Rotate object 'amount' degrees
+    #
+    def rotate(amount)
+      @angle += amount
     end
-    alias :zoom :factor
     
     #
     # Returns true if game object is inside the game window, false if outside

data/lib/chingu/game_state.rb

@@ -34,16 +34,17 @@ module Chingu
     include Chingu::InputClient
     
     attr_reader :options                # so jlnr can access his :level-number
-    attr_reader :game_objects, :do_setup
+    attr_reader :game_objects
     
     def initialize(options = {})
       @options = options
-      @do_setup = options[:setup] || true
-      
       @game_objects = Set.new
-      @input_clients = Set.new  # Set is like a unique Array with Hash lookupspeed
+      @input_clients = Set.new          # Set is like a unique Array with Hash lookupspeed
       
-      $window.game_state_manager.inside_state = self
+      # Game state mamanger can be run alone
+      if defined?($window) && $window.respond_to?(:game_state_manager)
+        $window.game_state_manager.inside_state = self
+      end
     end
     
     #
@@ -53,12 +54,16 @@ module Chingu
     def to_sym
       self.class.to_s.to_sym
     end
-    
+
+    def to_s
+      self.class.to_s
+    end
+
     def add_game_object(object)
       @game_objects << object
     end
     def remove_game_object(object)
-      @input_clients.delete(object)
+      @game_objects.delete(object)
     end
     
     def setup

data/lib/chingu/game_state_manager.rb

@@ -2,103 +2,144 @@ module Chingu
   #
   # GameStateManger is responsible for keeping track of game states with a simple pop/push stack.
   #
+  # Related blogpost: http://gamedevgeek.com/tutorials/managing-game-states-in-c/
+  #
   # Chingu::Window automatically creates a @game_state_manager and makes it accessible in our game loop.
   # By default the game loop calls update() / draw() on @game_state_manager
   #
   class GameStateManager
     attr_accessor :inside_state
-    attr_reader :states, :created_states
     
     def initialize
       @inside_state = nil
-      @states = []
-      @created_states = {}
+      @game_states = []
     end
 
     #
     # Gets the currently active gamestate (top of stack)
     #
-    def current_state
-      @states.last
+    def current_game_state
+      @game_states.last
     end
+    alias :current current_game_state
 
     #
-    # Adds a state to the game state-stack and activates it
+    # Returns all gamestates with top of stack first
     #
-    def push_state(state, options = {})
-      new_state = nil
+    def game_states
+      @game_states.reverse
+    end
+    
+    #
+    # Switch to a given game state, _replacing_ the current active one.
+    #
+    def switch_game_state(state, options = {})
+      options = {:setup => true, :finalize => true}.merge(options)
 
-      #
-      # If state is a GameState-instance, just queue it
-      #
-      if state.is_a? Chingu::GameState
-        new_state = state
-      #
-      # If state is a GameState-class, create/initialize it once (@created_states keeps track of this)
-      #        
-      elsif state.superclass == Chingu::GameState
+      new_state = game_state_instance(state)
+      
+      if new_state
+        # Give the soon-to-be-disabled state a chance to clean up by calling finalize() on it.
+        current_game_state.finalize   if current_game_state.respond_to?(:finalize) && options[:finalize]
         
-        if @created_states[state.to_s]
-          new_state = @created_states[state.to_s]
+        # Call setup
+        new_state.setup               if new_state.respond_to?(:setup) && options[:setup]
+        
+        
+        if current_game_state.nil?
+          @game_states << new_state
         else
-          new_state = state.new(options)
-          @created_states[state.class.to_s] = new_state
+          # Replace last (active) state with new one
+          @game_states[-1] = new_state
         end
       end
+    end
+    alias :switch :switch_game_state
+    
+    #
+    # Adds a state to the game state-stack and activates it
+    #
+    def push_game_state(state, options = {})
+      options = {:setup => true, :finalize => true}.merge(options)
 
-      #
-      # If the new state is all good
-      #
+      new_state = game_state_instance(state)
+      
       if new_state
         # Give the soon-to-be-disabled state a chance to clean up by calling finalize() on it.
-        current_state.finalize  if current_state.respond_to? :finalize
+        current_game_state.finalize   if current_game_state.respond_to?(:finalize) && options[:finalize]
         
         # Call setup
-        new_state.setup         if new_state.do_setup
+        new_state.setup               if new_state.respond_to?(:setup) && options[:setup]
         
         # Push new state on top of stack and therefore making it active
-        @states.push(new_state)
+        @game_states.push(new_state)
       end
     end
+    alias :push :push_game_state
     
     #
     # Pops a state off the game state-stack, activating the previous one.
     #
-    def pop_state(options = {})
+    def pop_game_state(options = {})
+      options = {:setup => true, :finalize => true}.merge(options)
+      
       #
       # Give the soon-to-be-disabled state a chance to clean up by calling finalize() on it.
       #
-      current_state.finalize  if current_state.respond_to? :finalize
+      current_game_state.finalize    if current_game_state.respond_to?(:finalize) && options[:finalize]
       
       #
       # Activate the game state "bellow" current one with a simple Array.pop
       #
-      @states.pop
+      @game_states.pop
 
       # Call setup on the new current state
-      current_state.setup       unless options[:setup] == false
+      current_game_state.setup       if current_game_state.respond_to?(:setup) && options[:setup]
     end
-    
+    alias :pop :pop_game_state
+
+    #
+    # Returns a GameState-instance from either a class or object
+    #
+    def game_state_instance(state)
+      new_state = nil
+      #
+      # If state is a GameState-instance, just queue it
+      #
+      if state.is_a? Chingu::GameState
+        new_state = state
+      #
+      # If state is a GameState-class, create it.
+      #        
+      elsif state.superclass == Chingu::GameState
+        new_state = state.new({})
+      end
+      
+      return new_state
+    end
+
+
     #
     # Returns the previous game state
     #
-    def previous_state
-      @states[@states.index(current_state)-1]
+    def previous_game_state
+      @game_states[@game_states.index(current_game_state)-1]
     end
-    alias :prev_state previous_state
+    alias :previous previous_game_state
     
     #
     # Remove all game states from stack
     #
-    def clear_states
-      @states.clear
+    def clear_game_states
+      @game_states.clear
     end
+    alias :clear :clear_game_states
     
     #
     # Pops through all game states until matching a given game state
     #
     def pop_until_game_state(new_state)
-      while (state = @states.pop)
+      while (state = @game_states.pop)
         break if state == new_state
       end
     end
@@ -114,27 +155,27 @@ module Chingu
     # Called before #update when the user pressed a button while the window had the focus. 
     #
     def button_down(id)
-      current_state.button_down(id) if current_state
+      current_game_state.button_down(id) if current_game_state
     end
     
     #
     # Called when the user released a button. 
     #
     def button_up(id)
-      current_state.button_up(id)   if current_state
+      current_game_state.button_up(id)  if current_game_state
     end
     
     #
     # Calls #update on the current gamestate, if there is one.
     #
-    def update(time = 1)
-      current_state.update(time)  if current_state
+    def update(time = nil)
+      current_game_state.update(time)   if current_game_state
     end
     #
     # Calls draw() on the current gamestate, if there is one.
     #
     def draw
-      current_state.draw    if current_state
+      current_game_state.draw           if current_game_state
     end
   end
 end

data/lib/chingu/helpers.rb

@@ -21,7 +21,7 @@ module Chingu
     end
 
     def dispatch_button_down(id, object)
-      return if object.nil? || object.input.nil?
+      return if(object.nil? || object.input.nil?)
       
       object.input.each do |symbol, action|
         if Input::SYMBOL_TO_CONSTANT[symbol] == id
@@ -95,23 +95,27 @@ module Chingu
   #
   module GameStateHelpers
     def push_game_state(state, options = {})
-      $window.game_state_manager.push_state(state, options)      
+      $window.game_state_manager.push_game_state(state, options)      
     end
   
     def pop_game_state(options = {})
-      $window.game_state_manager.pop_state(options)
+      $window.game_state_manager.pop_game_state(options)
+    end
+
+    def switch_game_state(state, options = {})
+      $window.game_state_manager.switch_game_state(state, options)
     end
 
     def current_game_state
-      $window.game_state_manager.current_state
+      $window.game_state_manager.current_game_state
     end
 
     def previous_game_state
-      $window.game_state_manager.previous_state
+      $window.game_state_manager.previous_game_state
     end
-
+    
     def clear_game_states
-      $window.game_state_manager.clear_states
+      $window.game_state_manager.clear_game_states
     end
   end
 

data/lib/chingu/text.rb

@@ -34,8 +34,8 @@ module Chingu
     def initialize(options)
       super(options)
       @text = options[:text] || "-No text specified-"
-      @font =  options[:font] || @@font || "verdana"
-      @height = options[:height] || options[:size] || @@size || default_font_name()
+      @font =  options[:font] || @@font || default_font_name()
+      @height = options[:height] || options[:size] || @@size || 15
       
       @gosu_font = Gosu::Font.new($window, @font, @height)
     end

data/lib/chingu/window.rb

@@ -1,5 +1,5 @@
 module Chingu
-	class Window < Gosu::Window
+  class Window < Gosu::Window
     # adds push_game_state, pop_game_state, current_game_state and previous_game_state
     include Chingu::GameStateHelpers    
     
@@ -15,9 +15,8 @@ module Chingu
     # input= and input
     include Chingu::InputClient
     
-		attr_reader :root, :game_state_manager, :game_objects, :milliseconds_since_last_tick
-  
-		
+    attr_reader :root, :game_state_manager, :game_objects, :milliseconds_since_last_tick
+    
     #
     # See http://www.libgosu.org/rdoc/classes/Gosu/Window.html
     #
@@ -29,58 +28,56 @@ module Chingu
     # - Assethandling with Image["picture.png"] and Sample["shot.wav"]
     # - Default input mapping escape to close 
     #
-		def initialize(width = 640, height = 480)
-			full_screen = ARGV.include?("--fullscreen")
-			$window = super(width, height, full_screen)
+    def initialize(width = 640, height = 480)
+      full_screen = ARGV.include?("--fullscreen")
+      $window = super(width, height, full_screen)
 			
-			@root = File.dirname(File.expand_path($0))
-			Gosu::Image.autoload_dirs = [".", File.join(@root, "gfx"), File.join(@root, "media")]
-			Gosu::Sample.autoload_dirs = [".", File.join(@root, "sound"), File.join(@root, "media")]
-			Gosu::Tile.autoload_dirs = [".", File.join(@root, "gfx"), File.join(@root, "media")]
+      @root = File.dirname(File.expand_path($0))
+      Gosu::Image.autoload_dirs = [".", File.join(@root, "gfx"), File.join(@root, "media")]
+      Gosu::Sample.autoload_dirs = [".", File.join(@root, "sound"), File.join(@root, "media")]
+      Gosu::Tile.autoload_dirs = [".", File.join(@root, "gfx"), File.join(@root, "media")]
       Gosu::Song.autoload_dirs = [".", File.join(@root, "sfx"), File.join(@root, "media")]
 			
       @game_objects = Set.new
       @input_clients = Set.new  # Set is like a unique Array with Hash lookupspeed
       
       @fps_counter = FPSCounter.new
-			@game_state_manager = GameStateManager.new
-      
-			self.input = { :escape => close }
-		end
+      @game_state_manager = GameStateManager.new
+    end
     
     def add_game_object(object)
       @game_objects << object
     end
     def remove_game_object(object)
-      @input_clients.delete(object)
+      @game_objects.delete(object)
     end
         
     #
-    # Frames per second
+    # Frames per second, access with $window.fps or $window.framerate
     #
-		def fps
-			@fps_counter.fps
-		end
+    def fps
+      @fps_counter.fps
+    end
     alias :framerate :fps
 
     #
     # Total amount of game iterations (ticks)
     #
-		def ticks
-			@fps_counter.ticks
-		end
+    def ticks
+      @fps_counter.ticks
+    end
 
     #
     # Chingus core-logic / loop. Gosu will call this each game-iteration.
     #
-		def update
+    def update
       #
       # Register a tick with our rather standard tick/framerate counter. 
       # Returns the amount of milliseconds since last tick. This number is used in all update()-calls.
       # 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
       
       #
       # Dispatch inputmap for main window
@@ -102,14 +99,14 @@ module Chingu
       # Call update(milliseconds_since_last_tick) on all game objects belonging to the current game state.
       #
       update_game_state_manager
-		end
+    end
     
     # 
     # Chingus main screen manupulation method.
     # If you override this in your Chingu::Window class, make sure to call super.
     # Gosu will call this each game-iteration just after #update
     #
- 		def draw
+    def draw
       #
       # Draw all game objects associated with the main window.      
       #
@@ -119,7 +116,7 @@ module Chingu
       # Let the game state manager call draw on the active game state (if any)
       #
       @game_state_manager.draw
-		end
+    end
     
     #
     # Call update() on all game objects in main game window.
@@ -137,7 +134,6 @@ module Chingu
       @game_state_manager.update(@milliseconds_since_last_tick)
     end
 
-
     #
     # By default button_up sends the keyevent to the GameStateManager
     # .. Which then is responsible to send it to the right GameState(s)

data/lib/chingu.rb

@@ -26,5 +26,5 @@ require 'set'
     end
 
 module Chingu
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ippa-chingu
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors: 
 - ippa
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-14 00:00:00 -07:00
+date: 2009-08-19 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency