chingu 0.7.6.5 → 0.7.6.6

data/chingu.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{chingu}
-  s.version = "0.7.6.5"
+  s.version = "0.7.6.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["ippa"]
-  s.date = %q{2010-06-22}
+  s.date = %q{2010-06-24}
   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 = [

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.5"
+  VERSION = "0.7.6.6"
   
   DEBUG_COLOR = Gosu::Color.new(0xFFFF0000)
   DEBUG_ZORDER = 9999

data/lib/chingu/game_state_manager.rb

@@ -100,7 +100,6 @@ module Chingu
     # .. and finalize() is called on the game state we're switching _from_.
     #
     def switch_game_state(state, options = {})
-      puts state.class
       options = {:setup => true, :finalize => true, :transitional => true}.merge(options)
 
       @previous_game_state = current_game_state
@@ -195,8 +194,8 @@ module Chingu
       #
       # Give the soon-to-be-disabled state a chance to clean up by calling finalize() on it.
       #
-      @previous_game_state = current_game_state
       current_game_state.finalize    if current_game_state.respond_to?(:finalize) && options[:finalize]
+      @previous_game_state = current_game_state
 
       #
       # Activate the game state "bellow" current one with a simple Array.pop

data/lib/chingu/game_states/edit.rb

@@ -46,29 +46,38 @@ module Chingu
     class Edit < Chingu::GameState
       attr_accessor :grid, :debug, :file, :hud_color
       attr_reader :classes, :exclude
-      
+
       def initialize(options = {})
         super
+        
+        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)
+        @draw_grid = options[:draw_grid]
+        @snap_to_grid = options[:snap_to_grid]      # todo
+        @resize_to_grid = options[:resize_to_grid]  # todo
+        
         @classes = Array(options[:classes] || game_object_classes)
         @except = options[:except] || []
-        @classes -= Array(@except)        
+        @classes -= Array(@except)
         @debug = options[:debug]
         @zorder = 10000
-                
+
         p @classes  if @debug
-        
-        @hud_color = Gosu::Color.new(180,70,70,70)
-        @selected_game_object = nil        
-        self.input =  { 
-          :left_mouse_button => :left_mouse_button, 
+
+        @hud_color = Gosu::Color.new(200,70,70,70)
+        @selected_game_object = nil
+        self.input =  {
+          :left_mouse_button => :left_mouse_button,
           :released_left_mouse_button => :released_left_mouse_button,
           :right_mouse_button => :right_mouse_button,
-          :released_right_mouse_button => :released_right_mouse_button, 
-                        
-          :delete => :destroy_selected_game_objects,
+          :released_right_mouse_button => :released_right_mouse_button,
+
+          :delete    => :destroy_selected_game_objects,
+          :d         => :destroy_selected_game_objects,
           :backspace => :reset_selected_game_objects,
-                        
+
           :holding_numpad_7 => :scale_down,
           :holding_numpad_9 => :scale_up,
           :holding_numpad_4 => :tilt_left,
@@ -87,42 +96,43 @@ module Chingu
 
           :page_up => :inc_zorder,
           :page_down => :dec_zorder,
-          
+
           :s => :try_save,
           :a => :try_select_all,
-    
+
           :e => :save_and_quit,
-          
+
           :esc => :esc,
           :q => :quit,
-          
+
           :up_arrow => :move_up,
           :down_arrow => :move_down,
           :left_arrow => :move_left,
           :right_arrow => :move_right,
-          
+
           :holding_up_arrow => :try_scroll_up,
           :holding_down_arrow => :try_scroll_down,
           :holding_left_arrow => :try_scroll_left,
           :holding_right_arrow => :try_scroll_right,
-          
+
           :plus => :scale_up,
           :minus => :scale_down,
           :mouse_wheel_up => :mouse_wheel_up,
           :mouse_wheel_down => :mouse_wheel_down,
-                        
+
           :"1" => :create_object_1,
           :"2" => :create_object_2,
           :"3" => :create_object_3,
           :"4" => :create_object_4,
           :"5" => :create_object_5,
         }
-        
+
+        @hud_height = 140
         x = 20
         y = 60
         @classes.each do |klass|
           puts "Creating a #{klass}"  if @debug
-          
+
           # We initialize x,y,zorder,rotation_center after creation
           # so they're not overwritten by the class initialize/setup or simular
           begin
@@ -131,12 +141,13 @@ module Chingu
             game_object.y = y
             game_object.zorder = @zorder
             game_object.options[:toolbar] = true
-            
+
             # Scale down object to fit our toolbar
             if game_object.image
+              Text.create("#{klass}\n#{game_object.width.to_i}x#{game_object.height.to_i}", :size => 13, :x=>x-16, :y=>y+18, :zorder => @zorder)
               game_object.size = [32,32]
               game_object.cache_bounding_box if game_object.respond_to?(:cache_bounding_box)
-              x += 40
+              x += 60
             else
               puts "Skipping #{klass} - no image" if @debug
               game_object.destroy
@@ -147,6 +158,23 @@ module Chingu
         end
       end
       
+      def draw_grid
+        return unless @grid
+        
+        start_x = start_y = 0,0
+        if defined?(previous_game_state.viewport)
+          start_x = -previous_game_state.viewport.x % @grid.first
+          start_y = -previous_game_state.viewport.y % @grid.last
+        end
+        (start_x .. $window.width).step(@grid.first).each do |x|
+          $window.draw_line(x, 1, @grid_color, x, $window.height, @grid_color, @zorder-10, :additive)
+        end
+        (start_y .. $window.height).step(@grid.last).each do |y|
+          $window.draw_line(1, y, @grid_color, $window.width, y, @grid_color, @zorder-10, :additive)
+        end
+        
+      end
+
       #
       # SETUP
       #
@@ -157,6 +185,12 @@ module Chingu
         @title.text += " - Grid: #{@grid}" if @grid
         @text = Text.create("", :x => 300, :y => 20, :factor => 1, :size => 16, :zorder => @zorder)
         @status_text = Text.create("-", :x => 5, :y => 20, :factor => 1, :size => 16, :zorder => @zorder)
+        
+        if defined?(previous_game_state.viewport)
+          @game_area_backup = previous_game_state.viewport.game_area.dup
+          previous_game_state.viewport.game_area.x -= @hud_height
+          previous_game_state.viewport.game_area.y -= @hud_height
+        end        
       end
                   
       #
@@ -184,8 +218,11 @@ module Chingu
           selected_game_objects.each do |selected_game_object|            
             selected_game_object.x = self.mouse_x + selected_game_object.options[:mouse_x_offset]
             selected_game_object.y = self.mouse_y + selected_game_object.options[:mouse_y_offset]
-            selected_game_object.x -= selected_game_object.x % @grid[0]
-            selected_game_object.y -= selected_game_object.y % @grid[1]
+            
+            if @snap_to_grid
+              selected_game_object.x -= selected_game_object.x % @grid[0]
+              selected_game_object.y -= selected_game_object.y % @grid[1]
+            end
           end
           
           # TODO: better cleaner sollution
@@ -218,13 +255,15 @@ module Chingu
         
         super
         
+        draw_grid if @draw_grid
+                
         #
         # Draw an edit HUD
         #
         $window.draw_quad(  0,0,@hud_color,
                             $window.width,0,@hud_color,
-                            $window.width,100,@hud_color,
-                            0,100,@hud_color, @zorder-1)
+                            $window.width,@hud_height,@hud_color,
+                            0,@hud_height,@hud_color, @zorder-1)
         
         #
         # Draw red rectangles/circles around all selected game objects
@@ -423,6 +462,12 @@ module Chingu
         quit
       end
 
+      def finalize
+        if defined?(previous_game_state.viewport)
+          previous_game_state.viewport.game_area = @game_area_backup
+        end
+      end
+            
       def move_left
         scroll_left && return   if selected_game_objects.empty?
         selected_game_objects.each { |game_object| game_object.x -= 1 }

data/lib/chingu/game_states/fade_to.rb

@@ -36,7 +36,7 @@ module Chingu
     class FadeTo < Chingu::GameState
       
       def initialize(new_game_state, options = {})
-        @options = {:speed => 3}.merge(options)
+        @options = {:speed => 3, :zorder => 999999}.merge(options)
         
         @new_game_state = new_game_state
         @new_game_state = new_game_state.new if new_game_state.is_a? Class        
@@ -81,7 +81,7 @@ module Chingu
           $window.draw_quad( 0,0,@color,
                               $window.width,0,@color,
                               $window.width,$window.height,@color,
-                              0,$window.height,@color,999)
+                              0,$window.height,@color,@options[:zorder])
         end
         
         if @fading_in && @alpha == 0

data/lib/chingu/rect.rb

@@ -1,612 +1,629 @@
-#--
-#	Rubygame -- Ruby code and bindings to SDL to facilitate game creation
-#	Copyright (C) 2004-2007  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
-#++
-
-#--
-# Table of Contents:
-#
-# class Rect
-# 	GENERAL:
-# 		initialize
-# 		new_from_object
-# 		to_s
-# 		to_a, to_ary
-# 		[]
-# 	ATTRIBUTES:
-# 		x, y, w, h [<- accessors]
-# 		width, height, size
-# 		left, top, right, bottom
-# 		center, centerx, centery
-# 		topleft, topright
-# 		bottomleft, bottomright
-# 		midleft, midtop, midright, midbottom
-# 	UTILITY METHODS:
-# 		clamp, clamp!
-# 		clip, clip!
-# 		collide_hash, collide_hash_all
-# 		collide_array, collide_array_all
-# 		collide_point?
-# 		collide_rect?
-# 		contain?
-# 		inflate, inflate!
-# 		move, move!
-# 		normalize, normalize!
-# 		union, union!
-# 		union_all, union_all!
-#
-#	class Surface
-#		make_rect
-# 
-#++
-
-module Chingu
-
-# A Rect is a representation of a rectangle, with four core attributes
-# (x offset, y offset, width, and height) and a variety of functions
-# for manipulating and accessing these attributes.
-#
-# Like all coordinates in Rubygame (and its base library, SDL), x and y
-# offsets are measured from the top-left corner of the screen, with greater
-# y offsets being lower. Thus, specifying the x and y offsets of the Rect
-# is equivalent to setting the location of its top-left corner.
-# 
-# In Rubygame, Rects are used for collision detection and describing 
-# the area of a Surface to operate on.
-class Rect < Array
-
-	#--
-	# GENERAL
-	#++
-
-	# Create a new Rect, attempting to extract its own information from 
-	# the given arguments. The arguments must fall into one of these cases:
-	# 
-	#   - 4 integers +(x, y, w, h)+.
-	#   - 1 Rect or Array containing 4 integers +([x, y, w, h])+.
-	#   - 2 Arrays containing 2 integers each +([x,y], [w,h])+.
-	#   - 1 object with a +rect+ attribute which is a valid Rect object.
-	# 
-	# All rect core attributes (x,y,w,h) must be integers.
-	# 
-	def initialize(*argv)
-		case argv.length
-		when 1
-			if argv[0].kind_of? Array; super(argv[0])
-			elsif argv[0].respond_to? :rect; super(argv[0])
-			end
-		when 2
-			super(argv[0].concat(argv[1]))
-		when 4
-			super(argv)
-		end
-		return self
-	end
-
-	# Extract or generate a Rect from the given object, if possible, using the
-	# following process:
-	# 
-	#  1. If it's a Rect already, return a duplicate Rect.
-	#  2. Elsif it's an Array with at least 4 values, make a Rect from it.
-	#  3. Elsif it has a +rect+ attribute., perform (1) and (2) on that.
-	#  4. Otherwise, raise TypeError.
-	# 
-	# See also Surface#make_rect()
-	def Rect.new_from_object(object)
-		case(object)
-		when Rect
-			return object.dup
-		when Array 
-			if object.length >= 4
-				return Rect.new(object)
-			else
-				raise(ArgumentError,"Array does not have enough indices to be made into a Rect (%d for 4)."%object.length )
-			end
-		else
-			begin
-				case(object.rect)
-				when Rect
-					return object.rect.dup
-				when Array
-					if object.rect.length >= 4
-						return Rect.new(object.rect)
-					else
-						raise(ArgumentError,"Array does not have enough indices to be made into a Rect (%d for 4)."%object.rect.length )
-					end
-				end				# case object.rect
-			rescue NoMethodError # if no rect.rect
-				raise(TypeError,"Object must be a Rect or Array [x,y,w,h], or have an attribute called 'rect'. (Got %s instance.)"%object.class)
-			end
-		end # case object
-	end
-
-
-	# Print the Rect in the form "+#<Rect [x,y,w,h]>+"
-	def to_s; "#<Rect [%s,%s,%s,%s]>"%self; end
-
-	# Print the Rect in the form "+#<Rect:id [x,y,w,h]>+"
-	def inspect; "#<Rect:#{self.object_id} [%s,%s,%s,%s]>"%self; end
-
-	#--
-	# ATTRIBUTES
-	#++
-
-	# Returns self.at(0)
-	def x; return self.at(0); end
-	# Sets self[0] to +val+
-	def x=(val); self[0] = val; end
-
-	alias left x
-	alias left= x=;
-	alias l x
-	alias l= x=;
-
-	# Returns self.at(1)
-	def y; return self.at(1); end
-	# Sets self[1] to +val+
-	def y=(val); self[1] = val; end
-
-	alias top y
-	alias top= y=;
-	alias t y
-	alias t= y=;
-
-	# Returns self.at(2)
-	def w; return self.at(2); end
-	# Sets self[2] to +val+
-	def w=(val); self[2] = val; end
-
-	alias width w
-	alias width= w=;
-
-	# Returns self.at(3)
-	def h; return self.at(3); end
-	# Sets self[3] to +val+
-	def h=(val); self[3] = val; end
-
-	alias height h
-	alias height= h=;
-
-	# Return the width and height of the Rect.
-	def size; return self[2,2]; end
-
-	# Set the width and height of the Rect.
-	def size=(size)
-	 raise ArgumentError, "Rect#size= takes an Array of form [width, height]." if size.size != 2
-	 self[2,2] = size
-	 size
-	end
-
-	# Return the x coordinate of the right side of the Rect.
-	def right; return self.at(0)+self.at(2); end
-
-	# Set the x coordinate of the right side of the Rect by translating the
-	# Rect (adjusting the x offset).
-	def right=(r); self[0] = r - self.at(2); return r; end
-
-	alias r right
-	alias r= right=;
-
-	# Return the y coordinate of the bottom side of the Rect.
-	def bottom; return self.at(1)+self.at(3); end
-
-	# Set the y coordinate of the bottom side of the Rect by translating the
-	# Rect (adjusting the y offset).
-	def bottom=(b); self[1] = b - self.at(3); return b; end
-
-	alias b bottom
-	alias b= bottom=;
-
-	# Return the x and y coordinates of the center of the Rect.
-	def center; return self.centerx, self.centery; end
-
-	# Set the x and y coordinates of the center of the Rect by translating the
-	# Rect (adjusting the x and y offsets).
-	def center=(center)
-	    raise ArgumentError, "Rect#center= takes an Array of the form [x,y]." if center.size != 2
-		self.centerx, self.centery = center
-		center
-	end
-	alias c center
-	alias c= center=;
-
-	# Return the x coordinate of the center of the Rect
-	def centerx; return self.at(0)+(self.at(2).div(2)); end
-
-	# Set the x coordinate of the center of the Rect by translating the
-	# Rect (adjusting the x offset).
-	def centerx=(x); self[0] = x - (self.at(2).div(2)); return x; end
-
-	alias cx centerx
-	alias cx= centerx=;
-
-	# Return the y coordinate of the center of the Rect
-	def centery; return self.at(1)+(self.at(3).div(2)); end
-
-	# Set the y coordinate of the center of the Rect by translating the
-	# Rect (adjusting the y offset).
-	def centery=(y); self[1] = y- (self.at(3).div(2)); return y; end
-
-	alias cy centery
-	alias cy= centery=;
-
-	# Return the x and y coordinates of the top-left corner of the Rect
-	def topleft; return self[0,2].to_a; end
-
-	# Set the x and y coordinates of the top-left corner of the Rect by 
-	# translating the Rect (adjusting the x and y offsets).
-	def topleft=(topleft)
-	    raise ArgumentError, "Rect#topright= takes an Array of form [x, y]." if topleft.size != 2
-		self[0,2] = topleft
-		return topleft
-	end
-
-	alias tl topleft
-	alias tl= topleft=;
-
-	# Return the x and y coordinates of the top-right corner of the Rect
-	def topright; return self.right, self.at(1); end
-
-	# Set the x and y coordinates of the top-right corner of the Rect by 
-	# translating the Rect (adjusting the x and y offsets).
-	def topright=(topright)
-	    raise ArgumentError, "Rect#topright= takes an Array of form [x, y]." if topright.size != 2
-		self.right, self[1] = topright
-		return topright
-	end
-
-	alias tr topright
-	alias tr= topright=;
-
-	# Return the x and y coordinates of the bottom-left corner of the Rect
-	def bottomleft; return self.at(0), self.bottom; end
-
-	# Set the x and y coordinates of the bottom-left corner of the Rect by 
-	# translating the Rect (adjusting the x and y offsets).
-	def bottomleft=(bottomleft)
-		raise ArgumentError, "Rect#bottomleft= takes an Array of form [x, y]." if bottomleft.size != 2
-		self[0], self.bottom = bottomleft
-		return bottomleft
-	end
-
-	alias bl bottomleft
-	alias bl= bottomleft=;
-
-	# Return the x and y coordinates of the bottom-right corner of the Rect
-	def bottomright; return self.right, self.bottom; end
-
-	# Set the x and y coordinates of the bottom-right corner of the Rect by 
-	# translating the Rect (adjusting the x and y offsets).
-	def bottomright=(bottomright)
-		raise ArgumentError, "Rect#bottomright= takes an Array of form [x, y]." if bottomright.size != 2
-		self.right, self.bottom = bottomright
-		return bottomright
-	end
-
-	alias br bottomright
-	alias br= bottomright=;
-
-	# Return the x and y coordinates of the midpoint on the left side of the
-	# Rect.
-	def midleft; return self.at(0), self.centery; end	
-
-	# Set the x and y coordinates of the midpoint on the left side of the Rect
-	# by translating the Rect (adjusting the x and y offsets).
-	def midleft=(midleft)
-    	raise ArgumentError, "Rect#midleft= takes an Array of form [x, y]." if midleft.size != 2
-		self[0], self.centery = midleft
-		return midleft
-	end
-
-	alias ml midleft
-	alias ml= midleft=;
-
-	# Return the x and y coordinates of the midpoint on the left side of the
-	# Rect.
-	def midtop; return self.centerx, self.at(1); end	
-
-	# Set the x and y coordinates of the midpoint on the top side of the Rect
-	# by translating the Rect (adjusting the x and y offsets).
-	def midtop=(midtop)
-    	raise ArgumentError, "Rect#midtop= takes an Array of form [x, y]." if midtop.size != 2
-		self.centerx, self[1] = midtop
-		return midtop
-	end
-
-	alias mt midtop
-	alias mt= midtop=;
-
-	# Return the x and y coordinates of the midpoint on the left side of the
-	# Rect.
-	def midright; return self.right, self.centery; end	
-
-	# Set the x and y coordinates of the midpoint on the right side of the Rect
-	# by translating the Rect (adjusting the x and y offsets).
-	def midright=(midright)
-    	raise ArgumentError, "Rect#midright= takes an Array of form [x, y]." if midright.size != 2
-		self.right, self.centery = midright
-		return midright
-	end
-
-	alias mr midright
-	alias mr= midright=;
-
-	# Return the x and y coordinates of the midpoint on the left side of the
-	# Rect.
-	def midbottom; return self.centerx, self.bottom; end	
-
-	# Set the x and y coordinates of the midpoint on the bottom side of the
-	# Rect by translating the Rect (adjusting the x and y offsets).
-	def midbottom=(midbottom)
-    	raise ArgumentError, "Rect#midbottom= takes an Array of form [x, y]." if midbottom.size != 2
-		self.centerx, self.bottom = midbottom
-		return midbottom
-	end
-
-	alias mb midbottom
-	alias mb= midbottom=;
-
-	#--
-	# UTILITY METHODS
-	#++
-
-
-	# As #clamp!, but the original caller is not changed.
-	def clamp(rect)
-		self.dup.clamp!(rect)
-	end
-
-	# Translate the calling Rect to be entirely inside the given Rect. If 
-	# the caller is too large along either axis to fit in the given rect,
-	# it is centered with respect to the given rect, along that axis.
-	def clamp!(rect)
-		nself = self.normalize
-		rect = Rect.new_from_object(rect)
-		#If self is inside given, there is no need to move self
-		unless rect.contain?(nself)
-
-			#If self is too wide:
-			if nself.at(2) >= rect.at(2)
-				self[0] = rect.centerx - nself.at(2).div(2)
-				#Else self is not too wide
-			else
-				#If self is to the left of arg
-				if nself.at(0) < rect.at(0)
-					self[0] = rect.at(0)
-				#If self is to the right of arg
-				elsif nself.right > rect.right
-					self[0] = rect.right - nself.at(2)
-				#Otherwise, leave x alone
-				end
-			end
-
-			#If self is too tall:
-			if nself.at(3) >= rect.at(3)
-				self[1] = rect.centery - nself.at(3).div(2)
-				#Else self is not too tall
-			else
-				#If self is above arg
-				if nself.at(1) < rect.at(1)
-					self[1] = rect.at(1)
-				#If self below arg
-				elsif nself.bottom > rect.bottom
-					self[1] = rect.bottom - nself.at(3)
-				#Otherwise, leave y alone
-				end
-			end
-		end
-		return self
-	end
-
-	# As #clip!, but the original caller is not changed.
-	def clip(rect)
-		self.dup.clip!(rect)
-	end
-
-	# Crop the calling Rect to be entirely inside the given Rect. If the
-	# caller does not intersect the given Rect at all, its width and height
-	# are set to zero, but its x and y offsets are not changed.
-	# 
-	# As a side effect, the Rect is normalized.
-	def clip!(rect)
-		nself = self.normalize
-		other = Rect.new_from_object(rect).normalize!
-		if self.collide_rect?(other)
-			self[0] = [nself.at(0), other.at(0)].max
-			self[1] = [nself.at(1), other.at(1)].max
-			self[2] = [nself.right, other.right].min - self.at(0)
-			self[3] = [nself.bottom, other.bottom].min - self.at(1)
-		else #if they do not intersect at all:
-			self[0], self[1] = nself.topleft
-			self[2], self[3] = 0, 0
-		end
-		return self
-	end
-
-	# Iterate through all key/value pairs in the given hash table, and
-	# return the first pair whose value is a Rect that collides with the
-	# caller.
-	#
-	# Because a hash table is unordered, you should not expect any 
-	# particular Rect to be returned first.
-	def collide_hash(hash_rects)
-		hash_rects.each { |key,value|
-			if value.collide_rect?+(self); return [key,value]; end
-		}
-		return nil
-	end
-
-	# Iterate through all key/value pairs in the given hash table, and
-	# return an Array of every pair whose value is a Rect that collides
-	# the caller.
-	# 
-	# Because a hash table is unordered, you should not expect the returned
-	# pairs to be in any particular order.
-	def collide_hash_all(hash_rects)
-		hash_rects.select { |key,value|
-			value.collide_rect?+(self)
-		}
-	end
-
-	# Iterate through all elements in the given Array, and return
-	# the *index* of the first element which is a Rect that collides with
-	# the caller.
-	def collide_array(array_rects)
-		for i in (0...(array_rects.length))
-			if array_rects[i].collide_rect?(self)
-				return i
-			end
-		end
-		return nil
-	end
-
-	# Iterate through all elements in the given Array, and return
-	# an Array containing the *indices* of every element that is a Rect
-	# that collides with the caller.
-	def collide_array_all(array_rects)
-		indexes = []
-		for i in (0...(array_rects.length))
-			if array_rects[i].collide_rect?(self)
-				indexes += [i]
-			end
-		end
-		return indexes
-	end
-
-	# True if the point is inside (including on the border) of the caller.
-	# If you have Array of coordinates, you can use collide_point?(*coords).
-	def collide_point?(x,y)
-		nself = normalize()
-		x.between?(nself.left,nself.right) && y.between?(nself.top,nself.bottom)
-	end
-
-	# True if the caller and the given Rect overlap (or touch) at all.
-	def collide_rect?(rect)
-		nself = self.normalize
-		rect  = Rect.new_from_object(rect).normalize!
-		return ((nself.l >= rect.l && nself.l <= rect.r) or (rect.l >= nself.l && rect.l <= nself.r)) &&
-		       ((nself.t >= rect.t && nself.t <= rect.b) or (rect.t >= nself.t && rect.t <= nself.b))
-	end
-
-	# True if the given Rect is totally within the caller. Borders may
-	# overlap.
-	def contain?(rect)
-		nself = self.normalize
-		rect = Rect.new_from_object(rect).normalize!
-		return (nself.left <= rect.left and rect.right <= nself.right and
-					nself.top <= rect.top and rect.bottom <= nself.bottom)
-	end
-
-	# As #inflate!, but the original caller is not changed.
-	def inflate(x,y)
-		return self.class.new(self.at(0) - x.div(2),
-													self.at(1) - y.div(2),
-													self.at(2) + x,
-													self.at(3) + y)
-	end
-
-	# Increase the Rect's size is the x and y directions, while keeping the
-	# same center point. For best results, expand by an even number.
-	# X and y inflation can be given as an Array or as separate values.
-	def inflate!(x,y)
-		self[0] -= x.div(2)
-		self[1] -= y.div(2)
-		self[2] += x
-		self[3] += y
-		return self
-	end
-
-	# As #move!, but the original caller is not changed.
-	def move(x,y)
-		self.dup.move!(x,y)
-	end
-
-	# Translate the Rect by the given amounts in the x and y directions.
-	# Positive values are rightward for x and downward for y.
-	# X and y movement can be given as an Array or as separate values.
-	def move!(x,y)
-		self[0]+=x; self[1]+=y
-		return self
-	end
-
-	# As #normalize!, but the original caller is not changed.
-	def normalize
-		self.dup.normalize!()
-	end
-
-	# Fix Rects that have negative width or height, without changing the
-	# area it represents. Has no effect on Rects with non-negative width
-	# and height. Some Rect methods will automatically normalize the Rect.
-	def normalize!
-		if self.at(2) < 0
-			self[0], self[2] = self.at(0)+self.at(2), -self.at(2)
-		end
-		if self.at(3) < 0
-			self[1], self[3] = self.at(1)+self.at(3), -self.at(3)
-		end
-		self
-	end
-
-	# As #union!, but the original caller is not changed.
-	def union(rect)
-		self.dup.union!(rect)
-	end
-
-	# Expand the caller to also cover the given Rect. The Rect is still a 
-	# rectangle, so it may also cover areas that neither of the original
-	# Rects did, for example areas between the two Rects.
-	def union!(rect)
-		self.normalize!
-    rleft, rtop = self.topleft
-    rright, rbottom = self.bottomright
-		r2 = Rect.new_from_object(rect).normalize!
-
-		rleft = [rleft, r2.left].min
-		rtop = [rtop, r2.top].min
-		rright = [rright, r2.right].max
-		rbottom = [rbottom, r2.bottom].max
-
-		self[0,4] = rleft, rtop, rright - rleft, rbottom - rtop
-		return self
-	end
-
-	# As #union_all!, but the original caller is not changed.
-	def union_all(array_rects)
-		self.dup.union_all!(array_rects)
-	end
-
-	# Expand the caller to cover all of the given Rects. See also #union!
-	def union_all!(array_rects)
-		array_rects.each do |r|
-      self.union!(r)
-		end
-		return self
-	end
-
-
-end # class Rect
-
-
-class Surface
-	# Return a Rect with the same width and height as the Surface, positioned
-	# at (0,0).
-	def make_rect()
-		return Rect.new(0,0,self.width,self.height)
-	end
-end
-
-end # module Rubygame
+#--
+#	Rubygame -- Ruby code and bindings to SDL to facilitate game creation
+#	Copyright (C) 2004-2007  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
+#++
+
+#--
+# Table of Contents:
+#
+# class Rect
+# 	GENERAL:
+# 		initialize
+# 		new_from_object
+# 		to_s
+# 		to_a, to_ary
+# 		[]
+# 	ATTRIBUTES:
+# 		x, y, w, h [<- accessors]
+# 		width, height, size
+# 		left, top, right, bottom
+# 		center, centerx, centery
+# 		topleft, topright
+# 		bottomleft, bottomright
+# 		midleft, midtop, midright, midbottom
+# 	UTILITY METHODS:
+# 		clamp, clamp!
+# 		clip, clip!
+# 		collide_hash, collide_hash_all
+# 		collide_array, collide_array_all
+# 		collide_point?
+# 		collide_rect?
+# 		contain?
+# 		inflate, inflate!
+# 		move, move!
+# 		normalize, normalize!
+# 		union, union!
+# 		union_all, union_all!
+#
+#	class Surface
+#		make_rect
+# 
+#++
+
+module Chingu
+
+# A Rect is a representation of a rectangle, with four core attributes
+# (x offset, y offset, width, and height) and a variety of functions
+# for manipulating and accessing these attributes.
+#
+# Like all coordinates in Rubygame (and its base library, SDL), x and y
+# offsets are measured from the top-left corner of the screen, with greater
+# y offsets being lower. Thus, specifying the x and y offsets of the Rect
+# is equivalent to setting the location of its top-left corner.
+# 
+# In Rubygame, Rects are used for collision detection and describing 
+# the area of a Surface to operate on.
+class Rect < Array
+
+	#--
+	# GENERAL
+	#++
+
+	# Create a new Rect, attempting to extract its own information from 
+	# the given arguments. The arguments must fall into one of these cases:
+	# 
+	#   - 4 integers +(x, y, w, h)+.
+	#   - 1 Rect or Array containing 4 integers +([x, y, w, h])+.
+	#   - 2 Arrays containing 2 integers each +([x,y], [w,h])+.
+	#   - 1 object with a +rect+ attribute which is a valid Rect object.
+	# 
+	# All rect core attributes (x,y,w,h) must be integers.
+	# 
+	def initialize(*argv)
+		case argv.length
+		when 1
+			if argv[0].kind_of? Array; super(argv[0])
+			elsif argv[0].respond_to? :rect; super(argv[0])
+			end
+		when 2
+			super(argv[0].concat(argv[1]))
+		when 4
+			super(argv)
+		end
+		return self
+	end
+
+	# Extract or generate a Rect from the given object, if possible, using the
+	# following process:
+	# 
+	#  1. If it's a Rect already, return a duplicate Rect.
+	#  2. Elsif it's an Array with at least 4 values, make a Rect from it.
+	#  3. Elsif it has a +rect+ attribute., perform (1) and (2) on that.
+	#  4. Otherwise, raise TypeError.
+	# 
+	# See also Surface#make_rect()
+	def Rect.new_from_object(object)
+		case(object)
+		when Rect
+			return object.dup
+		when Array 
+			if object.length >= 4
+				return Rect.new(object)
+			else
+				raise(ArgumentError,"Array does not have enough indices to be made into a Rect (%d for 4)."%object.length )
+			end
+		else
+			begin
+				case(object.rect)
+				when Rect
+					return object.rect.dup
+				when Array
+					if object.rect.length >= 4
+						return Rect.new(object.rect)
+					else
+						raise(ArgumentError,"Array does not have enough indices to be made into a Rect (%d for 4)."%object.rect.length )
+					end
+				end				# case object.rect
+			rescue NoMethodError # if no rect.rect
+				raise(TypeError,"Object must be a Rect or Array [x,y,w,h], or have an attribute called 'rect'. (Got %s instance.)"%object.class)
+			end
+		end # case object
+	end
+
+
+	# Print the Rect in the form "+#<Rect [x,y,w,h]>+"
+	def to_s; "#<Rect [%s,%s,%s,%s]>"%self; end
+
+	# Print the Rect in the form "+#<Rect:id [x,y,w,h]>+"
+	def inspect; "#<Rect:#{self.object_id} [%s,%s,%s,%s]>"%self; end
+
+	#--
+	# ATTRIBUTES
+	#++
+
+	# Returns self.at(0)
+	def x; return self.at(0); end
+	# Sets self[0] to +val+
+	def x=(val); self[0] = val; end
+
+	alias left x
+	alias left= x=;
+	alias l x
+	alias l= x=;
+
+	# Returns self.at(1)
+	def y; return self.at(1); end
+	# Sets self[1] to +val+
+	def y=(val); self[1] = val; end
+
+	alias top y
+	alias top= y=;
+	alias t y
+	alias t= y=;
+
+	# Returns self.at(2)
+	def w; return self.at(2); end
+	# Sets self[2] to +val+
+	def w=(val); self[2] = val; end
+
+	alias width w
+	alias width= w=;
+
+	# Returns self.at(3)
+	def h; return self.at(3); end
+	# Sets self[3] to +val+
+	def h=(val); self[3] = val; end
+
+	alias height h
+	alias height= h=;
+
+	# Return the width and height of the Rect.
+	def size; return self[2,2]; end
+
+	# Set the width and height of the Rect.
+	def size=(size)
+	 raise ArgumentError, "Rect#size= takes an Array of form [width, height]." if size.size != 2
+	 self[2,2] = size
+	 size
+	end
+
+	# Return the x coordinate of the right side of the Rect.
+	def right; return self.at(0)+self.at(2); end
+
+	# Set the x coordinate of the right side of the Rect by translating the
+	# Rect (adjusting the x offset).
+	def right=(r); self[0] = r - self.at(2); return r; end
+
+	alias r right
+	alias r= right=;
+
+	# Return the y coordinate of the bottom side of the Rect.
+	def bottom; return self.at(1)+self.at(3); end
+
+	# Set the y coordinate of the bottom side of the Rect by translating the
+	# Rect (adjusting the y offset).
+	def bottom=(b); self[1] = b - self.at(3); return b; end
+
+	alias b bottom
+	alias b= bottom=;
+
+	# Return the x and y coordinates of the center of the Rect.
+	def center; return self.centerx, self.centery; end
+
+	# Set the x and y coordinates of the center of the Rect by translating the
+	# Rect (adjusting the x and y offsets).
+	def center=(center)
+	    raise ArgumentError, "Rect#center= takes an Array of the form [x,y]." if center.size != 2
+		self.centerx, self.centery = center
+		center
+	end
+	alias c center
+	alias c= center=;
+
+	# Return the x coordinate of the center of the Rect
+	def centerx; return self.at(0)+(self.at(2).div(2)); end
+
+	# Set the x coordinate of the center of the Rect by translating the
+	# Rect (adjusting the x offset).
+	def centerx=(x); self[0] = x - (self.at(2).div(2)); return x; end
+
+	alias cx centerx
+	alias cx= centerx=;
+
+	# Return the y coordinate of the center of the Rect
+	def centery; return self.at(1)+(self.at(3).div(2)); end
+
+	# Set the y coordinate of the center of the Rect by translating the
+	# Rect (adjusting the y offset).
+	def centery=(y); self[1] = y- (self.at(3).div(2)); return y; end
+
+	alias cy centery
+	alias cy= centery=;
+
+	# Return the x and y coordinates of the top-left corner of the Rect
+	def topleft; return self[0,2].to_a; end
+
+	# Set the x and y coordinates of the top-left corner of the Rect by 
+	# translating the Rect (adjusting the x and y offsets).
+	def topleft=(topleft)
+	    raise ArgumentError, "Rect#topright= takes an Array of form [x, y]." if topleft.size != 2
+		self[0,2] = topleft
+		return topleft
+	end
+
+	alias tl topleft
+	alias tl= topleft=;
+
+	# Return the x and y coordinates of the top-right corner of the Rect
+	def topright; return self.right, self.at(1); end
+
+	# Set the x and y coordinates of the top-right corner of the Rect by 
+	# translating the Rect (adjusting the x and y offsets).
+	def topright=(topright)
+	    raise ArgumentError, "Rect#topright= takes an Array of form [x, y]." if topright.size != 2
+		self.right, self[1] = topright
+		return topright
+	end
+
+	alias tr topright
+	alias tr= topright=;
+
+	# Return the x and y coordinates of the bottom-left corner of the Rect
+	def bottomleft; return self.at(0), self.bottom; end
+
+	# Set the x and y coordinates of the bottom-left corner of the Rect by 
+	# translating the Rect (adjusting the x and y offsets).
+	def bottomleft=(bottomleft)
+		raise ArgumentError, "Rect#bottomleft= takes an Array of form [x, y]." if bottomleft.size != 2
+		self[0], self.bottom = bottomleft
+		return bottomleft
+	end
+
+	alias bl bottomleft
+	alias bl= bottomleft=;
+
+	# Return the x and y coordinates of the bottom-right corner of the Rect
+	def bottomright; return self.right, self.bottom; end
+
+	# Set the x and y coordinates of the bottom-right corner of the Rect by 
+	# translating the Rect (adjusting the x and y offsets).
+	def bottomright=(bottomright)
+		raise ArgumentError, "Rect#bottomright= takes an Array of form [x, y]." if bottomright.size != 2
+		self.right, self.bottom = bottomright
+		return bottomright
+	end
+
+	alias br bottomright
+	alias br= bottomright=;
+
+	# Return the x and y coordinates of the midpoint on the left side of the
+	# Rect.
+	def midleft; return self.at(0), self.centery; end	
+
+	# Set the x and y coordinates of the midpoint on the left side of the Rect
+	# by translating the Rect (adjusting the x and y offsets).
+	def midleft=(midleft)
+    	raise ArgumentError, "Rect#midleft= takes an Array of form [x, y]." if midleft.size != 2
+		self[0], self.centery = midleft
+		return midleft
+	end
+
+	alias ml midleft
+	alias ml= midleft=;
+
+	# Return the x and y coordinates of the midpoint on the left side of the
+	# Rect.
+	def midtop; return self.centerx, self.at(1); end	
+
+	# Set the x and y coordinates of the midpoint on the top side of the Rect
+	# by translating the Rect (adjusting the x and y offsets).
+	def midtop=(midtop)
+    	raise ArgumentError, "Rect#midtop= takes an Array of form [x, y]." if midtop.size != 2
+		self.centerx, self[1] = midtop
+		return midtop
+	end
+
+	alias mt midtop
+	alias mt= midtop=;
+
+	# Return the x and y coordinates of the midpoint on the left side of the
+	# Rect.
+	def midright; return self.right, self.centery; end	
+
+	# Set the x and y coordinates of the midpoint on the right side of the Rect
+	# by translating the Rect (adjusting the x and y offsets).
+	def midright=(midright)
+    	raise ArgumentError, "Rect#midright= takes an Array of form [x, y]." if midright.size != 2
+		self.right, self.centery = midright
+		return midright
+	end
+
+	alias mr midright
+	alias mr= midright=;
+
+	# Return the x and y coordinates of the midpoint on the left side of the
+	# Rect.
+	def midbottom; return self.centerx, self.bottom; end	
+
+	# Set the x and y coordinates of the midpoint on the bottom side of the
+	# Rect by translating the Rect (adjusting the x and y offsets).
+	def midbottom=(midbottom)
+    	raise ArgumentError, "Rect#midbottom= takes an Array of form [x, y]." if midbottom.size != 2
+		self.centerx, self.bottom = midbottom
+		return midbottom
+	end
+
+	alias mb midbottom
+	alias mb= midbottom=;
+
+   
+   # returns rects for side collision
+   def left_side
+      Rect.new([ x, y, width * 0.25, height ])
+   end
+
+   def right_side
+      Rect.new([ x + (width * 0.75), y, width * 0.25, height ])
+   end
+
+   def top_side
+      Rect.new([ x, y, width, height * 0.25 ])
+   end
+
+   def bottom_side
+      Rect.new([ x, y + (height * 0.75), width, height * 0.25 ])
+   end
+
+   #--
+	# UTILITY METHODS
+	#++
+
+	# As #clamp!, but the original caller is not changed.
+	def clamp(rect)
+		self.dup.clamp!(rect)
+	end
+
+	# Translate the calling Rect to be entirely inside the given Rect. If 
+	# the caller is too large along either axis to fit in the given rect,
+	# it is centered with respect to the given rect, along that axis.
+	def clamp!(rect)
+		nself = self.normalize
+		rect = Rect.new_from_object(rect)
+		#If self is inside given, there is no need to move self
+		unless rect.contain?(nself)
+
+			#If self is too wide:
+			if nself.at(2) >= rect.at(2)
+				self[0] = rect.centerx - nself.at(2).div(2)
+				#Else self is not too wide
+			else
+				#If self is to the left of arg
+				if nself.at(0) < rect.at(0)
+					self[0] = rect.at(0)
+				#If self is to the right of arg
+				elsif nself.right > rect.right
+					self[0] = rect.right - nself.at(2)
+				#Otherwise, leave x alone
+				end
+			end
+
+			#If self is too tall:
+			if nself.at(3) >= rect.at(3)
+				self[1] = rect.centery - nself.at(3).div(2)
+				#Else self is not too tall
+			else
+				#If self is above arg
+				if nself.at(1) < rect.at(1)
+					self[1] = rect.at(1)
+				#If self below arg
+				elsif nself.bottom > rect.bottom
+					self[1] = rect.bottom - nself.at(3)
+				#Otherwise, leave y alone
+				end
+			end
+		end
+		return self
+	end
+
+	# As #clip!, but the original caller is not changed.
+	def clip(rect)
+		self.dup.clip!(rect)
+	end
+
+	# Crop the calling Rect to be entirely inside the given Rect. If the
+	# caller does not intersect the given Rect at all, its width and height
+	# are set to zero, but its x and y offsets are not changed.
+	# 
+	# As a side effect, the Rect is normalized.
+	def clip!(rect)
+		nself = self.normalize
+		other = Rect.new_from_object(rect).normalize!
+		if self.collide_rect?(other)
+			self[0] = [nself.at(0), other.at(0)].max
+			self[1] = [nself.at(1), other.at(1)].max
+			self[2] = [nself.right, other.right].min - self.at(0)
+			self[3] = [nself.bottom, other.bottom].min - self.at(1)
+		else #if they do not intersect at all:
+			self[0], self[1] = nself.topleft
+			self[2], self[3] = 0, 0
+		end
+		return self
+	end
+
+	# Iterate through all key/value pairs in the given hash table, and
+	# return the first pair whose value is a Rect that collides with the
+	# caller.
+	#
+	# Because a hash table is unordered, you should not expect any 
+	# particular Rect to be returned first.
+	def collide_hash(hash_rects)
+		hash_rects.each { |key,value|
+			if value.collide_rect?+(self); return [key,value]; end
+		}
+		return nil
+	end
+
+	# Iterate through all key/value pairs in the given hash table, and
+	# return an Array of every pair whose value is a Rect that collides
+	# the caller.
+	# 
+	# Because a hash table is unordered, you should not expect the returned
+	# pairs to be in any particular order.
+	def collide_hash_all(hash_rects)
+		hash_rects.select { |key,value|
+			value.collide_rect?+(self)
+		}
+	end
+
+	# Iterate through all elements in the given Array, and return
+	# the *index* of the first element which is a Rect that collides with
+	# the caller.
+	def collide_array(array_rects)
+		for i in (0...(array_rects.length))
+			if array_rects[i].collide_rect?(self)
+				return i
+			end
+		end
+		return nil
+	end
+
+	# Iterate through all elements in the given Array, and return
+	# an Array containing the *indices* of every element that is a Rect
+	# that collides with the caller.
+	def collide_array_all(array_rects)
+		indexes = []
+		for i in (0...(array_rects.length))
+			if array_rects[i].collide_rect?(self)
+				indexes += [i]
+			end
+		end
+		return indexes
+	end
+
+	# True if the point is inside (including on the border) of the caller.
+	# If you have Array of coordinates, you can use collide_point?(*coords).
+	def collide_point?(x,y)
+		nself = normalize()
+		x.between?(nself.left,nself.right) && y.between?(nself.top,nself.bottom)
+	end
+
+	# True if the caller and the given Rect overlap (or touch) at all.
+	def collide_rect?(rect)
+		nself = self.normalize
+		rect  = Rect.new_from_object(rect).normalize!
+		return ((nself.l >= rect.l && nself.l <= rect.r) or (rect.l >= nself.l && rect.l <= nself.r)) &&
+		       ((nself.t >= rect.t && nself.t <= rect.b) or (rect.t >= nself.t && rect.t <= nself.b))
+	end
+
+	# True if the given Rect is totally within the caller. Borders may
+	# overlap.
+	def contain?(rect)
+		nself = self.normalize
+		rect = Rect.new_from_object(rect).normalize!
+		return (nself.left <= rect.left and rect.right <= nself.right and
+					nself.top <= rect.top and rect.bottom <= nself.bottom)
+	end
+
+	# As #inflate!, but the original caller is not changed.
+	def inflate(x,y)
+		return self.class.new(self.at(0) - x.div(2),
+													self.at(1) - y.div(2),
+													self.at(2) + x,
+													self.at(3) + y)
+	end
+
+	# Increase the Rect's size is the x and y directions, while keeping the
+	# same center point. For best results, expand by an even number.
+	# X and y inflation can be given as an Array or as separate values.
+	def inflate!(x,y)
+		self[0] -= x.div(2)
+		self[1] -= y.div(2)
+		self[2] += x
+		self[3] += y
+		return self
+	end
+
+	# As #move!, but the original caller is not changed.
+	def move(x,y)
+		self.dup.move!(x,y)
+	end
+
+	# Translate the Rect by the given amounts in the x and y directions.
+	# Positive values are rightward for x and downward for y.
+	# X and y movement can be given as an Array or as separate values.
+	def move!(x,y)
+		self[0]+=x; self[1]+=y
+		return self
+	end
+
+	# As #normalize!, but the original caller is not changed.
+	def normalize
+		self.dup.normalize!()
+	end
+
+	# Fix Rects that have negative width or height, without changing the
+	# area it represents. Has no effect on Rects with non-negative width
+	# and height. Some Rect methods will automatically normalize the Rect.
+	def normalize!
+		if self.at(2) < 0
+			self[0], self[2] = self.at(0)+self.at(2), -self.at(2)
+		end
+		if self.at(3) < 0
+			self[1], self[3] = self.at(1)+self.at(3), -self.at(3)
+		end
+		self
+	end
+
+	# As #union!, but the original caller is not changed.
+	def union(rect)
+		self.dup.union!(rect)
+	end
+
+	# Expand the caller to also cover the given Rect. The Rect is still a 
+	# rectangle, so it may also cover areas that neither of the original
+	# Rects did, for example areas between the two Rects.
+	def union!(rect)
+		self.normalize!
+    rleft, rtop = self.topleft
+    rright, rbottom = self.bottomright
+		r2 = Rect.new_from_object(rect).normalize!
+
+		rleft = [rleft, r2.left].min
+		rtop = [rtop, r2.top].min
+		rright = [rright, r2.right].max
+		rbottom = [rbottom, r2.bottom].max
+
+		self[0,4] = rleft, rtop, rright - rleft, rbottom - rtop
+		return self
+	end
+
+	# As #union_all!, but the original caller is not changed.
+	def union_all(array_rects)
+		self.dup.union_all!(array_rects)
+	end
+
+	# Expand the caller to cover all of the given Rects. See also #union!
+	def union_all!(array_rects)
+		array_rects.each do |r|
+      self.union!(r)
+		end
+		return self
+	end
+
+
+end # class Rect
+
+
+class Surface
+	# Return a Rect with the same width and height as the Surface, positioned
+	# at (0,0).
+	def make_rect()
+		return Rect.new(0,0,self.width,self.height)
+	end
+end
+
+end # module Rubygame