gamebox 0.2.1 → 0.3.2

data/lib/gamebox/data/config/objects.yml

@@ -5,9 +5,11 @@ game:
     - sound_manager
     - stage_manager
 resource_manager:
+  auto_require: false
   compose:
     - wrapped_screen
 stage_manager:
+  auto_require: false
   compose:
     - input_manager
     - resource_manager
@@ -15,18 +17,23 @@ stage_manager:
     - config_manager
     - actor_factory
 sound_manager:
+  auto_require: false
   compose:
     - resource_manager
     - config_manager
 input_manager:
+  auto_require: false
   compose:
     - wrapped_screen
     - config_manager
 wrapped_screen:
+  auto_require: false
   compose:
     - config_manager
 config_manager:
+  auto_require: false
 actor_factory:
+  auto_require: false
   compose:
     - input_manager
     - wrapped_screen

data/lib/gamebox/gamebox_application.rb

@@ -1,22 +1,11 @@
 #!/usr/bin/env ruby
 $: << "#{File.dirname(__FILE__)}/../config"
 
-require 'gosu'
-include Gosu
-
-require "environment"
-
-require 'metaclass'
-require 'publisher'
-require 'publisher_ext'
-require 'inflector'
-require 'constructor'
-require 'diy'
-require 'class_finder'
-require 'actor_factory'
-require 'input_manager'
-
-require 'stagehand'
+begin
+  # optional file
+  require "environment" 
+rescue LoadError => err
+end
 
 class GameboxApp
   attr_reader :context, :game
@@ -45,13 +34,11 @@ class GameboxApp
   end
   
   def setup_debug_server
-    
-    require 'drb'
-    self.class.extend DRbUndumped
-    puts "Starting debug server..."
-    
-    DRb.start_service "druby://localhost:7373", self
-    puts "on #{DRb.uri}"
+    Thread.new do
+      loop do
+        binding.remote_pry
+      end
+    end
   end
   
   def main_loop
@@ -61,10 +48,6 @@ class GameboxApp
 
   def shutdown
   end
-  
-  def debug_eval(eval_str)
-    instance_eval eval_str
-  end
 
   def start(argv,env)
     setup
@@ -75,12 +58,6 @@ class GameboxApp
   end
 end
 
-# TODO move this to some logging class
-def log(output, level = :debug)
-  t = Time.now
-  puts "[#{t.min}:#{t.sec}:#{t.usec}] [#{level}] #{output}"
-end
-
 if $0 == __FILE__
   GameboxApp.run ARGV, ENV
 end

data/lib/gamebox/gamebox_generator.rb

@@ -1,32 +1,32 @@
-# This is the generator for gamebox
-require 'inflector'
-$: << File.join(File.dirname(__FILE__),'generators')
-
-unless "".respond_to? :end_with?
-  class String
-    def end_with?(ending)
-      self[size-ending.size..-1] == ending
-    end
-  end
-end
-
-def print_usage
-  puts "generate what *opts"
-  puts "TODO list all generators here"
-end
-# TODO pull these out into generators/ dir for listing
-
-if ARGV.size < 1
-  print_usage 
-  exit 0
-end
-
-# TODO load generator file based on ARGV[0]
-generator_klass_name = 
-  Inflector.camelize ARGV[0].downcase+"_generator"
-
-require Inflector.underscore(generator_klass_name)
-
-generator_klass = Object.const_get generator_klass_name
-generator_klass.new.generate(ARGV[1..-1])
-
+# # This is the generator for gamebox
+# 
+# $: << File.join(File.dirname(__FILE__),'generators')
+# 
+# unless "".respond_to? :end_with?
+#   class String
+#     def end_with?(ending)
+#       self[size-ending.size..-1] == ending
+#     end
+#   end
+# end
+# 
+# def print_usage
+#   puts "generate what *opts"
+#   puts "TODO list all generators here"
+# end
+# # TODO pull these out into generators/ dir for listing
+# 
+# if ARGV.size < 1
+#   print_usage 
+#   exit 0
+# end
+# 
+# # TODO load generator file based on ARGV[0]
+# generator_klass_name = 
+#   Inflector.camelize ARGV[0].downcase+"_generator"
+# 
+# require Inflector.underscore(generator_klass_name)
+# 
+# generator_klass = Object.const_get generator_klass_name
+# generator_klass.new.generate(ARGV[1..-1])
+# 

data/lib/gamebox/input_manager.rb

@@ -1,5 +1,7 @@
 require 'publisher'
-require 'hooked_gosu_window'
+
+# looks like theres a bug in Gosu
+KbRangeBegin = 0
 
 # InputManager handles the pumping for events and distributing of said events.
 # You can gain access to these events by registering for all events, 
@@ -20,6 +22,9 @@ class InputManager
   extend Publisher
   can_fire :key_up, :event_received
 
+  DOWN_EVENTS = [:mouse_down, :keyboard_down, :game_pad_down]
+  UP_EVENTS = [:mouse_up, :keyboard_up, :game_pad_up]
+
   attr_accessor :window
   constructor :config_manager, :wrapped_screen
 
@@ -28,10 +33,12 @@ class InputManager
   def setup
     @window = @wrapped_screen.screen
 
-    @auto_quit = instance_eval(@config_manager[:auto_quit])
+    auto_quit = @config_manager[:auto_quit]
+    @auto_quit = instance_eval(auto_quit) if auto_quit
 
     @hooks = {}
     @non_id_hooks = {}
+    @down_ids = {}
   end
 
   # This gets called from game app and sets up all the
@@ -46,17 +53,17 @@ class InputManager
     end
     @window.when :update do |millis|
 
-      @last_mouse_x ||= @window.mouse_x
-      @last_mouse_y ||= @window.mouse_y
+      @last_mouse_x ||= mouse_x
+      @last_mouse_y ||= mouse_y
 
-      x_diff = @last_mouse_x - @window.mouse_x
-      y_diff = @last_mouse_y - @window.mouse_y
+      x_diff = @last_mouse_x - mouse_x
+      y_diff = @last_mouse_y - mouse_y
 
       unless x_diff < 0.1 && x_diff > -0.1 && y_diff < 0.1 && y_diff > -0.1
         _handle_event nil, :motion
 
-        @last_mouse_x = @window.mouse_x
-        @last_mouse_y = @window.mouse_y
+        @last_mouse_x = mouse_x
+        @last_mouse_y = mouse_y
       end
 
       game.update millis
@@ -69,51 +76,69 @@ class InputManager
   end
 
   def _handle_event(gosu_id, action) #:nodoc:
-    @window.close if gosu_id == @auto_quit
+    @window.close if @auto_quit && gosu_id == @auto_quit
+    if action == :down
+      @down_ids[gosu_id] = true 
+    else
+      @down_ids.delete gosu_id
+    end
+
     event_data = nil
+    mouse_dragged = false
 
+    callback_key = action
     if gosu_id.nil?
       event_type = :mouse_motion
       callback_key = :mouse_motion
-      event_data = [@window.mouse_x, @window.mouse_y]
+      @mouse_dragging = true if @mouse_down
+      event_data = [mouse_x, mouse_y]
     elsif gosu_id >= MsRangeBegin && gosu_id <= MsRangeEnd
       event_type = :mouse
+      event_data = [mouse_x, mouse_y]
       if action == :up
-        callback_key = :mouse_up
+        # callback_key = :mouse_up
+        @mouse_down = false
+        mouse_dragged = true if @mouse_dragging
+        @mouse_dragging = false
       else
-        callback_key = :mouse_down
+        # callback_key = :mouse_down
+        @mouse_down = true
+        @last_click_x = mouse_x
+        @last_click_y = mouse_y
       end
     elsif gosu_id >= KbRangeBegin && gosu_id <= KbRangeEnd
       event_type = :keyboard
-      if action == :up
-        callback_key = :keyboard_up
-      else
-        callback_key = :keyboard_down
-      end
     elsif gosu_id >= GpRangeBegin && gosu_id <= GpRangeEnd
       event_type = :game_pad
-      if action == :up
-        callback_key = :game_pad_up
-      else
-        callback_key = :game_pad_down
-      end
     end
 
     event = {
       :type => event_type, 
       :id => gosu_id,
       :action => action,
-      :callback_key => event_type,
+      :callback_key => callback_key,
       :data => event_data
     }
 
+    fire_event(event)
+
+    if mouse_dragged
+      drag_data = {:to => [mouse_x, mouse_y], :from => [@last_click_x, @last_click_y]}
+      event[:data] = drag_data
+      event[:callback_key] = :mouse_drag
+      fire_event(event)
+    end
+  end
+
+  def fire_event(event)
     fire :event_received, event
 
     # fix for pause bug?
     @hooks ||= {}
     @non_id_hooks ||= {}
 
-    event_hooks = @hooks[callback_key] 
+    event_hooks = @hooks[event[:callback_key]] 
+    gosu_id = event[:id]
 
     unless gosu_id.nil?
       event_action_hooks = event_hooks[gosu_id] if event_hooks
@@ -124,7 +149,7 @@ class InputManager
       end
     end
     
-    non_id_event_hooks = @non_id_hooks[callback_key]
+    non_id_event_hooks = @non_id_hooks[event[:callback_key]]
     if non_id_event_hooks
       for callback in non_id_event_hooks
         callback.call event
@@ -141,6 +166,8 @@ class InputManager
   #   # will be called on every spacebar key press
   # end
   def register_hook(event_class, *event_ids, &block)
+    event_class = :down if DOWN_EVENTS.include? event_class
+    event_class = :up if UP_EVENTS.include? event_class
     return unless block_given?
     listener = eval("self", block.binding) 
     _register_hook listener, event_class, *event_ids, &block
@@ -170,6 +197,8 @@ class InputManager
   # input_manager.unregister_hook KeyPressed, :space, registered_block
   # also see InputManager#clear_hooks for clearing many hooks
   def unregister_hook(event_class, *event_ids, &block)
+    event_class = :down if DOWN_EVENTS.include? event_class
+    event_class = :up if UP_EVENTS.include? event_class
     @hooks[event_class] ||= {}
     for event_id in event_ids
       @hooks[event_class][event_id] ||= []
@@ -206,13 +235,17 @@ class InputManager
     end
   end
 
-  # autohook a boolean to be set to true while a key is pressed
-  def while_key_pressed(key, target, accessor)
-    _register_hook target, :keyboard_down, key do
-      target.send "#{accessor}=", true
-    end
-    _register_hook target, :keyboard_up, key do
-      target.send "#{accessor}=", false
+  # autohook a boolean to be set to true while any of the keys are pressed
+  def while_pressed(id_or_ids, target, accessor)
+    ids = [id_or_ids].flatten
+    ids.each do |id|
+      _register_hook target, :down, id do
+        target.send "#{accessor}=", true
+      end
+
+      _register_hook target, :up, id do
+        target.send "#{accessor}=", false if (@down_ids.keys & ids).size == 0
+      end
     end
   end
 
@@ -230,4 +263,12 @@ class InputManager
     @paused_non_id_hooks = nil
   end
 
+  private
+  def mouse_x
+    @window.mouse_x
+  end
+  def mouse_y
+    @window.mouse_y
+  end
+
 end

data/lib/gamebox/lib/inflector.rb

@@ -275,4 +275,4 @@ module Inflector
   end
 end
 
-require 'inflections'
+

data/lib/gamebox/lib/range_ext.rb

@@ -0,0 +1,5 @@
+class Range
+  def sample
+    num = self.min + rand(self.max-self.min)
+  end
+end

data/lib/gamebox/lib/rect.rb

@@ -1,56 +1,56 @@
 #--
-#	Rubygame -- Ruby code and bindings to SDL to facilitate game creation
-#	Copyright (C) 2004-2007  John Croisant
+#  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 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.
+#  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
+#  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!
+#   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
+#  class Surface
+#    make_rect
 # 
 #++
 
@@ -69,77 +69,77 @@
 # 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
+  #--
+  # 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
 
 
   # Returns an SDL::Rect version of this Rect. Float values are
@@ -150,461 +150,461 @@ class Rect < Array
   end
 
 
-	#--
-	# ATTRIBUTES
-	#++
+  #--
+  # 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
 
-	# Returns self.at(0)
-	def x; return self.at(0); end
-	# Sets self[0] to +val+
-	def x=(val); self[0] = val; end
+  alias r right
+  alias r= right=;
 
-	alias left x
-	alias left= x=;
-	alias l x
-	alias l= x=;
+  # Return the y coordinate of the bottom side of the Rect.
+  def bottom; return self.at(1)+self.at(3); end
 
-	# Returns self.at(1)
-	def y; return self.at(1); end
-	# Sets self[1] to +val+
-	def y=(val); self[1] = val; 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 top y
-	alias top= y=;
-	alias t y
-	alias t= y=;
+  alias b bottom
+  alias b= bottom=;
 
-	# Returns self.at(2)
-	def w; return self.at(2); end
-	# Sets self[2] to +val+
-	def w=(val); self[2] = val; end
+  # Return the x and y coordinates of the center of the Rect.
+  def center; return self.centerx, self.centery; end
 
-	alias width w
-	alias width= w=;
+  # 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=;
 
-	# Returns self.at(3)
-	def h; return self.at(3); end
-	# Sets self[3] to +val+
-	def h=(val); self[3] = val; end
+  # Return the x coordinate of the center of the Rect
+  def centerx; return self.at(0)+(self.at(2).div(2)); end
 
-	alias height h
-	alias height= h=;
+  # 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
 
-	# Return the width and height of the Rect.
-	def size; return self[2,2]; end
+  alias cx centerx
+  alias cx= centerx=;
 
-	# 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 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
 
-	# 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=;
+  alias mt midtop
+  alias mt= midtop=;
 
-	# Return the y coordinate of the bottom side of the Rect.
-	def bottom; return self.at(1)+self.at(3); end
+  # 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 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!
+  # 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!
+    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
+    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
+    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
+  # 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|
+  # 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
+    return self
+  end
 
 
 end # class Rect