chingu 0.7.6.8 → 0.7.6.9

data/.gitignore

@@ -2,4 +2,5 @@
 pkg
 .gem
 .git
+.idea
 coverage

data/chingu.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{chingu}
-  s.version = "0.7.6.8"
+  s.version = "0.7.6.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["ippa"]
-  s.date = %q{2010-08-15}
+  s.date = %q{2010-08-18}
   s.description = %q{OpenGL accelerated 2D game framework for Ruby. Builds on Gosu (Ruby/C++) which provides all the core functionality. Chingu adds simple yet powerful game states, prettier input handling, deployment safe asset-handling, a basic re-usable game object and stackable game logic.}
   s.email = %q{ippa@rubylicio.us}
   s.extra_rdoc_files = [
@@ -138,6 +138,7 @@ Gem::Specification.new do |s|
      "lib/chingu/particle.rb",
      "lib/chingu/rect.rb",
      "lib/chingu/require_all.rb",
+     "lib/chingu/simple_menu.rb",
      "lib/chingu/text.rb",
      "lib/chingu/traits/animation.rb",
      "lib/chingu/traits/bounding_box.rb",
@@ -153,7 +154,10 @@ Gem::Specification.new do |s|
      "lib/chingu/window.rb",
      "spec/chingu/fpscounter_spec.rb",
      "spec/chingu/game_object_spec.rb",
+     "spec/chingu/helpers/input_client_spec.rb",
+     "spec/chingu/helpers/input_dispatcher_spec.rb",
      "spec/chingu/helpers/options_setter_spec.rb",
+     "spec/chingu/images/rect_20x20.png",
      "spec/chingu/inflector_spec.rb",
      "spec/chingu/rect_20x20.png",
      "spec/chingu/text_spec.rb",
@@ -169,6 +173,8 @@ Gem::Specification.new do |s|
   s.test_files = [
     "spec/chingu/fpscounter_spec.rb",
      "spec/chingu/game_object_spec.rb",
+     "spec/chingu/helpers/input_client_spec.rb",
+     "spec/chingu/helpers/input_dispatcher_spec.rb",
      "spec/chingu/helpers/options_setter_spec.rb",
      "spec/chingu/inflector_spec.rb",
      "spec/chingu/text_spec.rb",

data/examples/example4_gamestates.rb

@@ -116,7 +116,7 @@ class Level < Chingu::GameState
     @player = Player.create
     
     #
-    # The below code can mostly be replaced with the use of method "holding?" in Level#update
+    # The below code can mostly be replaced with the use of methods "holding?", "holding_all?" or "holding_any?" in Level#update
     # Using holding? in update could be good if you need fine grained controll over when input is dispatched.
     # 
     @player.input = {  :holding_left => :move_left, 
@@ -138,10 +138,10 @@ class Level < Chingu::GameState
     #
     # Another way of checking input
     #
-    # @player.move_left   if holding?(:left, :a)
-    # @player.move_right  if holding?(:right, :d)
-    # @player.move_up     if holding?(:up, :w)
-    # @player.move_down   if holding?(:down, :s)
+    # @player.move_left   if holding_any?(:left, :a)
+    # @player.move_right  if holding_any?(:right, :d)
+    # @player.move_up     if holding_any?(:up, :w)
+    # @player.move_down   if holding_any?(:down, :s)
     # @player.fire        if holding?(:space)
 
     Bullet.destroy_if {|bullet| bullet.outside_window? }

data/lib/chingu.rb

@@ -33,7 +33,7 @@ require_all "#{CHINGU_ROOT}/chingu/traits"
 require_all "#{CHINGU_ROOT}/chingu"
 
 module Chingu
-  VERSION = "0.7.6.8"
+  VERSION = "0.7.6.9"
   
   DEBUG_COLOR = Gosu::Color.new(0xFFFF0000)
   DEBUG_ZORDER = 9999

data/lib/chingu/game_object.rb

@@ -100,7 +100,7 @@ module Chingu
     # Makes it easy to clone a objects x,y,angle etc.
     #
     def attributes
-      [@x, @y, @angle, @center_x, @center_y, @factor_x, @factor_y, @color, @mode, @zorder]
+      [@x, @y, @angle, @center_x, @center_y, @factor_x, @factor_y, @color.dup, @mode, @zorder]
     end
 
     #

data/lib/chingu/game_object_list.rb

@@ -63,6 +63,10 @@ module Chingu
       @game_objects.size
     end
     
+    def empty?
+      @game_objects.empty?
+    end
+    
     def draw
       @game_objects.each{ |object| object.visible }.each do |object| 
         object.draw_trait

data/lib/chingu/game_states/edit.rb

@@ -53,7 +53,7 @@ module Chingu
         options = {:draw_grid => true, :snap_to_grid => true, :resize_to_grid => true}.merge(options)
         
         @grid = options[:grid] || [8,8]
-        @grid_color = options[:grid_color] || Color.new(0xaa222222)
+        @grid_color = options[:grid_color] || Gosu::Color.new(0xaa222222)
         @draw_grid = options[:draw_grid]
         @snap_to_grid = options[:snap_to_grid]      # todo
         @resize_to_grid = options[:resize_to_grid]  # todo
@@ -501,7 +501,7 @@ END_OF_STRING
       end
       
       def quit
-        pop_game_state(:setup => false)
+        pop_game_state
       end
       def save 
         save_game_objects(:game_objects => editable_game_objects, :file => @file, :classes => @classes)
@@ -654,26 +654,14 @@ END_OF_STRING
       def create_new_game_object_from(template)
         game_object = template.class.create(:parent => previous_game_state)
         game_object.update
-        #game_object.options[:selected] = true
-        game_object.options[:created_with_editor] = true
+        
+        # If we don't create it from the toolbar, we're cloning another object
+        # When cloning we wan't the cloned objects attributes
+        game_object.attributes = template.attributes  unless template.options[:toolbar]       
         game_object.x = self.mouse_x
         game_object.y = self.mouse_y
-                 
-        unless template.options[:toolbar]
-          game_object.angle = template.angle
-          game_object.factor_x = template.factor_x
-          game_object.factor_y = template.factor_y
-          game_object.color = template.color.dup
-          game_object.zorder = template.zorder
-          game_object.update
-        else
-          # Resize the new game object to fit the grid perfectly!
-          wanted_width = game_object.image.width + @grid[0] - (game_object.image.width % @grid[0])
-          wanted_height = game_object.image.height + @grid[1] - (game_object.image.height % @grid[1])
-          game_object.factor_x = wanted_width.to_f / game_object.image.width.to_f
-          game_object.factor_y = wanted_height.to_f / game_object.image.height.to_f
-        end
-        
+        game_object.options[:created_with_editor] = true
+                
         game_object.options[:mouse_x_offset] = (game_object.x - self.mouse_x) rescue 0
         game_object.options[:mouse_y_offset] = (game_object.y - self.mouse_y) rescue 0
         

data/lib/chingu/helpers/input_client.rb

@@ -44,60 +44,222 @@ module Chingu
     #
     #
     module InputClient
+      # The current input handlers. This may contain data which is different to the input set,
+      # but it will be equivalent in function [Hash].
+      def input
+        @input ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      # Is a particular key being held down at this moment?
+      #
+      # === Parameters
+      # +key+:: Chingu key code [Symbol]
+      #
+      public
+      def holding?(key)
+        $window.button_down?(Chingu::Input::SYMBOL_TO_CONSTANT[key])
+      end
+
+      # Are any of a list of keys being held down?
+      #
+      # === Parameters
+      # +key+:: Chingu key code [Symbol]
       #
-      # Returns true or false depending if any of the given keys are pressed
+      # :call-seq:
+      #    holding_any?(key [, key]*) { } -> true or false
+      #
+      public
+      def holding_any?(*keys)
+        keys.any? { |key| holding?(key) }
+      end
+
+      # Are all keys in a list being held down simultaneously?
+      #
+      # === Parameters
+      # +key+:: Chingu key code [Symbol]
+      #
+      # :call-seq:
+      #   holding_all?(key [, key]*) { } -> true or false
+      #
+      public
+      def holding_all?(*keys)
+        keys.all? { |key| holding?(key) }
+      end
+
+      # Ensures that the key code exists and ensures it has a consistent name.
       #
-      # Example:
-      #   @player.go_left if holding?(:left, :a)
+      # === Parameters
+      # +key+:: Chingu key code [Symbol]
       #
-      def holding?(*keys)
-        Array(keys).each do |key|
-          return true if $window.button_down?(Chingu::Input::SYMBOL_TO_CONSTANT[key])
+      # Returns: Key code [Symbol]
+      #
+      protected
+      def validate_input_key(key)
+        raise ArgumentError, "Input must be a Symbol or #{MultiInput}, but received #{key} (#{key.class})" unless key.is_a? Symbol
+
+        # The base key is the key without a prefix, so we can find it in the lookups.
+        base_key = Chingu::Input::SYMBOL_TO_CONSTANT.has_key?(key) ? key : nil
+        prefix_used = ""
+        ["holding_", "released_"].each do |prefix|
+          break if base_key
+          if key =~ /^#{prefix}(.*)$/
+            base_key = Chingu::Input::SYMBOL_TO_CONSTANT.has_key?($1.to_sym) ? $1.to_sym : nil
+            prefix_used = prefix
+          end
         end
-        return false
+
+        raise ArgumentError, "No such input as #{key.inspect}" unless base_key
+
+        # Standardise the symbol used.
+        :"#{prefix_used}#{Input::CONSTANT_TO_SYMBOL[Input::SYMBOL_TO_CONSTANT[base_key]].first}"
       end
-      
+
+      # Ensures that the key code exists and ensures it has a consistent name.
       #
-      # Input-map writer
+      # === Parameters
+      # +key+:: Chingu key code [Symbol]
+      # +action+:: Action to perform [Method/Proc/String/Symbol/Class/Chingu::GameState]
       #
-      def input=(input_map)
-        @input ||= Hash.new
+      # Returns: Key code, action [Array]
+      #
+      protected
+      def validate_input(key, action)
+        key = validate_input_key(key)
         
-        if input_map.is_a? Array
-          #
-          # Un-nest input_map [:left, :right, :space]
-          # Into: { :left => :left, :right => :right, :space => :space}
-          #
-          input_map.each do |symbol|
-            @input[symbol] = symbol
-          end
-        elsif input_map.is_a? Hash
-          #
-          # Un-nest input:  { [:pad_left, :arrow_left, :a] => :move_left }
-          # Into:  { :pad_left => :move_left, :arrow_left => :move_left, :a => :move_left }
-          #
-          input_map.each_pair do |possible_array, action|
-            if possible_array.is_a? Array
-              possible_array.each do |symbol|
-                @input[symbol] = action
-              end
-            elsif possible_array.is_a? Symbol
-              @input[possible_array] = action
+        message = case action
+          when Method, Proc, Chingu::GameState
+            nil
+
+          when String, Symbol
+            "#{self.class} does not have a #{action} method" unless self.respond_to? action
+            # Resolve to a method.
+            action = method action
+            
+            nil
+
+          when Class
+            if action.ancestors.include? Chingu::GameState
+              nil
+            else
+              "Input action is a class (#{action.class}) not inheriting from Chingu::GameState"
             end
+
+          else
+            "Input action must be a Method, Proc, String, Symbol, Chingu::GameState or a class inheriting from Chingu::GameState (Received a #{action.class})"
+        end
+
+        raise ArgumentError, "(For input #{key.inspect}) #{message}" if message
+
+        [key, action]
+      end
+
+      # Add input handlers all at once. This is an alternative to on_input, which sets input handlers individually.
+      #
+      # === Parameters
+      # +input_list+:: [Hash or Array]
+      #
+      # === Examples
+      # As a hash (Will call move_left or move_right methods when keys pressed):
+      #   add_inputs :left_arrow => :move_left,
+      #             :right_arrow => :move_right
+      #
+      # As an array (Will call left_arrow or right_arrow methods when keys pressed):
+      #   add_inputs :left_arrow, :right_arrow
+
+      # :call-seq:
+      #   add_inputs(input [, input]*] -> self
+      #   add_inputs(input => action [, input => action]*) -> self
+      #
+      public
+      def add_inputs(*input_list)
+        raise "Need to provide inputs as either parameters or hashed parameters" if input_list.empty?
+        input_list = input_list[0] if input_list[0].is_a? Hash
+
+        case input_list
+          when Array
+            #
+            # Un-nest input_map [:left, :right, :space]
+            # Into: { :left => :left, :right => :right, :space => :space }
+            #
+            input_list.each { |symbol| on_input(symbol) }
+            
+          when Hash
+            #
+            # Un-nest input:  { [:pad_left, :arrow_left, :a] => :move_left }
+            # Into:  { :pad_left => :move_left, :arrow_left => :move_left, :a => :move_left }
+            #
+            input_list.each_pair do |possible_array, action|
+              case possible_array
+                when Array
+                  possible_array.each { |symbol| on_input(symbol, action) }
+                when Symbol
+                  on_input(possible_array, action)
+              end
           end
         end
-        
-        if @parent 
-          if (@input == nil || @input == {})
+
+        self
+      end
+
+      # Backwards compatibility function. Use on_inputs or on_input instead.
+      def input=(input_list)
+        @input = nil
+        input_list.is_a?(Array) ? add_inputs(*input_list) : add_inputs(input_list)
+      end
+
+      # Adds an event handler for a key or any of a list of keys. This is an alternative to input=, which sets all
+      # handlers at once.
+      #
+      # === Parameters
+      # +input+:: Chingu input code(s) [Symbol or Array of Symbols]
+      # +action+:: [Method/Proc/String/Symbol/Class/Chingu::GameState]
+      #
+      # Returns: self
+      #
+      # === Examples
+      # Using actions:
+      #   on_input(:space) # Will call the space method when input detected.
+      #   on_input(:space, :fire_laser)
+      #   on_input([:left, :a], method(:go_left))
+      #
+      # Using blocks:
+      #   on_input :space do
+      #      # Fire the laser
+      #   end
+      #   on_input [:left, :a] do
+      #      # Move the player left.
+      #   end
+      #
+      # :call-seq:
+      #    on_input(input)         -> self
+      #    on_input(input) { }     -> self
+      #    on_input(input, action) -> self
+      #
+      public
+      def on_input(input, action = nil, &block)
+        raise ArgumentError, "#{self.class}#on_input takes either an input OR an input and action OR an input with a block" if action and block
+
+        inputs = input.is_a?(Array) ? input : [input]  # Can be a single input or an array of them.
+        action = block if block
+        action = input unless action
+
+        @input ||= Hash.new { |hash, key| hash[key] = [] }
+
+        # Ensure that the new input array is reasonable.
+        inputs.each do |input|
+          standardised_symbol, action = validate_input(input, action)
+          @input[standardised_symbol] << action
+        end
+
+        if @parent
+          if @input.empty?
             @parent.remove_input_client(self)
           else
             @parent.add_input_client(self)
           end
         end
-      end
-      
-      def input
-        @input
+        
+        self
       end
     end
   end

data/lib/chingu/helpers/input_dispatcher.rb

@@ -21,89 +21,74 @@
 
 module Chingu
   module Helpers
-  
   #
   # Methods for parsing and dispatching Chingus input-maps
   # Mixed into Chingu::Window and Chingu::GameState
   #
   module InputDispatcher
     attr_reader :input_clients
-    
+
+    # Called by input_clients to add themselves from forwarding.
     def add_input_client(object)
       @input_clients << object    unless @input_clients.include?(object)
     end
-    
+
+    # Called by input_clients to remove themselves from forwarding.
     def remove_input_client(object)
       @input_clients.delete(object)
     end
 
+    # Dispatch button press to one of your clients.
     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        
+      if actions = object.input[Input::CONSTANT_TO_SYMBOL[id].first]
+        dispatch_actions(actions)
       end
     end
-    
+
+    # Dispatch button release to one of your clients.
     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
+      if actions = object.input[:"released_#{Input::CONSTANT_TO_SYMBOL[id].first}"]
+        dispatch_actions(actions)
       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
+      pattern = /^#{prefix}/
+      object.input.each do |symbol, actions|
+        if symbol =~ pattern and $window.button_down?(Input::SYMBOL_TO_CONSTANT[$'.to_sym])
+          dispatch_actions(actions)
         end
       end
     end
-    
+
     #
     # For a given object, dispatch "action".
-    # An action can be:
+    # An action can be an array containing any of:
     #
-    # * Symbol (:p, :space) or String, translates into a method-call
     # * Proc/Lambda or Method, 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 dispatch_action(action, object)
-      #puts "Dispatch Action: #{action} - Objects class: #{object.class.to_s}"
-      
-      case action
-      when Symbol, String
-        object.send(action)
-      when Proc, Method
-        action[]
-      when Chingu::GameState
-        push_game_state(action)
-      when Class
-        if action.ancestors.include?(Chingu::GameState)
-          push_game_state(action)
+    protected
+    def dispatch_actions(actions)
+      # puts "Dispatch Action: #{action} - Objects class: #{object.class.to_s}"
+      actions.each do |action|
+        case action
+          when Proc, Method
+            action[]
+          when Chingu::GameState, Class
+            # Don't need to check if the Class is a GameState, since that is already checked.
+            push_game_state(action)
+          else
+            raise ArgumentError, "Unexpected action #{action}"
         end
-      else
-        # TODO possibly raise an error? This ought to be handled when the input is specified in the first place.
       end
+      # Other types will already have been resolved to one of these, so no need for checking.
     end
   end
-  
+
   end
 end

data/lib/chingu/simple_menu.rb

@@ -0,0 +1,119 @@
+#--
+#
+# 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
+  #
+  # 
+  #
+  class SimpleMenu < BasicGameObject
+    include Chingu::Helpers::InputClient
+    attr_accessor :menu_items
+    
+    def initialize(options = {})
+      super
+      
+      @menu_items = options.delete(:menu_items)# || {"Exit" => :exit}
+      
+      @x = options.delete(:x) || $window.width/2
+      @y = options.delete(:x) || 100
+      @spacing = options.delete(:x) || 100
+      @items = []
+  
+      y = @spacing
+      menu_items.each do |key, value|
+        
+        item = if key.is_a? String
+          Text.new(key, options.dup)
+        elsif key.is_a? Image
+          GameObject.new(options.merge!(:image => key))
+        elsif key.is_a? GameObject
+          menu_item.options.merge!(options.dup)
+          menu_item
+        end
+        
+        item.options[:on_select] = method(:on_select)
+        item.options[:on_deselect] = method(:on_deselect)
+        item.options[:action] = value
+        
+        item.rotation_center = :center_center
+        item.x = @x
+        item.y = y
+        y += item.height + @spacing
+        @items << item
+      end      
+      @selected = options[:selected] || 0
+      step(0)
+      
+      self.input = {:up => lambda{step(-1)}, :down => lambda{step(1)}, [:return, :space, :right] => :select}
+    end
+    
+    def step(value)
+      selected.options[:on_deselect].call(selected)
+      @selected += value
+      @selected = @items.count-1  if @selected < 0
+      @selected = 0               if @selected == @items.count
+      selected.options[:on_select].call(selected)
+    end
+    
+    def select
+      dispatch_action(selected.options[:action], self.parent)
+    end
+            
+    def selected
+      @items[@selected]
+    end
+      
+    def on_deselect(object)
+      object.color = Color::WHITE
+    end
+    
+    def on_select(object)
+      object.color = Color::RED
+    end
+    
+    def draw
+      @items.each { |item| item.draw }
+    end
+    
+    private
+    
+    #
+    # TODO - DRY this up with input dispatcher somehow 
+    #
+    def dispatch_action(action, object)
+      case action
+      when Symbol, String
+        object.send(action)
+      when Proc, Method
+        action[]
+      when Chingu::GameState
+        push_game_state(action)
+      when Class
+        if action.ancestors.include?(Chingu::GameState)
+          push_game_state(action)
+        end
+      else
+        # TODO possibly raise an error? This ought to be handled when the input is specified in the first place.
+      end
+    end    
+  end
+end
+ 

data/spec/chingu/game_object_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module Chingu
 
   describe GameObject do
-    
+
     before(:all) do 
       @game = Chingu::Window.new
     end
@@ -59,30 +59,28 @@ module Chingu
     end
 
     describe "GameObject with an image" do
-      before do
-        p Image.autoload_dirs
-        subject { GameObject.new(:image => "rect_20x20.png") }
-      end
-      
+
+      let(:game_object) { GameObject.new(:image => "rect_20x20.png") }
+
       it "should have width,height & size" do
-        subject.height.should == 20
-        subject.width.should == 20
-        subject.size.should == [20,20]
+        game_object.height.should == 20
+        game_object.width.should == 20
+        game_object.size.should == [20,20]
       end
       
       it "should adapt width,height & size to scaling" do
-        subject.factor = 2
-        subject.height.should == 40
-        subject.width.should == 40
-        subject.size.should == [40,40]
+        game_object.factor = 2
+        game_object.height.should == 40
+        game_object.width.should == 40
+        game_object.size.should == [40,40]
       end
 
       it "should adapt factor_x/factor_y to new size" do
-        subject.size = [10,40]  # half the width, double the height
-        subject.height.should == 10
-        subject.width.should == 40
-        subject.factor_x.should == 0.5
-        subject.factor_y.should == 2
+        game_object.size = [10,40]  # half the width, double the height
+        game_object.width.should == 10
+        game_object.height.should == 40
+        game_object.factor_x.should == 0.5
+        game_object.factor_y.should == 2
       end
       
     end
@@ -93,4 +91,4 @@ module Chingu
     
   end
 
-end
+end

data/spec/chingu/helpers/input_client_spec.rb

@@ -0,0 +1,180 @@
+require "spec_helper"
+
+module Chingu
+  describe Helpers::InputClient do
+    before :each do
+      $window = mock Gosu::Window
+      $window.stub!(:button_down?).and_return(false)
+
+      @subject = Object.new.extend described_class
+      @subject.stub!(:handler1).and_return(nil)
+      @handler1 = @subject.method :handler1
+      @subject.stub!(:handler2).and_return(nil)
+      @handler2 = @subject.method :handler2
+    end
+
+    describe "#holding?" do
+      it "should be true if that key is being held down" do
+        $window.should_receive(:button_down?).with(Gosu::KbSpace).and_return(true)
+        @subject.holding?(:space).should be_true
+      end
+
+      it "should be false if that key is being held down" do
+        $window.should_receive(:button_down?).with(Gosu::KbSpace).and_return(false)
+        @subject.holding?(:space).should be_false
+      end
+    end
+
+    describe "#holding_all?" do
+      it "should be true if all of those keys are being held down" do
+        $window.should_receive(:button_down?).with(Gosu::KbSpace).and_return(true)
+        $window.should_receive(:button_down?).with(Gosu::KbA).and_return(true)
+        @subject.holding_all?(:space, :a).should be_true
+      end
+
+      it "should be false if all of those keys are not being held down" do
+        @subject.holding_all?(:space, :a).should be_false
+      end
+
+      it "should be false if some of those keys are not being held down" do
+        $window.stub!(:button_down?).with(Gosu::KbSpace).and_return(true)
+        @subject.holding_all?(:space, :a).should be_false
+      end
+    end
+
+    describe "#holding_any?" do
+      it "should be true if any of those keys are being held down" do
+        $window.stub!(:button_down?).with(Gosu::KbA).and_return(true)
+        $window.stub!(:button_down?).with(Gosu::KbSpace).and_return(true)
+        @subject.holding_any?(:space, :a).should be_true
+      end
+
+      it "should be false if none of those keys are being held down" do
+        @subject.holding_any?(:space, :a).should be_false
+      end
+    end
+
+    describe "#input" do
+      it "should initially be an empty hash" do
+        @subject.input.should == {}
+      end
+    end
+
+    describe "#input=" do
+      it "should set the input hash" do
+        @subject.input = { :a => GameStates::Pause, :b => GameState }
+        @subject.input.should == { :a => [GameStates::Pause], :b => [GameState] }
+      end
+
+      it "should set the input array" do
+        @subject.stub!(:a)
+        @subject.stub!(:b)
+        @subject.input = [:a, :b]
+        @subject.input.should == { :a => [@subject.method(:a)], :b => [@subject.method(:b)] }
+      end
+    end
+
+    describe "#add_inputs" do
+      it "should set the input hash" do
+        @subject.add_inputs :a => GameStates::Pause, :b => GameState
+        @subject.input.should == { :a => [GameStates::Pause], :b => [GameState] }
+      end
+
+      it "should set the input array" do
+        @subject.stub!(:a)
+        @subject.stub!(:b)
+        @subject.add_inputs :a, :b
+        @subject.input.should == { :a => [@subject.method(:a)], :b => [@subject.method(:b)] }
+      end
+
+      # Not bothering with all the options, since it is tested fully, though indirectly, in #on_input already.
+      # I suspect it might be better to put the logic in on_input rather than in input too. Mmm.
+      it "should do other stuff"
+    end
+
+    describe "#on_input" do
+      it "should add a handler that is given as a block" do
+        block = lambda { }
+        @subject.on_input :a, &block
+        @subject.input.should == { :a => [block] }
+      end
+
+      it "should add a handler that is given as a method" do
+        @subject.on_input :a, @handler1
+        @subject.input.should == { :a => [@handler1] }
+      end
+
+      it "should add a handler that is given as a proc" do
+        proc = lambda { puts "Hello" }
+        @subject.on_input :a, proc
+        @subject.input.should == { :a => [proc] }
+      end
+
+      [:handler1, "handler1"].each do |handler|
+        it "should add a handler that is given as a #{handler.class}" do
+          @subject.on_input :a, handler
+          @subject.input.should == { :a => [@handler1] }
+        end
+      end
+
+      it "should add multiple handlers for the same event" do
+        @subject.on_input :a, @handler1
+        @subject.on_input :a, @handler2
+        @subject.input.should == { :a => [@handler1, @handler2] }
+      end
+
+      it "should automatically handle to a method if only the input is given" do
+        @subject.stub!(:a)
+        @subject.on_input :a
+        @subject.input.should == { :a => [ @subject.method(:a) ] }
+      end
+
+      it "should add multiple handlers for the same event, even if given different key names" do
+        @subject.on_input :left, @handler1
+        @subject.on_input :left_arrow, @handler2
+        @subject.input.should == { :left_arrow => [@handler1, @handler2] }
+      end
+
+      it "should add a handler that is given as a Chingu::GameState class" do
+        @subject.on_input :a, GameStates::Pause
+        @subject.input.should == { :a => [GameStates::Pause] }
+      end
+
+      it "should add a handler that is given as a Chingu::GameState instance" do
+        state = GameState.new
+        @subject.on_input :a, state
+        @subject.input.should == { :a => [state] }
+      end
+
+      it "should raise an error if given an unknown key" do
+        lambda { @subject.on_input :aardvark, @handler1 }.should raise_error ArgumentError
+      end
+
+      it "should raise an error if given an incorrect action" do
+        lambda { @subject.on_input :a, 47 }.should raise_error ArgumentError
+      end
+
+      it "should add a new handler if one already exists for that input" do
+        @subject.on_input :a, @handler1
+        @subject.on_input :b, @handler2
+        @subject.input.should == { :a => [@handler1], :b => [@handler2] }
+      end
+
+      it "should consider all key synonyms the same" do
+        @subject.on_input :left, @handler1
+        @subject.on_input :left_arrow, @handler2
+        @subject.input.should == { :left_arrow => [@handler1, @handler2] }
+      end
+
+      it "should split up and standardise key arrays" do
+        @subject.on_input([:space, :left], @handler1)
+        @subject.input.should == { :" " => [@handler1], :left_arrow => [@handler1] }
+      end
+
+      it "should raise an error if both an action and a hander are given" do
+        block = lambda { p "hello world" }
+        lambda { @subject.on_input :a, "Hello", &block }.should raise_error ArgumentError
+      end
+    end
+  end
+end

data/spec/chingu/helpers/input_dispatcher_spec.rb

@@ -0,0 +1,84 @@
+require "spec_helper"
+
+describe Chingu::Helpers::InputDispatcher do
+  before :each do
+    @subject = Object.new.extend described_class
+    @client = Object.new
+  end
+
+  it "should respond to methods" do
+     @subject.should respond_to :input_clients
+     @subject.should respond_to :add_input_client
+     @subject.should respond_to :remove_input_client
+  end
+
+  {"button_down" => :a, "button_up" => :released_a}.each_pair do |event, key|
+    describe "#dispatch_#{event}" do
+      it "should dispatch key event if key is handled" do
+        @client.should_receive(:handler).with(no_args)
+        @client.stub!(:input).with(no_args).and_return({ key => [@client.method(:handler)] })
+        @subject.send("dispatch_#{event}", Gosu::KbA, @client)
+      end
+
+      it "should not dispatch key event if key is not handled" do
+        @client.stub!(:input).with(no_args).and_return({})
+        @subject.send("dispatch_#{event}", Gosu::KbA, @client)
+      end
+    end
+  end
+
+  describe "#dispatch_input_for" do
+    before :each do
+      $window = mock Chingu::Window
+      $window.stub!(:button_down?).and_return(false)
+    end
+
+    it "should dispatch if a key is being held" do
+      @client.should_receive(:handler).with(no_args)
+      $window.stub!(:button_down?).with(Gosu::KbA).and_return(true)
+      @client.stub!(:input).with(no_args).and_return({:holding_a => [@client.method(:handler)]})
+      @subject.dispatch_input_for(@client)
+    end
+
+    it "should do nothing if a key is not held" do
+      @client.stub!(:input).with(no_args).and_return({:holding_a => [lambda { raise "Shouldn't handle input!"}]})
+      @subject.dispatch_input_for(@client)
+    end
+  end
+
+
+  describe "#dispatch_actions" do
+    it "should call a method" do
+      @client.should_receive(:handler).with(no_args)
+      @subject.send(:dispatch_actions, [@client.method(:handler)])
+    end
+
+    it "should call a proc" do
+      @client.should_receive(:handler)
+      @subject.send(:dispatch_actions, [lambda { @client.handler }])
+    end
+
+    it "should push a game-state instance" do
+      state = Chingu::GameState.new
+      @subject.should_receive(:push_game_state).with(state)
+      @subject.send(:dispatch_actions, [state])
+    end
+    
+    it "should push a game-state class" do
+      @subject.should_receive(:push_game_state).with(Chingu::GameState)
+      @subject.send(:dispatch_actions, [Chingu::GameState])
+    end
+
+    it "should call multiple actions if more have been set" do
+      other = Object.new
+      other.should_receive(:handler).with(no_args)
+      @client.should_receive(:handler).with(no_args)
+      @subject.send(:dispatch_actions, [@client.method(:handler), other.method(:handler)])
+    end
+
+    # Note, doesn't check if a passed class is incorrect. Life is too short.
+    it "should raise an error with unexpected data" do
+      lambda { @subject.send(:dispatch_actions, [12]) }.should raise_error ArgumentError
+    end
+  end
+end

data/spec/chingu/helpers/options_setter_spec.rb

@@ -16,7 +16,7 @@ module Chingu
   module Helpers   
     describe OptionsSetter do
       
-      describe "using without defaults" do
+      context "using without defaults" do
         before do
           @car = Car.new(:angle => 44)
         end

data/spec/spec_helper.rb

@@ -5,7 +5,7 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 # encoding: utf-8
 require 'rubygems'
 require 'rspec'
-require 'require_all'
+require 'chingu/require_all'
 
 require 'chingu'
 require 'chingu/helpers/options_setter'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: chingu
 version: !ruby/object:Gem::Version 
-  hash: 127
+  hash: 125
   prerelease: false
   segments: 
   - 0
   - 7
   - 6
-  - 8
-  version: 0.7.6.8
+  - 9
+  version: 0.7.6.9
 platform: ruby
 authors: 
 - ippa
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-15 00:00:00 +02:00
+date: 2010-08-18 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -43,7 +43,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: -957518095
+        hash: -138847361
         segments: 
         - 2
         - 0
@@ -212,6 +212,7 @@ files:
 - lib/chingu/particle.rb
 - lib/chingu/rect.rb
 - lib/chingu/require_all.rb
+- lib/chingu/simple_menu.rb
 - lib/chingu/text.rb
 - lib/chingu/traits/animation.rb
 - lib/chingu/traits/bounding_box.rb
@@ -227,7 +228,10 @@ files:
 - lib/chingu/window.rb
 - spec/chingu/fpscounter_spec.rb
 - spec/chingu/game_object_spec.rb
+- spec/chingu/helpers/input_client_spec.rb
+- spec/chingu/helpers/input_dispatcher_spec.rb
 - spec/chingu/helpers/options_setter_spec.rb
+- spec/chingu/images/rect_20x20.png
 - spec/chingu/inflector_spec.rb
 - spec/chingu/rect_20x20.png
 - spec/chingu/text_spec.rb
@@ -270,6 +274,8 @@ summary: OpenGL accelerated 2D game framework for Ruby
 test_files: 
 - spec/chingu/fpscounter_spec.rb
 - spec/chingu/game_object_spec.rb
+- spec/chingu/helpers/input_client_spec.rb
+- spec/chingu/helpers/input_dispatcher_spec.rb
 - spec/chingu/helpers/options_setter_spec.rb
 - spec/chingu/inflector_spec.rb
 - spec/chingu/text_spec.rb