rubygame 2.2.0-i586-linux

data/lib/rubygame/clock.rb

@@ -0,0 +1,128 @@
+#--
+#	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
+#++
+
+module Rubygame
+		#  Clock provides class methods for tracking running time and delaying
+		#  execution of the program for specified time periods. This is used to
+		#  provide a consistent framerate, prevent the program from using
+		#  all the processor time, etc.
+		# 
+		#  Clock also provides instance methods to make it convenient to
+		#  monitor and limit application framerate. See #tick.
+		class Clock
+			# The runtime when the Clock was initialized.
+			attr_reader :start        
+			# The number of times #tick has been called.
+			attr_reader :ticks        
+
+			# Create a new Clock instance.
+			def initialize()
+				@start = Clock.runtime()
+				@last_tick = @start
+				@ticks = 0
+				@target_frametime = nil
+				yield self if block_given?
+			end
+
+			# The target frametime (milliseconds/frame). See #tick
+			attr_accessor :target_frametime
+
+			# Returns the current target framerate (frames/second).
+			# This is an alternate way to access @target_frametime.
+			# Same as: 1000.0 / #target_frametime
+			def target_framerate
+				if @target_frametime
+					1000.0 / @target_frametime
+				else
+					nil
+				end
+			rescue ZeroDivisionError
+				return nil
+			end
+
+			# Sets the target number of frames per second to +framerate+.
+			# This is an alternate way to access @target_frametime.
+			# Same as: #target_frametime = 1000.0 / framerate
+			def target_framerate=( framerate )
+				if framerate
+					@target_frametime = 1000.0 / framerate
+				else
+					@target_frametime = nil
+				end
+			rescue ZeroDivisionError
+				@target_frametime = nil
+			end
+
+			# call-seq: lifetime()  ->  Numeric
+			# 
+			# Returns time in milliseconds since this Clock instance was created.
+			def lifetime
+				Clock.runtime() - @start
+			end
+
+			# call-seq: framerate()  ->  Numeric
+			# 
+			# Return the actual framerate (frames per second) recorded by the Clock.
+			# See #tick.
+			# 
+			# TODO: sample only a few seconds in the past, instead of the
+			# entire lifetime of the Clock. 
+			def framerate
+				# below is same as: return @ticks / (lifetime / 1000.0)
+				return 1000.0 * @ticks / lifetime()
+			rescue ZeroDivisionError
+				return 0
+			end
+
+			# Returns the number of milliseconds since you last called this method.
+			# 
+			# You must call this method once per frame (i.e. per iteration of
+			# your main loop) if you want to use the framerate monitoring and/or
+			# framerate limiting features.
+			# 
+			# Framerate monitoring allows you to check the framerate (frames per
+			# second) with the #framerate method.
+			# 
+			# Framerate limiting allows you to prevent the application from running
+			# too fast (and using 100% of processor time) by pausing the program
+			# very briefly each frame. The pause duration is calculated each frame
+			# to maintain a constant framerate.
+			# 
+			# Framerate limiting is only enabled if you have set the
+			# #target_framerate= or #target_frametime=.
+			# If you have done that, this method will automatically perform the
+			# delay each time you call it.
+			# 
+			# (Please note that no effort is made to correct a framerate
+			# which is *slower* than the target framerate. Clock can't
+			# make your code run faster, only slow it down if it is
+			# running too fast.)
+			def tick()
+				passed = Clock.runtime() - @last_tick  # how long since the last tick?
+				if @target_frametime
+					return Clock.delay(@target_frametime - passed) + passed
+				end
+				return passed
+			ensure
+				@last_tick = Clock.runtime()
+				@ticks += 1
+			end
+
+		end # class Clock
+end #module Rubygame

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

@@ -0,0 +1,106 @@
+#--
+#	Rubygame -- Ruby code and bindings to SDL to facilitate game creation
+#	Copyright (C) 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
+#++
+
+
+# A mix-in module defining color arithmetic operations.
+module ColorBase
+
+	# Perform color addition with another color of any type.
+	# The alpha of the new color will be equal to the alpha
+	# of the receiver.
+	def +(other)
+		wrap( simple_op(other)  { |a,b| a + b } )
+	end
+	
+	# Perform color subtraction with another color of any type.
+	# The alpha of the new color will be equal to the alpha
+	# of the receiver.
+	def -(other)
+		wrap( simple_op(other)  { |a,b|  a - b } )
+	end
+
+	# Perform color multiplication with another color of any type.
+	# The alpha of the new color will be equal to the alpha
+	# of the receiver.
+	def *(other)
+		wrap( simple_op(other)  { |a,b|  a * b } )
+	end
+	
+	# Perform color division with another color of any type.
+	# The alpha of the new color will be equal to the alpha
+	# of the receiver.
+	def /(other)
+		wrap( simple_op(other)  { |a,b|  a / b } )
+	end
+	
+	# Layer this color over another color.
+	def over(other)
+		c1, c2 = self.to_rgba_ary, other.to_rgba_ary
+		a1, a2 = c1[3], c2[3]
+
+		rgba = [0,1,2].collect do |i| 
+			clamp( a1*c1.at(i) + a2*c2.at(i)*(1-a1) )
+		end
+		
+		rgba << ( a1 + a2*(1-a1) )
+		
+		wrap( rgba )
+	end
+	
+	# Average this color with another color. (Linear weighted average)
+	# 
+	# A weight of 0.0 means 0% of this color, 100% of the other.
+	# A weight of 1.0 means 100% of this color, 0% of the other.
+	# A weight of 0.5 means 50% of each color.
+	# 
+	def average(other, weight=0.5)
+		c1, c2 = self.to_rgba_ary, other.to_rgba_ary
+
+		rgba = [0,1,2,3].collect do |i| 
+			clamp( c1.at(i)*weight + c2.at(i)*(1-weight) )
+		end
+		
+		wrap( rgba )
+	end
+
+	private
+	
+	def wrap( rgba )
+		self.class.new_from_rgba( rgba )
+	end
+	
+	def simple_op(other, &block)
+		c1, c2 = self.to_rgba_ary, other.to_rgba_ary
+		a1, a2 = c1[3], c2[3]
+
+		rgba = [0,1,2].collect do |i| 
+			clamp( block.call( a1*c1.at(i),  a2*c2.at(i) ) )
+		end
+
+		rgba << a1
+
+		return rgba
+	end
+	
+	def clamp(v, min=0.0, max=1.0)
+		v = min if v < min
+		v = max if v > max
+		return v		
+	end
+end

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

@@ -0,0 +1,153 @@
+#--
+#	Rubygame -- Ruby code and bindings to SDL to facilitate game creation
+#	Copyright (C) 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
+#++
+
+require 'rubygame/color/models/base'
+
+module Rubygame
+	module Color
+
+		# Represents color in the HSL (Hue, Saturation, Luminosity) color space.
+		class ColorHSL
+			include ColorBase
+			
+			attr_reader :h, :s, :l, :a
+
+			# call-seq:
+			#   new( [h,s,l,a] )  ->  ColorHSL
+			#   new( [h,s,l] )  ->  ColorHSL
+			#   new( color )  ->  ColorHSL
+			# 
+			# Create a new instance from an Array or an existing color
+			# (of any type). If the alpha (opacity) component is omitted
+			# from the array, full opacity will be used.
+			# 
+			# All color components range from 0.0 to 1.0.
+			# 
+			def initialize( color )
+				if color.kind_of?(Array)
+					@h, @s, @l, @a = color.collect { |i| i.to_f }
+					@a = 1.0 unless @a
+				elsif color.respond_to?(:to_rgba_ary)
+					@h, @s, @l, @a = self.class.rgba_to_hsla( *color.to_rgba_ary )
+				end
+			end
+
+			# Return an Array with the red, green, blue, and alpha components
+			# of the color (converting the color to the RGBA model first).
+			def to_rgba_ary
+				return self.class.hsla_to_rgba( @h, @s, @l, @a )
+			end
+			
+			def to_s
+				"#<#{self.class} [#{@h}, #{@s}, #{@l}, #{@a}]>"
+			end
+			alias :inspect :to_s
+			
+			class << self
+
+				def new_from_rgba( rgba )
+					new( rgba_to_hsla(*rgba) )
+				end
+				
+				def new_from_sdl_rgba( rgba )
+					new_from_rgba( rgba.collect { |i| i / 255.0 } )
+				end
+				
+				# Convert the red, green, blue, and alpha to the
+				# equivalent hue, saturation, luminosity, and alpha.
+				def rgba_to_hsla( r, g, b, a ) # :nodoc:
+					rgb_arr = [r, g, b]
+					max     = rgb_arr.max
+					min     = rgb_arr.min
+
+					# Calculate lightness.
+					l = (max + min) / 2.0
+
+					# Calculate saturation.
+					if l == 0.0 or max == min
+						s = 0
+					elsif 0 < l and l <= 0.5 
+						s = (max - min) / (max + min)
+					else # l > 0.5
+						s = (max - min) / (2 - (max + min))
+					end
+					
+					# Calculate hue.
+					if min == max 
+						h = 0 
+						# Undefined in this case, but set it to zero
+					elsif max == r and g >= b
+						h = (1.quo(6) * (g - b) / (max - min)) + 0
+					elsif max == r and g < b
+						h = (1.quo(6) * (g - b) / (max - min)) + 1.0
+					elsif max == g
+						h = (1.quo(6) * (b - r) / (max - min)) + 1.quo(3)
+					elsif max == b
+						h = (1.quo(6) * (r - g) / (max - min)) + 2.quo(3)
+					else 
+						raise "Should never happen"
+					end 
+					
+					return [h,s,l,a]
+				end
+				
+				# Convert the hue, saturation, luminosity, and alpha
+				# to the equivalent red, green, blue, and alpha.
+				def hsla_to_rgba( h, s, l, a ) # :nodoc:
+					# If the color is achromatic, return already with the lightness value for all components
+					if s == 0.0
+						return [l, l, l, a]
+					end
+
+					# Otherwise, we have to do the long, hard calculation
+
+					# q helper value
+					q = (l < 0.5) ? (l * (1.0 + s)) : (l + s - l * s)
+
+					# p helper value
+					p = (2.0 * l) - q
+
+					r = calculate_component( p, q, h + 1.quo(3) )
+					g = calculate_component( p, q, h            )
+					b = calculate_component( p, q, h - 1.quo(3) )
+
+					return [r,g,b,a]
+				end
+
+				private
+				
+				# Perform some arcane math to calculate a color component.
+				def calculate_component(p, q, tc) # :nodoc:
+					tc %= 1.0
+					if tc < 1.quo(6)
+						p + (q - p) * tc * 6.0
+					elsif tc < 0.5
+						q
+					elsif tc < 2.quo(3)
+						p + (q - p) * (2.quo(3) - tc) * 6.0
+					else
+						p 
+					end
+				end
+				
+			end
+
+		end
+	end
+end

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

@@ -0,0 +1,149 @@
+#--
+#	Rubygame -- Ruby code and bindings to SDL to facilitate game creation
+#	Copyright (C) 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
+#++
+
+require 'rubygame/color/models/base'
+
+module Rubygame
+	module Color
+
+		# Represents color in the HSV (Hue, Saturation, Value) color space.
+		class ColorHSV
+			include ColorBase
+
+			attr_reader :h, :s, :v, :a
+
+			# call-seq:
+			#   new( [h,s,v,a] )  ->  ColorHSV
+			#   new( [h,s,v] )  ->  ColorHSV
+			#   new( color )  ->  ColorHSV
+			# 
+			# Create a new instance from an Array or an existing color
+			# (of any type). If the alpha (opacity) component is omitted
+			# from the array, full opacity will be used.
+			# 
+			# All color components range from 0.0 to 1.0.
+			# 
+			def initialize( color )
+				if color.kind_of?(Array)
+					@h, @s, @v, @a = color.collect { |i| i.to_f }
+					@a = 1.0 unless @a
+				elsif color.respond_to?(:to_rgba_ary)
+					@h, @s, @v, @a = self.class.rgba_to_hsva( *color.to_rgba_ary )
+				end
+			end
+			
+			# Return an Array with the red, green, blue, and alpha components
+			# of the color (converting the color to the RGBA model first).
+			def to_rgba_ary
+				return self.class.hsva_to_rgba( @h, @s, @v, @a )
+			end
+			
+			def to_s
+				"#<#{self.class} [#{@h}, #{@s}, #{@v}, #{@a}]>"
+			end
+			alias :inspect :to_s
+			
+			class << self
+				
+				def new_from_rgba( rgba )
+					new( rgba_to_hsva(*rgba) )
+				end
+				
+				def new_from_sdl_rgba( rgba )
+					new_from_rgba( rgba.collect { |i| i / 255.0 } )
+				end
+				
+				# Convert the red, green, blue, and alpha to the
+				# equivalent hue, saturation, value, and alpha.
+				def rgba_to_hsva( r, g, b, a ) # :nodoc:
+					rgb_arr = [r, g, b]
+					max     = rgb_arr.max
+					min     = rgb_arr.min
+
+					# Calculate hue.
+					if min == max 
+						h = 0 
+						# Undefined in this case, but set it to zero
+					elsif max == r and g >= b
+						h = (1.quo(6) * (g - b) / (max - min)) + 0
+					elsif max == r and g < b
+						h = (1.quo(6) * (g - b) / (max - min)) + 1.0
+					elsif max == g
+						h = (1.quo(6) * (b - r) / (max - min)) + 1.quo(3)
+					elsif max == b
+						h = (1.quo(6) * (r - g) / (max - min)) + 2.quo(3)
+					else 
+						raise "Should never happen"
+					end
+
+					# Calulate value.
+					v = max
+
+					# Calculate saturation.
+					if max == 0.0
+						s = 0.0
+					else
+						s = 1.0 - (min / max)
+					end  
+					
+					return [h,s,v,a]
+				end
+
+				# Convert the hue, saturation, value, and alpha
+				# to the equivalent red, green, blue, and alpha.
+				def hsva_to_rgba( h, s, v, a ) # :nodoc:
+					# Determine what part of the "color hexagon" the hue is in.
+					hi = (h * 6).floor % 6
+
+					# Fractional part
+					f  = (h * 6) - hi
+
+					# Helper values
+					p  = v * (1.0 - s)
+					q  = v * (1.0 - (f * s))
+					t  = v * (1.0 - ((1.0 - f) * s))
+
+					# Finally calculate the rgb values
+					r, g, b = calculate_rgb(hi, v, p, t, q)
+
+					return [r, g, b, a]
+				end
+
+				private
+				
+				def calculate_rgb(hi, v, p, t, q) # :nodoc:
+					case hi
+					when 0
+						return v, t, p
+					when 1
+						return q, v, p
+					when 2
+						return p, v, t
+					when 3
+						return p, q, v
+					when 4
+						return t, p, v
+					when 5
+						return v, p, q
+					end
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,78 @@
+#--
+#	Rubygame -- Ruby code and bindings to SDL to facilitate game creation
+#	Copyright (C) 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
+#++
+
+require 'rubygame/color/models/base'
+
+module Rubygame
+	module Color
+
+		# Represents color in the RGB (Red, Green, Blue) color space.
+		class ColorRGB
+			include ColorBase
+			
+			attr_reader :r, :g, :b, :a
+
+			# call-seq:
+			#   new( [r,g,b,a] )  ->  ColorRGB
+			#   new( [r,g,b] )  ->  ColorRGB
+			#   new( color )  ->  ColorRGB
+			# 
+			# Create a new instance from an Array or an existing color
+			# (of any type). If the alpha (opacity) component is omitted
+			# from the array, full opacity will be used.
+			# 
+			# All color components range from 0.0 to 1.0.
+			# 
+			def initialize( color )
+				if color.kind_of?(Array)
+					@r, @g, @b, @a = color.collect { |i| i.to_f }
+					@a = 1.0 unless @a
+				elsif color.respond_to?(:to_rgba_ary)
+					@r, @g, @b, @a = color.to_rgba_ary
+				end
+			end
+			
+			# Converts the color to an RGBA array of integers 
+			# ranging from 0 to 255, as SDL wants.
+			def to_sdl_rgba_ary
+				self.to_rgba_ary.collect { |i| (i * 255).to_i }
+			end
+			
+			def to_rgba_ary
+				return [@r, @g, @b, @a]
+			end
+			
+			def to_s
+				"#<#{self.class} [#{@r}, #{@g}, #{@b}, #{@a}]>"
+			end
+			alias :inspect :to_s
+			
+			class << self
+				def new_from_rgba( rgba )
+					new( rgba )
+				end
+
+				def new_from_sdl_rgba( rgba )
+					new_from_rgba( rgba.collect { |i| i / 255.0 } )
+				end
+			end
+			
+		end
+	end
+end

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

@@ -0,0 +1,49 @@
+#--
+#	Rubygame -- Ruby code and bindings to SDL to facilitate game creation
+#	Copyright (C) 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
+#++
+
+require 'rubygame/color'
+require 'rubygame/color/palettes/palette'
+require 'rubygame/color/palettes/x11'
+
+module Rubygame
+	module Color
+
+		# :enddoc:
+		
+		# The CSS module contains all the colors in the CSS/HTML palette
+		# by symbol name, e.g. :alice_blue, :dark_olive_green, etc.
+		# 
+		# NOTE: The CSS palette is identical to the X11 palette except for
+		# four colors: gray, green, maroon, and purple. 
+		# 
+		# Differences between CSS and X11 derived from
+		# http://en.wikipedia.org/wiki/X11_color_names
+		# as accessed on 2007-12-17
+		# 
+		CSS = Palette.new({
+			:gray =>                     ColorRGB.new( [0.50196, 0.50196, 0.50196] ),
+			:green =>                    ColorRGB.new( [0.00000, 0.50196, 0.00000] ),
+			:maroon =>                   ColorRGB.new( [0.50196, 0.00000, 0.00000] ),
+			:purple =>                   ColorRGB.new( [0.50196, 0.00000, 0.50196] )
+		})
+		
+		CSS.include X11
+		
+	end
+end