rubygame 2.6.2 → 2.6.3

data/NEWS

@@ -1,5 +1,38 @@
 = NEWS
 
+== Rubygame 2.6.3
+
+Release focus: Bug fixes.
+
+=== Fixes
+
+- Fixed: MouseMoved events always reported that all buttons were
+  being pressed, even when they were not. [#38]
+
+- Fixed: MousePressed and MouseReleased events would raise an error
+  for mouse buttons larger than 5. [#40]
+
+- Fixed: KeyPressed and KeyReleased events always reported that all
+  modifier keys were being pressed, even when they were not. [#41]
+
+- Fixed: Rubygame would generate spurious WindowUnminimized,
+  InputFocusGained, and MouseFocusGained events (or the opposite)
+  whenever any one of those events actually occurred.
+
+- Fixed: Surface#convert would raise NameError if no Screen was open,
+  due to a typo. [#42]
+
+=== Other Changes
+
+- Rubygame will now skip auto-initialization if the RUBYGAME_NOINIT
+  environment variable (`ENV["RUBYGAME_NOINIT"]`) is set to "1",
+  "true", or "yes" (case insensitive). You must set the environment
+  variable *before* doing `require "rubygame"`. This is intended
+  for special cases where auto-initialization is not wanted.
+
+
+
+
 == Rubygame 2.6.2
 
 Release focus: Bug fixes.

data/lib/rubygame.rb

@@ -89,5 +89,9 @@ end
 require File.join( this_dir, "rubygame", "screen" )
 
 
-Rubygame.init
-at_exit { Rubygame.quit }
+# Handle initialization automatically unless the RUBYGAME_NOINIT
+# environmental variable is set to something truthy.
+unless /^(1|t|true|y|yes)$/i =~ ENV["RUBYGAME_NOINIT"]
+  Rubygame.init
+  at_exit { Rubygame.quit }
+end

data/lib/rubygame/color.rb

@@ -102,9 +102,19 @@ module Rubygame
     end
 
     def self.make_sdl_rgba( color ) # :nodoc:
-      r,g,b,a = convert_color(color).collect!{ |c| c.to_i }[0,4]
-      a = 255 if a.nil?
-      [r,g,b,a]
+      @rgba_cache ||= {}
+      @rgba_cache[color] ||=
+        begin
+          r,g,b,a = convert_color(color).collect!{ |c| c.to_i }[0,4]
+          a ||= 255
+          [r,g,b,a].freeze
+        end
+    end
+
+
+    def self.remove_from_cache( color_name )
+      @rgba_cache ||= {}
+      @rgba_cache.delete( color_name )
     end
 
 	end

data/lib/rubygame/color/models/hsl.rb

@@ -59,6 +59,14 @@ module Rubygame
 			end
 			alias :inspect :to_s
 			
+			def hash
+				@hash ||= ((@h.hash << 4) +
+				           (@s.hash << 3) +
+				           (@l.hash << 2) +
+				           (@a.hash << 1) +
+				           self.class.hash)
+			end
+
 			class << self
 
 				def new_from_rgba( rgba )

data/lib/rubygame/color/models/hsv.rb

@@ -59,6 +59,14 @@ module Rubygame
 			end
 			alias :inspect :to_s
 			
+			def hash
+				@hash ||= ((@h.hash << 4) +
+				           (@s.hash << 3) +
+				           (@v.hash << 2) +
+				           (@a.hash << 1) +
+				           self.class.hash)
+			end
+
 			class << self
 				
 				def new_from_rgba( rgba )

data/lib/rubygame/color/models/rgb.rb

@@ -63,6 +63,14 @@ module Rubygame
 			end
 			alias :inspect :to_s
 			
+			def hash
+				@hash ||= ((@r.hash << 4) +
+				           (@g.hash << 3) +
+				           (@b.hash << 2) +
+				           (@a.hash << 1) +
+				           self.class.hash)
+			end
+
 			class << self
 				def new_from_rgba( rgba )
 					new( rgba )

data/lib/rubygame/color/palettes/palette.rb

@@ -48,6 +48,9 @@ class Rubygame::Color::Palette
 	
 	# Store a color by name in this palette. See #sanitize_name
 	def []=( name, color )
+    # Uncache colors with this name, to avoid using obsolete value.
+    Rubygame::Color.remove_from_cache( name )
+
 		name = sanitize_name( name )
 		@colors[name] = color
 	end

data/lib/rubygame/deprecated_mixer.rb

@@ -257,7 +257,7 @@ class Rubygame::Mixer::Sample
   def self.load_audio( filename )
     Rubygame.deprecated( "Rubygame::Mixer::Sample", "3.0" )
 
-    chunk = SDL::Mixer.LoadWAV( filename )
+    chunk = SDL::Mixer.LoadWAV( filename.to_s )
 
     if( chunk.pointer.null? )
       raise( Rubygame::SDLError,
@@ -331,7 +331,7 @@ class Rubygame::Mixer::Music
   def self.load_audio
     Rubygame.deprecated( "Rubygame::Mixer::Music", "3.0" )
 
-    music = SDL::Mixer.LoadMUS( filename )
+    music = SDL::Mixer.LoadMUS( filename.to_s )
 
     if( music.pointer.null? )
       raise( Rubygame::SDLError,

data/lib/rubygame/events.rb

@@ -144,14 +144,14 @@ module Rubygame
       gain  = ev.gain
 
       # any_state = SDL::APPACTIVE | SDL::APPINPUTFOCUS | SDL::APPMOUSEFOCUS
-      # if( state & any_state == 0 )
+      # if (state & any_state) == 0
       #   raise( Rubygame::SDLError, "Unknown ACTIVEEVENT state #{state}. "+
       #          "This is a bug in Rubygame." )
       # end
 
       events = []
 
-      if( SDL::APPACTIVE & state )
+      if (SDL::APPACTIVE & state) != 0
         if( gain == 1 )
           events << WindowUnminimized.new
         else
@@ -159,7 +159,7 @@ module Rubygame
         end
       end
 
-      if( SDL::APPINPUTFOCUS & state )
+      if (SDL::APPINPUTFOCUS & state) != 0
         if( gain == 1 )
           events << InputFocusGained.new
         else
@@ -167,7 +167,7 @@ module Rubygame
         end
       end
 
-      if( SDL::APPMOUSEFOCUS & state )
+      if (SDL::APPMOUSEFOCUS & state) != 0
         if( gain == 1 )
           events << MouseFocusGained.new
         else
@@ -320,17 +320,17 @@ module Rubygame
       return [] if mods == 0
 
       array = []
-      array << :left_shift   if( mods & SDL::KMOD_LSHIFT )
-      array << :right_shift  if( mods & SDL::KMOD_RSHIFT )
-      array << :left_ctrl    if( mods & SDL::KMOD_LCTRL  )
-      array << :right_ctrl   if( mods & SDL::KMOD_RCTRL  )
-      array << :left_alt     if( mods & SDL::KMOD_LALT   )
-      array << :right_alt    if( mods & SDL::KMOD_RALT   )
-      array << :left_meta    if( mods & SDL::KMOD_LMETA  )
-      array << :right_meta   if( mods & SDL::KMOD_RMETA  )
-      array << :numlock      if( mods & SDL::KMOD_NUM    )
-      array << :capslock     if( mods & SDL::KMOD_CAPS   )
-      array << :mode         if( mods & SDL::KMOD_MODE   )
+      array << :left_shift   if (mods & SDL::KMOD_LSHIFT) != 0
+      array << :right_shift  if (mods & SDL::KMOD_RSHIFT) != 0
+      array << :left_ctrl    if (mods & SDL::KMOD_LCTRL ) != 0
+      array << :right_ctrl   if (mods & SDL::KMOD_RCTRL ) != 0
+      array << :left_alt     if (mods & SDL::KMOD_LALT  ) != 0
+      array << :right_alt    if (mods & SDL::KMOD_RALT  ) != 0
+      array << :left_meta    if (mods & SDL::KMOD_LMETA ) != 0
+      array << :right_meta   if (mods & SDL::KMOD_RMETA ) != 0
+      array << :numlock      if (mods & SDL::KMOD_NUM   ) != 0
+      array << :capslock     if (mods & SDL::KMOD_CAPS  ) != 0
+      array << :mode         if (mods & SDL::KMOD_MODE  ) != 0
 
       return array
     end
@@ -378,7 +378,7 @@ module Rubygame
                when SDL::BUTTON_RIGHT;        :mouse_right
                when SDL::BUTTON_WHEELUP;      :mouse_wheel_up
                when SDL::BUTTON_WHEELDOWN;    :mouse_wheel_down
-               else;                          ("mouse_%d"%button).to_sym
+               else;                          ("mouse_%d"%ev.button).to_sym
                end
 
       pos = [ev.x, ev.y]
@@ -402,11 +402,13 @@ module Rubygame
       mods = ev.state
 
       btns = []
-      btns << :mouse_left        if( mods & SDL::BUTTON_LMASK )
-      btns << :mouse_middle      if( mods & SDL::BUTTON_MMASK )
-      btns << :mouse_right       if( mods & SDL::BUTTON_RMASK )
-      btns << :mouse_wheel_up    if( mods & (1<<(SDL::BUTTON_WHEELUP - 1)) )
-      btns << :mouse_wheel_down  if( mods & (1<<(SDL::BUTTON_WHEELDOWN - 1)) )
+      btns << :mouse_left        if (mods & SDL::BUTTON_LMASK) != 0
+      btns << :mouse_middle      if (mods & SDL::BUTTON_MMASK) != 0
+      btns << :mouse_right       if (mods & SDL::BUTTON_RMASK) != 0
+      btns << :mouse_wheel_up    if (mods & 
+                                     (1 << (SDL::BUTTON_WHEELUP - 1))) != 0
+      btns << :mouse_wheel_down  if (mods & 
+                                     (1 << (SDL::BUTTON_WHEELDOWN - 1))) != 0
 
       pos = [ev.x,    ev.y]
       rel = [ev.xrel, ev.yrel]

data/lib/rubygame/image.rb

@@ -76,7 +76,7 @@ class Rubygame::Surface
     # XPM:: "XPixMap" format.
     # 
     def load( filename )
-      surf = SDL::Image.Load( filename )
+      surf = SDL::Image.Load( filename.to_s )
 
       if( surf.pointer.null? )
         raise( Rubygame::SDLError, "Couldn't load image \"%s\": %s"%\

data/lib/rubygame/music.rb

@@ -76,7 +76,7 @@ class Rubygame::Music
     def load( filename )
       Rubygame.open_audio
 
-      music = SDL::Mixer.LoadMUS( filename )
+      music = SDL::Mixer.LoadMUS( filename.to_s )
 
       if( music.pointer.null? )
         raise( Rubygame::SDLError, "Could not load Music file '%s': %s"%

data/lib/rubygame/old_rect.rb

@@ -0,0 +1,612 @@
+#--
+#	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 Rubygame
+
+# 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
+
+
+  # Returns an SDL::Rect version of this Rect. Float values are
+  # rounded to the nearest integer.
+  # 
+  def to_sdl                    # :nodoc:
+    SDL::Rect.new( self.collect{|n| n.round } )
+  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
+
+end # module Rubygame

data/lib/rubygame/screen.rb

@@ -153,12 +153,73 @@ class Rubygame::Screen < Rubygame::Surface
 
 
 
+  # call-seq:
+  #   new( size, opts={} )
+  #   new( size, depth=0, flags=[] )  # DEPRECATED
+  # 
   # Create a new Rubygame window if there is none, or modify the
   # existing one. You cannot create more than one Screen; the existing
   # one will be replaced. (This is a limitation of SDL.)
   # 
   # Returns the resulting Screen.
   #
+  # size:: Screen size to create, [width, height] (in pixels).
+  # 
+  # opts::
+  #   Hash of options. The possible options are:
+  # 
+  #   :depth::      Requested color depth (in bits per pixel). If this
+  #                 is 0 or unspecified, Rubygame automatically
+  #                 chooses the depth based on the system depth.
+  #                 Possible values: 0, 8, 15, 16, 24, 32. Default: 0.
+  # 
+  #   :fullscreen:: If true, use fullscreen mode. If a hardware
+  #                 resolution change is not possible (for whatever
+  #                 reason), the next higher resolution will be used
+  #                 and the display window centered on a black
+  #                 background. Default: false.
+  # 
+  #   :resizable::  If true, the user will be able to resize the
+  #                 Rubygame window. When the window is resized, a
+  #                 ResizeEvent or Events::WindowResized event is
+  #                 generated. You should then use Screen.open to
+  #                 re-create the display surface at the new size.
+  #                 Default: false.
+  # 
+  #   :noframe::    If true, try to create a window with no title bar
+  #                 or frame decoration. This is automatically true
+  #                 when :fullscreen is true. Default: false.
+  # 
+  #   :hardware::   If true, try to create a hardware accelerated
+  #                 Surface (using a graphics card), which may be very
+  #                 fast to blit onto other hardware accelerated
+  #                 Surfaces, but somewhat slower to access in other
+  #                 ways. Creates a normal, non-accelerated Surface if
+  #                 hardware Surfaces are not available. Default:
+  #                 false.
+  # 
+  #   :doublebuf::  If true, enable hardware double buffering; only
+  #                 valid when :hardware is true. Calling #flip will
+  #                 switch the buffers and update the screen. All
+  #                 drawing will take place on the surface that is not
+  #                 displayed at the moment. If double buffering could
+  #                 not be enabled then #flip will just update the
+  #                 entire screen. Default: false.
+  # 
+  #   :opengl::     If true, create an OpenGL rendering context
+  #                 instead of a normal SDL display. You must set
+  #                 proper OpenGL video attributes with GL#set_attrib
+  #                 before calling this method with this flag. You can
+  #                 then use an OpenGL library (e.g. ruby-opengl) to
+  #                 do all OpenGL-related functions. Please note that
+  #                 you can't blit or draw regular SDL Surfaces onto
+  #                 an OpenGL-mode screen; you must use OpenGL
+  #                 functions. Default: false.
+  # 
+  # For backwards compatibility, you can provide the following
+  # arguments instead of the ones above. However, this form is
+  # DEPRECATED and will be removed in Rubygame 3.0:
+  # 
   # size::  requested window size (in pixels), in the form [width,height]
   # depth:: requested color depth (in bits per pixel). If 0 (default), the
   #         current system color depth.
@@ -204,7 +265,7 @@ class Rubygame::Screen < Rubygame::Surface
   #                      frame decoration.
   #                      Fullscreen modes automatically have this flag set.
   #
-  def initialize(  size, depth=0, flags=[Rubygame::SWSURFACE] )
+  def initialize( size, *args )
 
     # Cheating a bit. First arg can be a SDL::Surface to wrap it.
     #
@@ -220,7 +281,41 @@ class Rubygame::Screen < Rubygame::Surface
       return
     end
 
+    # Support old argument style for backwards compatibility.
+    if args.size > 1 or not args[0].is_a? Hash
+      _initialize_old( size, *args )
+      return
+    end
+
+    args = _parse_args( size, args[0] )
 
+    @struct = SDL.SetVideoMode( args[:width], args[:height],
+                                args[:depth], args[:flags] )
+
+    if( @struct.pointer.null? )
+      @struct = nil
+      raise( Rubygame::SDLError,
+             "Couldn't set [%d x %d] %d bpp video mode: %s"%\
+             [args[:width], args[:height], args[:depth], SDL.GetError()] )
+    end
+  end
+
+
+  def _parse_args( size, options ) # :nodoc:
+    args = super
+
+    flags = args[:flags]
+
+    flags |= SDL::FULLSCREEN if options[:fullscreen]
+    flags |= SDL::RESIZABLE  if options[:resizable]
+    flags |= SDL::NOFRAME    if options[:noframe]
+    flags |= SDL::DOUBLEBUF  if options[:doublebuf]
+    flags |= SDL::OPENGL     if options[:opengl]
+
+    args.merge( :flags => flags )
+  end
+
+  def _initialize_old( size, depth=0, flags=[] ) # :nodoc:
     w,h = size
     flags = Rubygame.collapse_flags(flags)
 
@@ -232,7 +327,6 @@ class Rubygame::Screen < Rubygame::Surface
              "Couldn't set [%d x %d] %d bpp video mode: %s"%\
              [w, h, depth, SDL.GetError()] )
     end
-
   end
 
 

data/lib/rubygame/sound.rb

@@ -73,7 +73,7 @@ class Rubygame::Sound
     def load( filename )
       Rubygame.open_audio
 
-      sound = SDL::Mixer.LoadWAV( filename )
+      sound = SDL::Mixer.LoadWAV( filename.to_s )
 
       if( sound.pointer.null? )
         raise( Rubygame::SDLError, "Could not load Sound file '%s': %s"%

data/lib/rubygame/surface.rb

@@ -48,18 +48,53 @@ class Rubygame::Surface
   protected :struct
 
 
-  # Create and initialize a new Surface object.
+  # call-seq:
+  #   new( size, opts={} )
+  #   new( size, depth=0, flags=[] )  # DEPRECATED
+  # 
+  # Create and initialize a new Surface.
   #
-  # A Surface is a grid of image data which you blit (i.e. copy) onto other
-  # Surfaces. Since the Rubygame display is also a Surface (see the Screen
-  # class), Surfaces can be blit to the screen; this is the most common way
-  # to display images on the screen.
+  # A Surface is a grid of image data which you blit (i.e. copy) onto
+  # other Surfaces. Since the Screen is also a Surface, Surfaces can
+  # be blit to the screen; this is the most common way to display
+  # images on the screen.
   #
   # This method may raise SDLError if the SDL video subsystem could
   # not be initialized for some reason.
   #
   # This function takes these arguments:
-  # size::  requested surface size; an array of the form [width, height].
+  # 
+  # size:: Surface size to create, [width, height] (in pixels).
+  # 
+  # opts::
+  #   Hash of options. The possible options are:
+  # 
+  #   :depth::    Requested color depth (in bits per pixel). If this
+  #               is 0 or unspecified, Rubygame automatically chooses
+  #               the depth based on the Screen mode or system depth.
+  #               Possible values: 0, 8, 15, 16, 24, 32. Default: 0.
+  # 
+  #   :alpha::    If true, Surfaces with depth 32 will have an alpha
+  #               channel (per-pixel transparency). Default: true.
+  #               (Note: Other depths cannot have an alpha channel.)
+  # 
+  #   :hardware:: If true, try to create a hardware accelerated
+  #               Surface (using a graphics card), which may be very
+  #               fast to blit onto other hardware accelerated
+  #               Surfaces, but somewhat slower to access in other
+  #               ways. Creates a normal, non-accelerated Surface if
+  #               hardware Surfaces are not available. Default: false.
+  # 
+  #   :masks::    For advanced users. Set the Surface's color masks
+  #               manually, as [r,g,b,a]. If this is nil or
+  #               unspecified, the color masks are calculated
+  #               automatically.
+  # 
+  # For backwards compatibility, you can provide the following
+  # arguments instead of the ones above. However, this form is
+  # DEPRECATED and will be removed in Rubygame 3.0:
+  # 
+  # size::  Surface size to create, [width, height] (in pixels).
   # depth:: requested color depth (in bits per pixel). If depth is 0 (default),
   #         automatically choose a color depth: either the depth of the Screen
   #         mode (if one has been set), or the greatest color depth available
@@ -80,7 +115,7 @@ class Rubygame::Surface
   #                       also enable alpha. as needed. For a description
   #                       of alpha, see #alpha.
   #
-  def initialize( size, depth=0, flags=[] )
+  def initialize( size, *args )
 
     # Cheating a bit. First arg can be a SDL::Surface to wrap it.
     #
@@ -94,6 +129,85 @@ class Rubygame::Surface
       return
     end
 
+    # Support old argument style for backwards compatibility.
+    if args.size > 1 or not args[0].is_a? Hash
+      _initialize_old( size, *args )
+      return
+    end
+
+    args = _parse_args( size, args[0] )
+
+    @struct = SDL.CreateRGBSurface( args[:flags],
+                                    args[:width], args[:height],
+                                    args[:depth], *args[:masks] )
+  end
+
+
+  private
+
+
+  def _parse_args( size, options )
+    unless size.is_a?(Array) and size.size == 2 and
+        size.all?{ |i| i.is_a?(Integer) and i > 0 }
+      raise( TypeError, "Invalid size: " + size.inspect +
+             " (expected [width,height] array of integers >= 0)" )
+    end
+
+    depth = options[:depth] || 0
+    unless depth.is_a?(Integer) and depth >= 0
+      raise( TypeError, "Invalid depth: " + depth.inspect +
+             " (expected integer >= 0)" )
+    end
+
+    alpha = options.has_key?(:alpha) ? options[:alpha] : true
+
+    masks = options[:masks]
+    if masks.nil?
+      masks = _make_masks( depth, alpha )
+    else
+      unless masks.size == 4 and masks.all?{|m| m.is_a?(Integer) and m >= 0}
+        raise( TypeError, "Invalid masks: " + masks.inspect +
+               " (expected [r,g,b,a] array of integers >= 0)" )
+      end
+    end
+
+    flags = 0
+    flags |= SDL::HWSURFACE if options[:hardware]    
+
+    { :width  => size[0],
+      :height => size[1],
+      :depth  => depth,
+      :masks  => masks,
+      :flags  => flags,
+    }
+  end
+
+
+  # Calculate color masks based on requested depth and (for 32 bit)
+  # whether or not to have an alpha channel.
+  def _make_masks( depth, alpha ) # :nodoc:
+    a = alpha ? 0xff000000 : 0
+
+    masks = case depth
+            when 32;  [0xff0000,  0x00ff00,  0x0000ff,  a]
+            when 24;  [0xff0000,  0x00ff00,  0x0000ff,  0]
+            when 16;  [0x00f800,  0x0007e0,  0x00001f,  0]
+            when 15;  [0x007c00,  0x0003e0,  0x00001f,  0]
+            else      [       0,         0,         0,  0]
+            end
+
+    if FFI::Platform::BYTE_ORDER == FFI::Platform::BIG_ENDIAN
+      masks[0,3] = masks[0,3].reverse
+    end
+
+    masks
+  end
+
+
+  # Initialize the Surface in the deprecated (pre-2.7) way.
+  def _initialize_old( size, depth=0, flags=[] ) # :nodoc:
+    Rubygame.deprecated("Old Surface#new arguments style", "3.0")
+
     unless size.kind_of? Array
       raise TypeError, "Surface size is not an Array: #{size.inspect}"
     end
@@ -139,6 +253,8 @@ class Rubygame::Surface
   end
 
 
+  public
+
 
   # Return the width (in pixels) of the surface.
   #
@@ -515,7 +631,7 @@ class Rubygame::Surface
 
     if other.nil?
       begin
-        other = Rubygame::ScreenFFI.get_surface
+        other = Rubygame::Screen.get_surface
       rescue Rubygame::SDLError
         raise( Rubygame::SDLError, "Cannot convert Surface with no target " +
                "given and no Screen made: #{SDL.GetError()}" )
@@ -601,7 +717,7 @@ class Rubygame::Surface
   # May raise SDLError if a problem occurs.
   #
   def savebmp( filename )
-    result = SDL.SaveBMP( @struct, filename )
+    result = SDL.SaveBMP( @struct, filename.to_s )
     if(result != 0)
       raise( Rubygame::SDLError, "Couldn't save surface to file %s: %s"%\
              [filename, SDL.GetError()] )

data/lib/rubygame/ttf.rb

@@ -75,7 +75,7 @@ class Rubygame::TTF
              "You must call TTF.setup before opening a font." )
     end
 
-    @struct = SDL::TTF.OpenFont( file, size )
+    @struct = SDL::TTF.OpenFont( file.to_s, size )
 
     if( @struct.pointer.null? )
       raise Rubygame::SDLError, "Could not open font: #{SDL.GetError()}"

data/samples/demo_gl.rb

@@ -27,7 +27,7 @@ Rubygame::GL.set_attrib(Rubygame::GL::BLUE_SIZE, 5)
 Rubygame::GL.set_attrib(Rubygame::GL::DEPTH_SIZE, 16)
 Rubygame::GL.set_attrib(Rubygame::GL::DOUBLEBUFFER, 1)
 
-Rubygame::Screen.open([WIDE,HIGH], 16, [Rubygame::OPENGL])
+Rubygame::Screen.open([WIDE,HIGH], :depth => 16, :opengl => true)
 queue = Rubygame::EventQueue.new()
 clock = Rubygame::Clock.new { |c| c.target_framerate = 60 }
 

data/samples/demo_gl_tex.rb

@@ -31,7 +31,7 @@ Rubygame::GL.set_attrib(Rubygame::GL::BLUE_SIZE, 5)
 Rubygame::GL.set_attrib(Rubygame::GL::DEPTH_SIZE, 16)
 Rubygame::GL.set_attrib(Rubygame::GL::DOUBLEBUFFER, 1)
 
-Rubygame::Screen.open([WIDE,HIGH], 16, [Rubygame::OPENGL])
+Rubygame::Screen.open([WIDE,HIGH], :depth => 16, :opengl => true)
 queue = Rubygame::EventQueue.new()
 clock = Rubygame::Clock.new { |c| c.target_framerate = 60 }
 

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: rubygame
 version: !ruby/object:Gem::Version 
-  version: 2.6.2
+  prerelease: false
+  segments: 
+  - 2
+  - 6
+  - 3
+  version: 2.6.3
 platform: ruby
 authors: 
 - John Croisant
@@ -9,29 +14,37 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-12 00:00:00 -06:00
+date: 2010-03-31 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rake
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 7
+        - 0
         version: 0.7.0
-    version: 
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: ruby-sdl-ffi
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 0
         version: 0.1.0
-    version: 
+  type: :runtime
+  version_requirements: *id002
 description: 
 email: jacius@gmail.com
 executables: []
@@ -74,6 +87,7 @@ files:
 - lib/rubygame/mediabag.rb
 - lib/rubygame/color.rb
 - lib/rubygame/sprite.rb
+- lib/rubygame/old_rect.rb
 - lib/rubygame/event_triggers.rb
 - lib/rubygame/music.rb
 - lib/rubygame/surface.rb
@@ -145,14 +159,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
       version: "1.8"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: 
 - SDL       >= 1.2.7
 - SDL_gfx   >= 2.0.10 (optional)
@@ -160,7 +177,7 @@ requirements:
 - SDL_mixer >= 1.2.7  (optional)
 - SDL_ttf   >= 2.0.6  (optional)
 rubyforge_project: rubygame
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Clean and powerful library for game programming