chingu 0.5.5.3

data/lib/chingu/gfx_helpers.rb

@@ -0,0 +1,89 @@
+#--
+#
+# Chingu -- Game framework built on top of the opengl accelerated gamelib Gosu
+# 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
+  #
+  # Various helper-methods to manipulate the screen.
+  # All drawings depend on the global variable $window which should be an instance of Gosu::Window or Chingu::Window
+  #
+  module GFXHelpers
+  
+    #
+    # Fills whole window with color 'color'.
+    #
+    def fill(color)
+      $window.draw_quad(0, 0, color,
+                        $window.width, 0, color,
+                        $window.width, $window.height, color,
+                        0, $window.height, color,
+                        0, :default)
+    end
+     
+    #
+    # Fills a given Rect 'rect' with Color 'color'
+    #
+    def fill_rect(rect, color)
+      rect = Rect.new(rect)     # Make sure it's a rect
+      $window.draw_quad(  rect.x, rect.y, color,
+                          rect.right, rect.y, color,
+                          rect.right, rect.bottom, color,
+                          rect.x, rect.bottom, color,
+                          0, :default)
+    end
+    
+    #
+    # Fills window or a given rect with a gradient between two colors.
+    #
+    #   :from         - Start with this color
+    #   :to           - End with this color
+    #   :rect         - Only fill rectangle :rect with the gradient, either a Rect-instance or [x,y,width,height] Array.
+    #   :orientation  - Either :vertical (top to bottom) or :horizontal (left to right)
+    #
+    def fill_gradient(options)
+      default_options = { :from => Gosu::Color.new(255,0,0,0),
+                          :to => Gosu::Color.new(255,255,255,255), 
+                          :thickness => 10, 
+                          :orientation => :vertical,
+                          :rect => Rect.new([0, 0, $window.width, $window.height]),
+                          :zorder => 0,
+                          :mode => :default
+                        }
+			options = default_options.merge(options)
+      rect = Rect.new(options[:rect])      
+      if options[:orientation] == :vertical
+        $window.draw_quad(  rect.x, rect.y, options[:from],
+                            rect.right, rect.y, options[:from],
+                            rect.right, rect.bottom, options[:to],
+                            rect.x, rect.bottom, options[:to],
+                            options[:zorder], options[:mode]
+                          )
+      else
+        $window.draw_quad(  rect.x, rect.y, options[:from],
+                            rect.x, rect.bottom, options[:from],
+                            rect.right, rect.bottom, options[:to],
+                            rect.right, rect.y, options[:to],
+                            options[:zorder], options[:mode]
+                          )        
+      end
+    end
+  end
+end

data/lib/chingu/helpers.rb

@@ -0,0 +1,166 @@
+#--
+#
+# Chingu -- Game framework built on top of the opengl accelerated gamelib Gosu
+# 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
+  
+  module InputClient
+    def input=(input_map)
+      @input = input_map
+      @parent.add_input_client(self)  if @parent
+    end
+    
+    def input
+      @input
+    end
+  end
+    
+  module InputDispatcher
+    attr_reader :input_clients
+    
+    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
+    
+    #
+    # For a given object, dispatch "action".
+    # An action can be:
+    #
+    # * 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 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.
+  #
+  # It will make call new() on a class, and just push an object.
+  #
+  module GameStateHelpers
+    def push_game_state(state, options = {})
+      $window.game_state_manager.push_game_state(state, options)      
+    end
+  
+    def pop_game_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 transitional_game_state(state, options = {})
+      $window.game_state_manager.transitional_game_state(state, options)      
+    end
+
+    def current_game_state
+      $window.game_state_manager.current_game_state
+    end
+
+    def previous_game_state
+      $window.game_state_manager.previous_game_state
+    end
+    
+    def clear_game_states
+      $window.game_state_manager.clear_game_states
+    end
+  end
+  
+  module GameObjectHelpers
+  
+    def add_game_object(object)
+      @game_objects.add_game_object(object)
+    end
+    
+    def remove_game_object(object)
+      @game_objects.remove_game_object(object)
+    end
+    
+    def game_objects
+      @game_objects
+    end
+    
+    #
+    # 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/inflector.rb

@@ -0,0 +1,34 @@
+#--
+#
+# Chingu -- Game framework built on top of the opengl accelerated gamelib Gosu
+# 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
+  module Inflector    
+    def Inflector.camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+      if first_letter_in_uppercase
+        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      else
+        lower_case_and_underscored_word.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+      end
+    end
+
+  end
+end

data/lib/chingu/input.rb

@@ -0,0 +1,100 @@
+module Chingu
+	module Input
+		include Gosu::Button
+    
+    #
+    # Ruby symbols describing http://www.libgosu.org/rdoc/classes/Gosu.html
+    #
+		CONSTANT_TO_SYMBOL = {
+      Kb0 => [:zero],
+      Kb1 => [:one],
+      Kb2 => [:two],
+      Kb3 => [:three],
+      Kb4 => [:four],
+      Kb5 => [:five],
+      Kb6 => [:six],
+      Kb7 => [:seven],
+      Kb8 => [:eight],
+      Kb9 => [:nine],
+    
+      KbBackspace => [:backspace],
+      KbDelete    => [:delete, :del],
+      KbDown      => [:down_arrow, :down],
+      KbEnd       => [:end],
+      KbEnter     => [:enter],
+      KbEscape    => [:escape, :esc],
+
+      KbHome        => [:home],
+      KbInsert      => [:insert, :ins],
+      KbLeft        => [:left_arrow, :left],
+      KbLeftAlt     => [:left_alt, :lalt],
+      KbLeftControl => [:left_control, :left_ctrl, :lctrl],
+      KbLeftShift   => [:left_shift, :lshift],
+      
+      
+      KbNumpadAdd       => [:"+", :add],
+      KbNumpadDivide    => [:"/", :divide],
+      KbNumpadMultiply  => [:"*", :multiply],
+      KbNumpadSubtract  => [:"-", :subtract],
+      KbPageDown        => [:page_down],
+      KbPageUp          => [:page_up],
+      # KbPause           => [:pause],
+      KbReturn          => [:return],
+      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_arrow, :up],
+      
+      MsLeft            => [:left_mouse_button, :mouse_left],
+      MsMiddle          => [:middle_mouse_button, :mouse_middle],
+      MsRight           => [:right_mouse_button, :mouse_right],
+      MsWheelDown       => [:mouse_wheel_down, :wheel_down],
+      MsWheelUp         => [:mouse_wheel_up, :wheel_up],
+      
+      GpDown 	          => [:gamepad_down, :gp_down, :pad_down],
+      GpLeft 	          => [:gamepad_left, :gp_left, :pad_left],
+      GpRight 	        => [:gamepad_right, :gp_right, :pad_right],
+      GpUp              => [:gamepad_up, :gp_up, :pad_up]
+		}
+    
+    # Letters, A-Z
+    ("A".."Z").each do |letter|
+      CONSTANT_TO_SYMBOL[eval("Kb#{letter}")] = [letter.downcase.to_sym]
+    end
+
+    # Numbers, 0-9
+    (0..9).each do |number|
+      CONSTANT_TO_SYMBOL[eval("Kb#{number.to_s}")] = [number.to_s.to_sym]
+    end
+
+    # Numpad-numbers, 0-9
+    (0..9).each do |number|
+      CONSTANT_TO_SYMBOL[eval("KbNumpad#{number.to_s}")] = ["numpad_#{number.to_s}".to_sym]
+    end
+
+    #F-keys, F1-F12
+    (1..12).each do |number|
+      CONSTANT_TO_SYMBOL[eval("KbF#{number.to_s}")] = ["f#{number.to_s}".to_sym]
+    end
+
+    # Gamepad-buttons 0-15
+    (0..15).each do |number|
+      CONSTANT_TO_SYMBOL[eval("GpButton#{number.to_s}")] = ["gamepad_button_#{number.to_s}"]
+    end
+
+    #
+    # Reverse CONSTANT_TO_SYMBOL -> SYMBOL_TO_CONSTNT
+    # like: SYMBOL_TO_CONSTANT = CONSTANT_TO_SYMBOL.invert.dup
+    #
+    SYMBOL_TO_CONSTANT = Hash.new
+    CONSTANT_TO_SYMBOL.each_pair do |constant, symbols|
+      symbols.each do |symbol|
+        SYMBOL_TO_CONSTANT[symbol] = constant
+      end
+    end
+    
+	end
+end

data/lib/chingu/named_resource.rb

@@ -0,0 +1,254 @@
+#--
+#	Rubygame -- Ruby code and bindings to SDL to facilitate game creation
+#	Copyright (C) 2004-2008  John Croisant
+#
+#	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
+
+  #  NamedResource is a mix-in module to implement a globally-available
+  #  resource table, a @name variable and accessors, and a system for
+  #  automatically loading resources when they are first needed.
+  #
+  #  This module is used for Rubygame::Music, Rubygame::Sound, and
+  #  Rubygame::Surface. You can use it in your own classes this way:
+  #
+  #  1. Do 'include Rubygame::NamedResource' in your class definition.
+  #
+  #  2. Set MyClass.autoload_dirs to an Array of directories to look
+  #     for files when autoloading. Tip: use File.join to create
+  #     paths that work on any operating system.
+  #
+  #  3. Define #autoload to implement the behavior for your class,
+  #     or leave it as the default if you don't need autoloading.
+  #     See the docs for #autoload for more information.
+  #
+  #  Here's an example of how you could use this for a class which
+  #  loads maps from a file:
+  #
+  #      class Map
+  #        include Rubygame::NamedResource
+  #
+  #        Map.autoload_dirs = [ File.join("maps","world_1"),
+  #                              File.join("maps","custom") ]
+  #
+  #        def autoload( name )
+  #          # Searches autoload_dirs for the file
+  #          path = find_file( name )
+  #
+  #          if( path )
+  #            return load_map( path )
+  #          else
+  #            return nil
+  #          end
+  #        end
+  #
+  #        def load_map( path )
+  #          # Your code to do the real loading, then return
+  #          # the created instance of Map class.
+  #          # ...
+  #          return map_instance
+  #        end
+  #      end
+  #
+  #  Here's an example of how you could then use the Map class:
+  #
+  #      map = Map["level_1.map"]
+  #
+  #      if( map )
+  #        start_playing( map )
+  #      else
+  #        raise "Oops! The map file for Level 1 doesn't exist!"
+  #      end
+  #
+  module NamedResource
+
+
+    #  Adds class methods when the NamedResource module is included
+    #  in a class. (Here, we are assuming that the NamedResource
+    #  module was included in a class called MyClass.)
+    module NamedResourceClassMethods
+
+      #  An Array of paths to check for files. See #find_file.
+      attr_accessor :autoload_dirs
+
+
+      #  call-seq:
+      #    MyClass[ name ]  ->  instance or nil
+      #
+      #  Retrieves an instance of the class from a per-class resource
+      #  table (Hash).
+      #
+      #  If no object has been saved under the given name, invoke
+      #  #autoload to try to load a new instance, store it in the
+      #  Hash table under this name, and sets the instance's @name
+      #  to this name.
+      #
+      def []( name )
+        result = @resources[name]
+
+        if result.nil?
+          result = autoload(name)
+          if result
+            self[name] = result
+            result.name = name
+          end
+        end
+
+        return result
+      end
+
+
+      #  call-seq:
+      #    MyClass[ name ] = instance
+      #
+      #  Stores an instance of the class in a per-class resource table
+      #  (Hash) for future access. If another object is already stored
+      #  with this name, the old record is lost.
+      #
+      #  May raise:  TypeError, if you try to store anything
+      #             that is not kind of this class.
+      #
+      def []=( name, value )
+        ##if( value.kind_of? self )
+          @resources[name] = value
+        ##else
+        ## raise TypeError, "#{self}#[]= can only store instances of #{self}"
+        ##end
+      end
+
+      #  call-seq:
+      #    MyClass.autoload( name )  ->  instance or nil
+      #
+      #  This method is invoked when a non-existing resource is
+      #  accessed with #[]. By default, this method simply returns
+      #  nil, effectively disabling autoloading.
+      #
+      #  You should override this method in your class to provide
+      #  class-specific loading behavior, or leave it as the default if
+      #  you don't need autoloading. Your method should return either
+      #  an instance of the class, or nil.
+      #
+      #  NOTE: The #find_file method is useful for getting the full
+      #  path to a file which matches the name. That's what it's there
+      #  for, so you should use it!
+      #
+      def autoload( name )
+        nil
+      end
+
+
+      #  call-seq:
+      #    MyClass.basename( path )  ->  filename
+      #
+      #  Returns the basename for the path (i.e. the
+      #  filename without the directory). Same as
+      #  File.basename
+      #
+      def basename( path )
+        File.basename( path )
+      end
+
+
+      #  call-seq:
+      #    MyClass.exist?( path )  ->  true or false
+      #
+      #  True if the given path points to a file
+      #  that exists, otherwise false. Same as
+      #  File.exist?
+      #
+      def exist?( path )
+        File.exist?(path)
+      end
+
+
+      #  call-seq:
+      #    MyClass.find_file( filename )  ->  path or nil
+      #
+      #  Checks every directory in @autoload_dirs for
+      #  a file with the given name, and returns the
+      #  path (directory and name) for the first match.
+      #
+      #  If no directories have a file with that name,
+      #  return nil.
+      #
+      def find_file( filename )
+        dir = @autoload_dirs.find { |dir|
+          exist?( File.join(dir,filename) )
+        }
+
+        if dir
+          return File.join(dir,filename)
+        else
+          return nil
+        end
+      end
+
+    end
+
+
+    #  Sets up the class when this module is included.
+    #  Adds the class methods and defines class instance
+    #  variables.
+    def self.included( object ) # :nodoc:
+
+      class << object
+        include NamedResourceClassMethods
+      end
+
+      object.instance_eval do
+        @resources = Hash.new
+        @autoload_dirs = []
+      end
+
+    end
+
+
+    # Returns the instance's @name. See also #name=.
+    def name
+      @name
+    end
+
+    #
+    #  Sets the instance's @name to the given String, or nil to
+    #  unset the name. See also #name.
+    #
+    #  NOTE: This does not automatically store the instance in the
+    #  class resource table by name. Use the #[]= class method to do
+    #  that.
+    #
+    #  The string is dup'ed and frozen before being stored.
+    #
+    #  May raise:  TypeError, if new_name is not a String or nil.
+    #
+    def name=( new_name )
+      if new_name.nil?
+        return @name = nil
+      end
+
+      unless new_name.kind_of? String
+        raise TypeError, "name must be a String (got #{new_name.class})"
+      end
+
+      @name = new_name.dup
+      @name.freeze
+    end
+
+
+  end
+
+end