rubygame 2.2.0-mswin32

data/ext/rubygame/rubygame_ttf.h

@@ -0,0 +1,69 @@
+/*
+ * 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
+ *
+ */
+
+#ifndef _RUBYGAME_TTF_H
+#define _RUBYGAME_TTF_H
+
+#include "SDL_ttf.h"
+
+#ifndef SDL_TTF_MAJOR_VERSION
+#define SDL_TTF_MAJOR_VERSION 0
+#endif
+
+#ifndef SDL_TTF_MINOR_VERSION
+#define SDL_TTF_MINOR_VERSION 0
+#endif
+
+#ifndef SDL_TTF_PATCHLEVEL
+#define SDL_TTF_PATCHLEVEL 0
+#endif
+
+extern void Init_rubygame_ttf();
+
+extern VALUE cTTF;
+
+extern VALUE rbgm_ttf_setup(VALUE);
+extern VALUE rbgm_ttf_quit(VALUE);
+extern VALUE rbgm_ttf_new(VALUE, VALUE, VALUE);
+extern VALUE rbgm_ttf_initialize(int, VALUE*, VALUE);
+
+extern VALUE rbgm_ttf_getbold(VALUE);
+extern VALUE rbgm_ttf_setbold(VALUE, VALUE);
+
+extern VALUE rbgm_ttf_getitalic(VALUE);
+extern VALUE rbgm_ttf_setitalic(VALUE, VALUE);
+
+extern VALUE rbgm_ttf_getunderline(VALUE);
+extern VALUE rbgm_ttf_setunderline(VALUE, VALUE);
+
+extern VALUE rbgm_ttf_height(VALUE);
+extern VALUE rbgm_ttf_ascent(VALUE);
+extern VALUE rbgm_ttf_descent(VALUE);
+extern VALUE rbgm_ttf_lineskip(VALUE);
+
+extern VALUE rbgm_ttf_sizetext(VALUE, VALUE);
+extern VALUE rbgm_ttf_size_utf8(VALUE, VALUE);
+extern VALUE rbgm_ttf_size_unicode(VALUE, VALUE);
+
+extern VALUE rbgm_ttf_render(int, VALUE*, VALUE);
+extern VALUE rbgm_ttf_render_utf8(int , VALUE*, VALUE);
+extern VALUE rbgm_ttf_render_unicode(int , VALUE*, VALUE);
+ 
+#endif

data/lib/rubygame.rb

@@ -0,0 +1,41 @@
+#--
+#  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
+#++
+
+# This is the file that should be imported, it in turn imports rubygame.so
+# (which has all of the C code for rubygame) and all the other rubygame modules
+
+require "rbconfig"
+
+require "rubygame_core"
+
+%W{ rubygame_gfx rubygame_image rubygame_ttf rubygame_mixer }.each do |mod|
+  begin
+    require mod
+  rescue LoadError
+    warn( "Warning: Unable to require optional module: #{mod}.") if $VERBOSE
+  end
+end
+
+require "rubygame/color"
+require "rubygame/constants"
+require "rubygame/event"
+require "rubygame/queue"
+require "rubygame/rect"
+require "rubygame/sprite"
+require "rubygame/clock"

data/lib/rubygame/MANIFEST

@@ -0,0 +1,12 @@
+clock.rb
+constants.rb
+event.rb
+ftor.rb
+hotspot.rb
+keyconstants.rb
+MANIFEST
+mediabag.rb
+queue.rb
+rect.rb
+sfont.rb
+sprite.rb

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.rb

@@ -0,0 +1,79 @@
+#--
+#	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'
+require 'rubygame/color/models/rgb'
+require 'rubygame/color/models/hsv'
+require 'rubygame/color/models/hsl'
+
+require 'rubygame/color/palettes/palette'
+require 'rubygame/color/palettes/x11'
+require 'rubygame/color/palettes/css'
+
+module Rubygame
+
+	# The Color module contains classes related to colors.
+	# 
+	# Available color representations:
+	# 
+	# ColorRGB::  color class with red, green, and blue components.
+	# ColorHSV::  color class with hue, saturation, and value components.
+	# ColorHSL::  color class with hue, saturation, and luminosity components.
+	# 
+	# The Palette class allows you to conveniently store and access a
+	# collection of many different colors, with inheritance from
+	# included Palettes.
+	# 
+	# The available predefined palettes are:
+	# 
+	# X11::    palette with the default X11 colors
+	# CSS::    palette used with HTML and CSS, very similar to X11
+	# GLOBAL:: special palette used for automatic lookup (see below)
+	# 
+	# The GLOBAL palette is special; it is used for automatic color lookup
+	# in functions like Surface#draw_circle and TTF#render.It includes the
+	# CSS palette by default; you can include other palettes or define new
+	# custom colors in GLOBAL to make them available for automatic lookup.
+	# 
+	# For convenience, you can access the GLOBAL palette through the
+	# #[] and #[]= methods:
+	# 
+	#     include Rubygame
+	#     player_color = Color[:red]
+	#     Color[:favorite] = Color[:azure]
+	# 
+	module Color
+
+		(GLOBAL = Palette.new()).include(CSS) # :nodoc:
+		
+		# Retrieve a color from the GLOBAL palette.
+		# See Palette#[]
+		def self.[]( name )
+			GLOBAL[name]
+		end
+		
+		# Store a color in the GLOBAL palette.
+		# See Palette#[]=
+		def self.[]=( name, color )
+			GLOBAL[name] = color
+		end
+		
+	end
+end
+

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