ippa-chingu 0.2.0 → 0.3.0

data/lib/chingu/assets.rb

@@ -30,7 +30,15 @@ module Gosu
 			(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
 	

data/lib/chingu/fpscounter.rb

@@ -1,21 +1,41 @@
 module Chingu
+  #
+  # Calculates a fps and a tick-time for use in update-calls
+  # register_tick() must be called every game loop iteration
+  #
 	class FPSCounter
-		attr_reader :fps
+		attr_reader :fps, :milliseconds_since_last_tick, :ticks
   
 		def initialize
 			@current_second = Gosu::milliseconds / 1000
 			@accum_fps = 0
 			@fps = 0
+      @ticks = 0
+      
+      @milliseconds_since_last_tick = 0
+			@last_value = Gosu::milliseconds
 		end
   
+    #
+    # This should be called once every game-iteration, preferable in update()
+    #
 		def register_tick
 			@accum_fps += 1
+      @ticks += 1
 			current_second = Gosu::milliseconds / 1000
 			if current_second != @current_second
 				@current_second = current_second
 				@fps = @accum_fps
 				@accum_fps = 0
 			end
+
+      #
+      # Calculate how many milliseconds passed since last game loop iteration.
+      # useful in update()-calls
+      #
+			@milliseconds_since_last_tick = Gosu::milliseconds - @last_value
+			@last_value = Gosu::milliseconds
+			return @milliseconds_since_last_tick
 		end
 	end
 end

data/lib/chingu/game_object.rb

@@ -6,10 +6,12 @@ module Chingu
   # All objects that inherits from this class will automaticly be updated and drawn.
   #
   class GameObject
-    attr_accessor :image, :x, :y, :angle, :center_x, :center_y, :factor_x, :factor_y, :mode
-    attr_accessor :update, :draw, :input
+    attr_accessor :image, :x, :y, :angle, :center_x, :center_y, :factor_x, :factor_y, :color, :mode
+    attr_accessor :update, :draw
     attr_reader :options
     
+    include Chingu::InputClient
+    
     #
     # Class-level default values. 
     # This allows you to set default-values that affect all created GameObjects after that.
@@ -17,12 +19,20 @@ module Chingu
     # 
     # in Gosu::Window#initialize: GameObject.center_x = GameObject.center_y = 0
     #
+    @@x = nil
+    @@y = nil
     @@zorder = 100
     @@center_x = 0.5
     @@center_y = 0.5
     @@factor_x = 1.0
     @@factor_y = 1.0
 
+    def self.x; @@x; end
+    def self.x=(value); @@x = value; end
+
+    def self.y; @@y; end
+    def self.y=(value); @@y = value; end
+
     def self.zorder; @@zorder; end
     def self.zorder=(value); @@zorder = value; end
 
@@ -41,18 +51,18 @@ module Chingu
     #
     # Create a new GameObject. Arguments are given in hash-format:
     # 
-    # :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).
+    #   :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+.
+    #   :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 initialize(options = {})
       @options = options
@@ -61,8 +71,8 @@ module Chingu
       @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
+      @x = options[:x] || @@x || 0
+      @y = options[:y] || @@y || 0
       @angle = options[:angle] || 0
       @zorder = options[:zorder] || @@zorder
       @center_x = options[:center_x] || options[:center] || @@center_x
@@ -72,6 +82,9 @@ module Chingu
       @color = options[:color] || 0xFFFFFFFF
       @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
@@ -85,9 +98,32 @@ module Chingu
       @parent.add_game_object(self)  if @parent
     end
     
+    def factor=(factor)
+      @factor = factor
+      @factor_x = @factor_y = @factor
+    end
+    alias :zoom= :factor=
+    def factor
+      @factor
+    end
+    alias :zoom :factor
     
-    def update
-      # Objects gamelogic here
+    #
+    # Returns true if game 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
+
+    #
+    # 
+    #
+    def outside_window?(x = @x, y = @y)
+      not inside_window?(x,y)
+    end
+
+    def update(time = 1)
+      # Objects gamelogic here, 'time' is the time passed between 2 iterations of the main game loop
 		end
     
     #

data/lib/chingu/game_state.rb

@@ -1,39 +1,115 @@
 module Chingu
+  #
+  # Chingu incorporates a basic push/pop game state system (as discussed here: http://www.gamedev.net/community/forums/topic.asp?topic_id=477320).
+  # Game states is a way of organizing your intros, menus, levels.
+  # Game states aren't complicated. In Chingu a GameState is a class that behaves mostly like your default Gosu::Window (or in our case Chingu::Window) game loop.
+  #
+  # # A simple GameState-example
+  # class Intro < Chingu::GameState
+  #   def update
+  #     # game logic here
+  #   end
+  #
+  #   def draw
+  #     # screen manipulation here
+  #   end
+  #        
+  #   # Called when we enter the game state
+  #   def setup
+  #     @player.angle = 0   # point player upwards
+  #   end
+  #    
+  #   # Called when we leave the current game state
+  #   def finalize
+  #     push_game_state(Menu)   # switch to game state "Menu"
+  #   end
+  # end
+  #
+
   class GameState
-    include Chingu::GameStateHelpers  # Easy access to the global game_state-queue
-    include Chingu::DrawHelpers       # Adds fill(), fade() etc to each gamestate.
-        
-    attr_reader :options              # so jac can access his :level-number
-    attr_reader :game_objects
-    attr_accessor :input
+    include Chingu::GameStateHelpers    # Easy access to the global game state-queue
+    include Chingu::DrawHelpers         # Adds fill(), fade() etc to each game state
+    include Chingu::GameObjectHelpers   # adds game_objects_of_class etc ...
+    include Chingu::InputDispatcher     # dispatch-helpers
+    include Chingu::InputClient
+    
+    attr_reader :options                # so jlnr can access his :level-number
+    attr_reader :game_objects, :do_setup
     
     def initialize(options = {})
       @options = options
-      @game_objects = Array.new
-      @input = options[:input]
+      @do_setup = options[:setup] || true
+      
+      @game_objects = Set.new
+      @input_clients = Set.new  # Set is like a unique Array with Hash lookupspeed
+      
       $window.game_state_manager.inside_state = self
-      setup
     end
     
-    def add_game_object(game_object)
-      @game_objects.push(game_object) unless @game_objects.include?(game_object)
+    #
+    # An unique identifier for the GameState-class, 
+    # Used in game state manager to keep track of created states.
+    #
+    def to_sym
+      self.class.to_s.to_sym
+    end
+    
+    def add_game_object(object)
+      @game_objects << object
+    end
+    def remove_game_object(object)
+      @input_clients.delete(object)
     end
     
     def setup
+      # Your game state setup logic here.
     end
     
+    #
+    # Called when a button is pressed and a game state is active
+    #
     def button_down(id)
+      dispatch_button_down(id, self)
+      @input_clients.each { |object| dispatch_button_down(id, object) }
     end
     
+    #
+    # Called when a button is released and a game state active
+    #
     def button_up(id)
+      dispatch_button_up(id, self)
+      @input_clients.each { |object| dispatch_button_up(id, object) }
     end
-
-    def update
-      @game_objects.each { |object| object.update }
+    
+    #
+    # Calls update on each game object that has current game state as parent (created inside that game state)
+    #
+    def update(time = 1)
+      dispatch_input_for(self)
+      @input_clients.each { |game_object| dispatch_input_for(game_object) }      
+      
+      @game_objects.each { |object| object.update(time) }
     end
     
+    #
+    # Calls Draw on each game object that has current game state as parent (created inside that game state)
+    #
     def draw
       @game_objects.each { |object| object.draw }
     end
+    
+    #
+    # Closes game state by poping it off the stack (and activating the game state below)
+    #
+    def close
+      pop_game_state
+    end
+    
+    #
+    # Closes main window and terminates the application
+    #
+    def close_game
+      $window.close
+    end
   end
 end

data/lib/chingu/game_state_manager.rb

@@ -1,47 +1,103 @@
-module Chingu  
+module Chingu
+  #
+  # GameStateManger is responsible for keeping track of game states with a simple pop/push stack.
+  #
+  # 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
+    attr_reader :states, :created_states
     
     def initialize
       @inside_state = nil
       @states = []
+      @created_states = {}
     end
 
     #
     # Gets the currently active gamestate (top of stack)
     #
-    def state
+    def current_state
       @states.last
     end
 
     #
-    # Adds a state to the gamestate-stack
+    # Adds a state to the game state-stack and activates it
     #
-    def push_state(state)
-      @states.push(state)
+    def push_state(state, options = {})
+      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/initialize it once (@created_states keeps track of this)
+      #        
+      elsif state.superclass == Chingu::GameState
+        
+        if @created_states[state.to_s]
+          new_state = @created_states[state.to_s]
+        else
+          new_state = state.new(options)
+          @created_states[state.class.to_s] = new_state
+        end
+      end
+
+      #
+      # If the new state is all good
+      #
+      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
+        
+        # Call setup
+        new_state.setup         if new_state.do_setup
+        
+        # Push new state on top of stack and therefore making it active
+        @states.push(new_state)
+      end
     end
     
     #
-    # Pops a state off the gamestate-stack
-    #
-    def pop_state
+    # Pops a state off the game state-stack, activating the previous one.
+    #
+    def pop_state(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
+      
+      #
+      # Activate the game state "bellow" current one with a simple Array.pop
+      #
       @states.pop
+
+      # Call setup on the new current state
+      current_state.setup       unless options[:setup] == false
     end
     
     #
-    # Returns the previous gamestate
+    # Returns the previous game state
     #
     def previous_state
-      @states[@states.index(state)-1]
+      @states[@states.index(current_state)-1]
     end
-    
     alias :prev_state previous_state
     
     #
-    # Pops through all gamestates until matching a given gamestate
+    # Remove all game states from stack
+    #
+    def clear_states
+      @states.clear
+    end
+    
+    #
+    # Pops through all game states until matching a given game state
     #
-    def switch_state(new_state)
+    def pop_until_game_state(new_state)
       while (state = @states.pop)
         break if state == new_state
       end
@@ -58,27 +114,27 @@ module Chingu
     # Called before #update when the user pressed a button while the window had the focus. 
     #
     def button_down(id)
-      state.button_down(id) if state
+      current_state.button_down(id) if current_state
     end
     
     #
     # Called when the user released a button. 
     #
     def button_up(id)
-      state.button_up(id)   if state
+      current_state.button_up(id)   if current_state
     end
     
     #
     # Calls #update on the current gamestate, if there is one.
     #
-    def update
-      state.update  if state
+    def update(time = 1)
+      current_state.update(time)  if current_state
     end
     #
     # Calls draw() on the current gamestate, if there is one.
     #
     def draw
-      state.draw    if state
+      current_state.draw    if current_state
     end
   end
 end