ippa-chingu 0.2.0 → 0.3.0

data/lib/chingu/helpers.rb

@@ -1,41 +1,149 @@
 module Chingu
-  module GameStateHelpers
+  
+  module InputClient
+    def input=(input_map)
+      @input = input_map
+      @parent.add_input_client(self)  if @parent
+    end
+    
+    def input
+      @input
+    end
+  end
+    
+  module InputDispatcher
+    def add_input_client(object)
+      @input_clients << object
+    end
+    
+    def remove_input_client(object)
+      @input_clients.delete(object)
+    end
+
+    def dispatch_button_down(id, object)
+      return if object.nil? || object.input.nil?
+      
+      object.input.each do |symbol, action|
+        if Input::SYMBOL_TO_CONSTANT[symbol] == id
+          dispatch_action(action, object)
+        end        
+      end
+    end
+    
+    def dispatch_button_up(id, object)
+      return if object.nil? || object.input.nil?
+      
+      object.input.each do |symbol, action|
+        if symbol.to_s.include? "released_"
+          symbol = symbol.to_s.sub("released_", "").to_sym
+          if Input::SYMBOL_TO_CONSTANT[symbol] == id
+            dispatch_action(action, object)
+          end
+        end
+      end
+    end
+    
+    #
+    # Dispatches input-mapper for any given object
+    #
+    def dispatch_input_for(object, prefix = "holding_")
+      return if object.nil? || object.input.nil?
+      
+      object.input.each do |symbol, action|
+        if symbol.to_s.include? prefix
+          symbol = symbol.to_s.sub(prefix, "").to_sym
+          if $window.button_down?(Input::SYMBOL_TO_CONSTANT[symbol])
+            dispatch_action(action, object)
+          end
+        end
+      end
+    end
     
     #
-    # push_gamestate accepts either a class inherited from GameState or an object-instance from such a class.
+    # For a given object, dispatch "action".
+    # An action can be:
     #
-    # push_gamestate(Intro) is the same as:
-    # push_gamestate(Intro.new)
-    # 
-    # The first line ends upp calling "new" to Intro before activating the newlycreated gamestate.
+    # * Symbol (:p, :space), translates into a method-call
+    # * Proc/Lambda, call() it
+    # * GameState-instance, push it on top of stack
+    # * GameState-inherited class, create a new instance, cache it and push it on top of stack
     #
-    def push_gamestate(state)
-      if state.is_a? Chingu::GameState
-        $window.game_state_manager.push_state(state)
-      elsif state.superclass == Chingu::GameState
-        $window.game_state_manager.push_state(state.new)
+    def dispatch_action(action, object)
+      # puts "Dispatch Action: #{action} - Objects class: #{object.class.to_s}"
+      if action.is_a? Symbol
+        object.send(action)
+      elsif action.is_a? Proc
+        action.call
+      elsif action.is_a? Chingu::GameState
+        push_game_state(action)
+      elsif action.superclass == Chingu::GameState
+        push_game_state(action)
       end
     end
+  end
+
+  #
+  # push_game_state accepts either a class inherited from GameState or an object-instance from such a class.
+  #
+  # push_game_state(Intro):
+  # game state mananger will create a new Intro-object first time called and cache it.
+  #
+  # push_game_state(Intro.new):
+  # The first line ends up calling "new" to Intro before activating the newly created game state.
+  # Each time 'push_game_state(Intro.new)' is called a new Intro-object will be created.
+  # Usefull for stuff like: push_game_state(Level.new(:level_nr => 11))
+  #
+  module GameStateHelpers
+    def push_game_state(state, options = {})
+      $window.game_state_manager.push_state(state, options)      
+    end
   
-    def pop_gamestate
-      $window.game_state_manager.pop_state
+    def pop_game_state(options = {})
+      $window.game_state_manager.pop_state(options)
     end
 
-    def current_gamestate
-      $window.game_state_manager.state
+    def current_game_state
+      $window.game_state_manager.current_state
     end
 
-    def previous_gamestate
+    def previous_game_state
       $window.game_state_manager.previous_state
     end
+
+    def clear_game_states
+      $window.game_state_manager.clear_states
+    end
   end
 
+  #
+  # Various helper-methods to manipulate the screen
+  #
   module DrawHelpers
-    def fill(color)
-       $window.draw_quad(0, 0, color, $window.width, 0, color, $window.width, $window.width, color, 0, $window.height, color, 0, :default) 
-     end
+    #
+    # Fills whole window with color 'c'
+    #
+    def fill(c)
+      $window.draw_quad(0,0,c,$window.width,0,c,$window.width,$window.width,c,0,$window.height,c,0,:default)
+    end
+     
+    #
+    # Fills a given Rect 'r' with color 'c'
+    #
+    def fill_rect(r, c)
+      $window.draw_quad(r.x,r.y,c, r.right,r.y,c, r.right,r.bottom,c, r.x,r.bottom,c,0,:default)
+    end
      
     def fade(options = {})
     end
   end
+  
+  module GameObjectHelpers
+    #
+    # Fetch game objects of a certain type/class
+    #
+    def game_objects_of_class(klass)
+      @game_objects.select { |game_object| game_object.is_a? klass }
+    end
+  end
+
 end

data/lib/chingu/input.rb

@@ -19,14 +19,14 @@ module Chingu
     
       KbBackspace => [:backspace],
       KbDelete    => [:delete, :del],
-      KbDown      => [:down],
+      KbDown      => [:down_arrow, :down],
       KbEnd       => [:end],
       KbEnter     => [:enter],
       KbEscape    => [:escape, :esc],
 
       KbHome        => [:home],
       KbInsert      => [:insert, :ins],
-      KbLeft        => [:left],
+      KbLeft        => [:left_arrow, :left],
       KbLeftAlt     => [:left_alt, :lalt],
       KbLeftControl => [:left_control, :left_ctrl, :lctrl],
       KbLeftShift   => [:left_shift, :lshift],
@@ -40,13 +40,13 @@ module Chingu
       KbPageUp          => [:page_up],
       # KbPause           => [:pause],
       KbReturn          => [:return],
-      KbRight           => [:right],
+      KbRight           => [:right_arrow, :right],
       KbRightAlt        => [:right_alt, :ralt],
       KbRightControl    => [:right_control, :right_ctrl, :rctrl],
       KbRightShift      => [:right_shift, :rshift],
       KbSpace           => [:" ", :space],
       KbTab             => [:tabulator, :tab],
-      KbUp              => [:up],
+      KbUp              => [:up_arrow, :up],
       
       MsLeft            => [:left_mouse_button, :mouse_left],
       MsMiddle          => [:middle_mouse_button, :mouse_middle],

data/lib/chingu/parallax.rb

@@ -29,7 +29,10 @@ module Chingu
       self.add_background(arg)
     end
     
-    def update
+    #
+    # TODO: make use of time here!
+    #
+    def update(time)
       @backgrounds.each do |background|
         background.x = -@x / background.damping
         background.y =  @y / background.damping

data/lib/chingu/text.rb

@@ -13,7 +13,17 @@ module Chingu
   #
   class Text < Chingu::GameObject
     attr_accessor :text
-    attr_reader :height, :font
+    attr_reader :height, :gosu_font
+
+    @@size = nil
+    @@font = nil
+    def self.font; @@font; end
+    def self.font=(value); @@font = value; end
+
+    def self.size; @@size; end
+    def self.size=(value); @@size = value; end
+    def self.height; @@size; end
+    def self.height=(value); @@size = value; end
     
     #
     # Takes the standard GameObject-hash-arguments but also:
@@ -24,21 +34,21 @@ module Chingu
     def initialize(options)
       super(options)
       @text = options[:text] || "-No text specified-"
-      @font_name = options[:font_name] || options[:font] || "verdana"
-      @height = options[:height] || options[:size] || 15
+      @font =  options[:font] || @@font || "verdana"
+      @height = options[:height] || options[:size] || @@size || default_font_name()
       
-      @font = Gosu::Font.new($window, @font_name, @height)
+      @gosu_font = Gosu::Font.new($window, @font, @height)
     end
     
     def draw
-      @font.draw_rot(@text, @x.to_i, @y.to_i, @zorder, @angle, @factor_x, @factor_y, @color, @mode)
+      @gosu_font.draw_rot(@text, @x.to_i, @y.to_i, @zorder, @angle, @factor_x, @factor_y, @color, @mode)
     end
     
     #
     # Returns the width, in pixels, the given text would occupy if drawn.
     #
     def width
-      @font.text_width(@text, @factor_x)
+      @gosu_font.text_width(@text, @factor_x)
     end
 
   end

data/lib/chingu/window.rb

@@ -1,11 +1,22 @@
 module Chingu
 	class Window < Gosu::Window
-    include Chingu::GameStateHelpers    # adds push_gamestate(), pop_gamestate() and previous_gamestate()
-    include Chingu::DrawHelpers         # adds fill() etc..
+    # adds push_game_state, pop_game_state, current_game_state and previous_game_state
+    include Chingu::GameStateHelpers    
     
-		attr_reader :root, :update_list, :draw_list, :tick, :game_state_manager
-		attr_accessor :key_receivers, :input
-    attr_reader :game_objects
+    # adds fill() etc...
+    include Chingu::DrawHelpers
+    
+    # adds game_objects_of_class etc ...
+    include Chingu::GameObjectHelpers
+    
+    # Input dispatch helpers
+    include Chingu::InputDispatcher
+    
+    # input= and input
+    include Chingu::InputClient
+    
+		attr_reader :root, :game_state_manager, :game_objects, :milliseconds_since_last_tick
+  
 		
     #
     # See http://www.libgosu.org/rdoc/classes/Gosu/Window.html
@@ -26,136 +37,125 @@ module Chingu
 			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 = []
-      @input = nil
-      
-			@ticks = 0
-			@last_tick = Gosu::milliseconds
+      @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
       
-			@update_list = []
-			@draw_list = []
-      
 			self.input = { :escape => close }
 		end
     
-    def add_game_object(game_object)
-      @game_objects.push(game_object) unless @game_objects.include?(game_object)
+    def add_game_object(object)
+      @game_objects << object
     end
-
-		def update_tick
-			@tick = Gosu::milliseconds - @last_tick
-			@last_tick = Gosu::milliseconds
-			@tick
-		end
-	
+    def remove_game_object(object)
+      @input_clients.delete(object)
+    end
+        
+    #
+    # Frames per second
+    #
 		def fps
 			@fps_counter.fps
 		end
-    
-    #
-    # By default button_up sends the keyevent to the GameStateManager
-    # .. Which then is responsible to send it to the right GameState(s)
-    #
-    def button_up(id)
-      @game_state_manager.button_up(id)
-    end
-    
+    alias :framerate :fps
 
     #
-    # By default button_down sends the keyevent to the GameStateManager
-    # .. Which then is responsible to send it to the right GameState(s)
+    # Total amount of game iterations (ticks)
     #
-    def button_down(id)
-      @game_state_manager.button_down(id)
-    end
+		def ticks
+			@fps_counter.ticks
+		end
 
-	
     #
-    # Standard GOSU main class update
+    # Chingus core-logic / loop. Gosu will call this each game-iteration.
     #
 		def update
-			@fps_counter.register_tick
-			update_tick
-
       #
-      # Process inputs for:
-      # - Our main game window (self)
-      # - .. and all gameobjects connected to it
-      # - the active gamestate
-      # - ... and all GameObjects connected to it
+      # 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.
       #
-      [self, @game_state_manager.state].each do |object|
-        next if object.nil?
-        
-				dispatch_input_for(object)
-        
-        object.game_objects.each do |game_object|
-          dispatch_input_for(game_object)
-        end
-			end
-
-      @game_objects.each { |object| object.update }
-      @game_state_manager.update
+			@milliseconds_since_last_tick = @fps_counter.register_tick
+      
+      #
+      # Dispatch inputmap for main window
+      #
+      dispatch_input_for(self)
+      
+      #
+      # Dispatch input for all input-clients handled by to main window (game objects with input created in main win)
+      #
+      @input_clients.each { |game_object| dispatch_input_for(game_object) }
+      
+      
+      #
+      # Call update(milliseconds_since_last_tick) on all game objects belonging to the main window.
+      #
+      update_game_objects
+      
+      #
+      # Call update(milliseconds_since_last_tick) on all game objects belonging to the current game state.
+      #
+      update_game_state_manager
 		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
+      #
+      # Draw all game objects associated with the main window.      
+      #
       @game_objects.each { |object| object.draw }
+      
+      #
+      # Let the game state manager call draw on the active game state (if any)
+      #
       @game_state_manager.draw
 		end
-
-    private 
     
     #
-    # Dispatches a input for any given object
+    # Call update() on all game objects in main game window.
     #
-    def dispatch_input_for(object)
-      return if object.nil? || object.input.nil?
-      
-      object.input.each do |symbol, action|
-        if button_down?(Input::SYMBOL_TO_CONSTANT[symbol])
-          #puts "#{object.to_s} :#{symbol.to_s} => #{action.to_s}"
-          #puts "[#{action.class.to_s} - #{action.class.superclass.to_s}]"         
-          if action.is_a? Symbol
-            object.send(action)
-          elsif action.is_a? Proc
-            action.call
-          elsif action.is_a? Chingu::GameState
-            push_gamestate(action)
-          elsif action.superclass == Chingu::GameState
-            push_gamestate(action)
-          end
-        end
-      end
+    def update_game_objects
+      @game_objects.each { |object| object.update(@milliseconds_since_last_tick) }
     end
     
-	end
-end
-
-
+    #
+    # Call update() on our game_state_manger
+    # -> call update on active state 
+    # -> call update on all game objects in that state
+    #
+    def update_game_state_manager
+      @game_state_manager.update(@milliseconds_since_last_tick)
+    end
 
 
-#		def button_down(id)
-#			key_recievers.each do |key_reciever|	
-#				key_reciever.keymap.each do |key, action|
-#					key_reciever.send(:before_keymap_dispatch)	if key_reciever.respond_to? (:before_keymap_dispatch)
-#					if Keymap::constant_to_symbol[id] == key
-#						puts "#{key.to_s} => #{action.to_s}"
-#						key_reciever.send(action)
-#					end
-#				end
-#			end			
-#		end
-		
-		#def button_up(id)
-		#	key_recievers.each do |key_reciever|	
-		#		key_reciever.release_keymap.each do |key, action|
-		#			if Keymap::Keys[id] == key
-		#				key_reciever.send(action)
-		#			end
-		#		end
-		#	end			
-		#end
+    #
+    # By default button_up sends the keyevent to the GameStateManager
+    # .. Which then is responsible to send it to the right GameState(s)
+    #
+    def button_up(id)
+      dispatch_button_up(id, self)
+      @input_clients.each { |object| dispatch_button_up(id, object) }
+      @game_state_manager.button_up(id)
+    end
+    
+    #
+    # By default button_down sends the keyevent to the GameStateManager
+    # .. Which then is responsible to send it to the right GameState(s)
+    #
+    def button_down(id)
+      dispatch_button_down(id, self)
+      @input_clients.each { |object| dispatch_button_down(id, object) }
+      @game_state_manager.button_down(id)
+    end
+  end
+end