rubygame 2.2.0-mswin32

data/NEWS

@@ -0,0 +1,201 @@
+== Changes from 2.1.0 to 2.2.0
+
+=== Features
+
+- Add: Rubygame::Color module
+  - ColorRGB, ColorHSV, and ColorHSL classes.
+  - X11 and CSS palettes of pre-defined colors.
+  - Surface methods can accept ColorRGB etc. for colors.
+  - Automatic lookup of color names when a string or symbol
+    is passed for a color to Surface methods.
+- Add: Surface#set_at().
+
+- Add: Screen#icon=().
+
+=== Bug Fixes
+
+- Fix: Surface#draw_arc was incorrectly documented as Surface#draw_pie
+
+=== Improvements
+
+- Rect#collide_rect? is now faster.
+- Sprites::Group#collide_group can take a block; arguments are deprecated.
+
+=== Other Stuff
+
+- Build system correctly recompiles if source has changed.
+- Build system option syntax has changed. See the README: Advanced Install.
+- Build system will correctly exit with an error status if it can't compile;
+  fixes Rubygems trying to install even when compile failed.
+
+=== Acknowledgements
+
+- Michael Swiger (mokkan) for Screen#icon=.
+- ippa for optimizing Rect#collide_rect?.
+
+
+
+
+== Changes from 2.0.1 to 2.1.0
+
+=== Features
+
+- Add: Mixer::Music module.
+- Add: Mixer.driver_name method.
+- Add: Depth sorting for sprites.
+- Add: Sprite#undraw.
+- Add: TTF#size_utf8 and TTF#size_unicode.
+- Add: Rubygame.key_name.
+
+=== Bug Fixes
+
+- Fix: Bug with dirty rectangles in UpdateGroup.
+- Fix: Incorrect docs for joy-hat direction value.
+- Fix: Segfaults when Joysticks are garbage-collected after Rubygame has quit.
+- Fix: Segfaults when using Surface#convert, #to_display, or #to_display_alpha
+  when no video mode has been set.
+- Fix: Surface#get_at returning [0,0,0,0] when it shouldn't.
+- Fix: Sprites::Group#collide_group behaving incorrectly (again).
+- Fix: Build system doesn't correctly handle quoted spaces in --cflags/--lflags.
+  (NOTE: Use CFLAGS/LDFLAGS environment variables now, instead.)
+
+=== Known Issues
+
+- Build system won't detect changed source files and recompile as necessary;
+  you must "rake clobber build" after a change.
+
+=== Other Stuff
+
+- Added argument checks to several Rect methods.
+- Surfaces can be created with no Screen mode set.
+- Mixer.open_audio has default values.
+- TTF style getting/setting refactored under the hood.
+- Added demo_music.rb and a sample song.ogg to try out music.
+
+=== Acknowledgements
+
+- Johan Berntsson for adding Mixer::Music.
+- Daniel Neis Araujo for adding Sprite#undraw.
+- Roger Ostrander (denor) for and bug fixes and adding Rubygame.key_name.
+- Bjorn De Meyer (beoran) for numerous patches and improvements.
+
+
+ 
+
+== Changes from 2.0.0 to 2.0.1
+
+=== Bug Fixes
+
+- Fix: Segfaults in several C methods when passed an unexpected argument type.
+- Fix: Segfaults in Screen#update and Screen#update_rects when the Rect(s)
+  extended out of the Screen bounds.
+- Fix: Ftor#magnitude= behaving incorrectly.
+- Fix: Rect#clip! behaving incorrectly.
+- Fix: Sprites::Group#collide_group behaving incorrectly.
+- Fix: Surface#savebmp wanting too many arguments.
+
+=== Other Stuff
+
+- Argument handling for C methods is now more robust under the hood.
+- C methods which expect Array arguments will now also work with objects
+  that can be converted to an Array (with #to_ary), such as Ftor.
+
+
+
+
+== Changes from 1.1.0 to 2.0.0:
+
+*NOTICE*: version 2.0.0 is not totally backward-compatible with 1.1.0.
+You may have to update existing applications to the new syntax.
+(Hence the major version number going up.)
+
+=== API Changes
+
+==== Basic audio playback with SDL_mixer
+
+- Add: Rubygame::Mixer module (basic SDL_mixer audio playback).
+- Add: Rubygame::Mixer::Sample class (load audio samples).
+
+==== Event management system revamped
+
+- Add: Rubygame.fetch_sdl_events()
+- Add: Rubygame::EventQueue class.
+- Add: Rubygame::MailQueue mixin.
+- Retire: Rubygame::Queue class.
+
+==== Surface swallows Draw, Transform, and Image methods
+
+- Updated: Rubygame::Surface class
+  - Add: Surface.load_image() (migrated from Image).
+  - Add: ##savebmp (migrated from Image).
+  - Add: ##draw_* (migrated from Draw).
+  - Add: ##rotozoom, ##zoom (migrated from Transform).
+  - Add: ##zoom_to method.
+
+- Retire: Draw module (methods merged into Surface).
+- Retire: Transform module (methods merged into Surface).
+- Retire: Image module (methods merged into Surface).
+
+==== Clock class improved
+
+- Updated: Rubygame::Clock class
+  - Clock is now directly under Rubygame (not Rubygame::Time).
+  - Clock.new() takes no arguments, but yields self if a block is given.
+  - framerate limiting with ##tick is now much more accurate.
+  - Add: Clock.runtime(), Clock.wait(), Clock.delay() (migrated from Time)
+  - Rename: ##fps to ##framerate.
+  - Rename: ##desired_fps to ##target_framerate.
+  - Rename: ##desired_mspf to ##target_frametime.
+  - Rename: ##time to ##lifetime.
+
+- Retire: Time module (methods merged into Clock).
+
+==== Experimental classes/modules
+
+- Add: Rubygame::MediaBag class.
+- Add: Rubygame::Ftor class.
+- Add: Rubygame::Hotspot mixin.
+- Change: Rubygame::SFont class must be explicitly imported
+  (require 'rubygame/sfont').
+
+==== New system for version and capability detection
+
+- Rubygame::VERSIONS: a hash table with the version numbers of rubygame, 
+  SDL, and any SDL_* libraries that were compiled in.
+- Methods which are not supported will no be defined in the namespace; 
+  formerly, they would be defined but nonfunctional (issued a warning and
+  returned nil).
+
+==== Miscellaneous other changes and additions
+
+- Add: Rubygame.quit (cleanly exit SDL; resets resolution after fullscreen).
+
+- Updated: Rubygame::Surface class
+  - Argument list for Surface.new() has changed.
+  - Add: ##clip and ##clip=.
+  - Add: ##convert, ##to_display, and ##to_display_alpha.
+
+- Updated: Rubygame::Screen class
+  - Rename: Screen.set_mode() to Screen.new().
+  - Add: Screen.set_mode() and Screen.instance() (aliases for Screen.new()).
+  - Add: ##title, ##title= (replaces ##caption and ##set_caption)
+
+- Updated: Rubygame::TTF class
+  - Add: ##render_utf8 and ##render_unicode methods.
+  - Add: ##size_text method.
+
+=== Bug Fixes
+
+- Fix several erroneous Rect methods.
+- Fix "bignum out of range of unsigned long (RangeError)" when using
+  Rubygame::FULLSCREEN.
+
+=== Other Stuff
+
+- New build/install system with Rake.
+- Split the monolithic rubygame extension into modules:
+  rubygame_core::  main SDL interface.
+  rubygame_gfx::   SDL_gfx interface.
+  rubygame_image:: SDL_image interface.
+  rubygame_mixer:: SDL_mixer interface.
+  rubygame_ttf::   SDL_ttf interface.

data/README

@@ -0,0 +1,139 @@
+ = Rubygame README
+
+ == What is Rubygame?
+
+ Rubygame is a cross-platform game-development extension and library for Ruby,
+ inspired by Pygame. The purpose of Rubygame is to empower game developers by
+ providing them with powerful and flexible high-level concepts. Instead of
+ worrying about low-level technical details, you can focus your energy on
+ more interesting things (like making a fun game).
+
+ Rubygame's core is written in C to bind low-level SDL functions in ruby.
+ On top of that is a pure ruby library for higher-level behavior like
+ event and game object management.
+
+ There are two other Ruby-SDL bindings which are worth mentioning: Ruby/SDL
+ and RUDL. Ruby/SDL is a simple wrapper which closely mirrors SDL's C API,
+ while RUDL tries to provide some high-level concepts. 
+ The main differences with Rubygame come down to a matter of priorities:
+ a great deal of care and effort goes into making Rubygame especially clean,
+ well-documented, powerful, and easy to use.
+
+ === Relevant Links
+ 1. Rubygame: http://rubygame.sourceforge.net
+ 2. Ruby: http://www.ruby-lang.org
+ 3. Pygame: http://www.pygame.org
+ 4. SDL: http://www.libsdl.org
+ 5. Ruby/SDL: http://www.kmc.gr.jp/~ohai/rubysdl.en.html
+ 6. RUDL: http://rudl.sourceforge.net
+
+ == Requirements
+
+ You will definitely need these software packages to compile Rubygame:
+
+ * ruby        >= 1.8 
+ * SDL         >= 1.2.7
+ * rake        >= 0.7.0    (for build/install system)
+
+ It's highly recommended that you have these packages as well, or some
+ cool features won't be available!
+
+ * SDL_gfx     >= 2.0.10
+ * SDL_image   >= 1.2.3
+ * SDL_mixer   >= 1.2.7
+ * SDL_ttf     >= 2.0.6
+
+ (If you don't have some of those, you have to disable those features
+ by passing some flags to the build process. See "Advanced Install", below.)
+
+ If you are compiling source on a binary-based Linux ditribution,
+ you will also need the "dev" packages of ruby, SDL, SDL_gfx, SDL_image,
+ SDL_mixer, and SDL_ttf. (Really, you just need the header files.)
+
+ And of course, if you are compiling the source, you will need a C compiler!
+ These versions of gcc worked fine when I tried them; other compilers might
+ work too:
+
+ * gcc 3.3, 3.4, 4.0, 4.1
+
+
+ == Install
+
+ === Basic Install
+
+ Extract the archive and enter its top directory.
+ Then run ($ indicates as user, # as root):
+
+  $ rake build
+  # rake install
+
+ === Advanced Install
+
+ The build and install tasks can be configured by providing certain commands
+ to rake:
+
+  * no-sdl-gfx::    do not build modules which depend on SDL_gfx
+  * no-sdl-image::  do not build modules which depend on SDL_image
+  * no-sdl-mixer::  do not build modules which depend on SDL_mixer
+  * no-sdl-ttf::    do not build modules which depend on SDL_ttf
+  * no-opengl::     do not build modules which depend on OpenGL
+
+  * no-sdl-config:: do not guess compiler/linker flags using `sdl-config'
+
+  * debug::         build modules with debbugging flags enabled
+  * verbose::       display the build commands as they are run
+
+ Additionally, the build process respects certain environmental variables.
+ In particular, CFLAGS and LDFLAGS are important for users compiling with
+ the no-sdl-config command.
+
+  * CC::            C compiler command
+  * CFLAGS::        flags passed to the C compiler
+  * LDSHARED::      linker command
+  * LDFLAGS::       flags passed to the linker
+  * RUBYARCHDIR::   where to install platform-specific compiled extensions
+  * RUBYLIBDIR::    where to install platform-independent interpreted libs
+
+ IMPORTANT: if you are missing any optional SDL_* libraries, you must specify
+ "no-*" flags for those libraries. For example, if you don't have SDL_gfx:
+
+  $ rake no-gfx build
+
+ If you don't disable the features, the compile will probably fail when it
+ looks for the headers and libraries. (The build system is not smart enough to
+ automatically disable missing features.)
+
+ === Generating documentation
+
+ You can generate documentation for Rubygame's API by running:
+
+  # rake rdoc
+
+ Documentation will be generated as HTML in the 'html' directory.
+ Open 'html/index.html' in a web browser to get started.
+
+ == Usage
+ 
+ To use Rubygame in an application, do:
+
+   require 'rubygame'
+
+ You will probably also want a display window and event queue:
+
+   screen = Rubygame::Screen.new( [640,480] )
+   queue = Rubygame::EventQueue.new()
+
+ For more information, see the documentation (online at 
+ http://rubygame.sourceforge.net, or generated locally with the 
+ 'rake rdoc' command). You should also take a peek at the demo applications
+ in the 'samples' directory.
+
+ == License
+
+ Rubygame is distributed under the terms of the GNU Lesser GPL.
+ See LICENSE for more details.
+
+ Some of the sample files are distributed under other licenses than the
+ GNU Lesser GPL. See 'samples/README' and 'samples/GPL' for more details.
+
+ John Croisant (jacius at users.sourceforge.net)

data/ROADMAP

@@ -0,0 +1,43 @@
+= ROADMAP
+
+=== 3.0.0 (next major release)
+
+- Backwards compatibility will be broken:
+  - Surface#get_at
+  - Sprites::Group#collide_group
+
+- New scene/camera/sprite sytem.
+- New geometric primitives classes (for collision detection, drawing).
+- New hook-based event handler system.
+
+- Keyboard events to be :symbols (e.g. :uparrow, :a, :spacebar)
+
+- Clock class to be based on Ruby's timer (allows multi-threading). 
+- New TickEvent returned from Clock#tick.
+
+- Change Sprites::Group#collide_group to scrap the 'killa/killb' stuff,
+  take a block instead.
+
+=== On the horizon...
+
+- Path (Curve?) (graphs/plots for tracing position and other uses)
+  - Can find the position N units along the path.
+  - Can draw a line showing the path.
+  - LinearPath (connect the dots, linear interpolation)
+  - BezierPath (chain of continuous cubic Bézier curves)
+  - CodePath (calculated from a code block)
+
+- Better support for non-US keyboards, particularly generating strings for
+  keypresses: (EURO, WORLD*). Will need someone with a non-US keyboard to
+  test this.
+
+- Flesh out Mixer API.
+
+- Flesh out Rect unit tests.
+
+- C equivalent of Rect.new_from_object (see rect.rb)
+  - Screen#update (cannot pass object with rect attribute)
+  - Screen#update_rects (same as above)
+  - Why not just call the ruby function from within C?
+
+- Generate bounding Polygon from an image automatically.

data/Rakefile

@@ -0,0 +1,409 @@
+require 'rubygems'
+Gem::manage_gems
+
+require 'rake'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+require "rbconfig"
+include Config
+
+require 'English'
+
+class ShellCommandError < RuntimeError
+end
+
+# Execute the block (which is supposed to perform a shell command),
+# then raise ShellCommandError if the command failed.
+def try_shell( &block )
+  result = yield
+  
+  unless $CHILD_STATUS.exitstatus == 0
+    raise ShellCommandError, "Command failed. Aborting."
+  end
+  
+  return result
+end
+
+def try_sdl_config( flag )
+  begin
+    if $options[:"sdl-config"]
+      return try_shell { `sdl-config #{flag}`.chomp }
+    else
+      return String.new
+    end
+  rescue ShellCommandError
+    warn "WARNING: 'sdl-config' failed."
+    warn "Continuing anyway, but compile may fail."
+    return String.new
+  end
+end
+
+# Get a variable from ENV or CONFIG, with ENV having precedence.
+# Returns "" if the variable didn't exist at all.
+def from_env_or_config(string)
+  ([ENV[string], CONFIG[string]] - ["", nil])[0] or ""
+end
+
+OBJEXT = from_env_or_config("OBJEXT")
+DLEXT = from_env_or_config("DLEXT")
+
+RUBYGAME_VERSION = "2.2.0"
+
+spec = Gem::Specification.new do |s|
+  s.name     = "rubygame"
+  s.version  = RUBYGAME_VERSION
+  s.author   = "John Croisant"
+  s.email    = "jacius@users.sourceforge.net"
+  s.homepage = "http://rubygame.sourceforge.net/"
+  s.summary  = "Clean and powerful library for game programming"
+  s.has_rdoc = true
+
+  s.files = FileList.new do |fl|
+    fl.include("{lib,ext,samples,doc}/**/*")
+    fl.exclude(/svn/)
+    #fl.exclude(/\.#{OBJEXT}/)
+  end
+
+  s.require_paths = ["lib", "lib/rubygame/", "ext/rubygame/"]
+  s.autorequire = "rubygame.rb"
+  s.extensions = ["Rakefile"]
+
+  s.extra_rdoc_files = FileList.new do |fl|
+    fl.include "doc/*.rdoc"
+    fl.include "README", "LICENSE", "CREDITS", "ROADMAP", "NEWS"
+  end
+end
+
+task :linux do
+	spec.platform = Gem::Platform::LINUX_586
+end
+
+task :macosx do
+	spec.platform = Gem::Platform::DARWIN
+end
+
+task :win32 do
+	spec.platform = Gem::Platform::WIN32
+end
+
+Rake::GemPackageTask.new(spec) do |pkg| 
+  pkg.need_tar_bz2 = true
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README"
+  rd.title = "Rubygame #{RUBYGAME_VERSION} Docs"
+  rd.rdoc_files.include("ext/rubygame/*.c",
+                        "lib/rubygame/**/*.rb",
+                        "doc/*.rdoc",
+                        "README",
+                        "LICENSE",
+                        "CREDITS",
+                        "ROADMAP",
+                        "NEWS")
+end
+
+task :default => [:build]
+desc "Compile all of the extensions"
+task :build
+
+require 'rake/clean'
+task(:clean) { puts "Cleaning out temporary generated files" }
+task(:clobber) { puts "Cleaning out final generated files" }
+
+##############################
+##      BUILD  OPTIONS      ##
+##############################
+
+$options = {
+	:"sdl-gfx"    => true,
+	:"sdl-image"  => true,
+	:"sdl-ttf"    => true,
+	:"sdl-mixer"  => true,
+	:opengl       => true,
+	:"sdl-config" => true,
+	:debug        => false,
+	:verbose      => false,
+	:sitearchdir  => CONFIG["sitearchdir"],
+	:sitelibdir   => CONFIG["sitelibdir"]
+}
+
+# Default behavior for win32 is to skip sdl_config,
+# since it's usually not available. It can still be
+# enabled through the options, though.
+if PLATFORM =~ /win32/
+	$options[:"sdl-config"] = false
+end
+
+# Define tasks to enable and disable bool options.
+# 
+#     rake option
+#     rake no-option
+# 
+#   task_name::   the task name to use
+#   option_name:: the option name (if different from
+#                 the task name)
+#   desc::        a longer description, to fill
+#                 "Enable ________.", if different
+#                 from the task name.
+# 
+def bool_option( task_name, option_name=nil, desc=nil )
+	option_name = task_name unless option_name
+	option_name = option_name.intern if option_name.kind_of? String
+
+	desc = task_name.to_s unless desc
+  
+	notask_name = "no-#{task_name.to_s}".intern
+
+	is_true = $options[option_name]
+	
+	desc "Enable #{desc} #{'(default)' if is_true}"
+	task(task_name)   { $options[option_name] = true  }
+
+	desc "Disable #{desc} #{'(default)' unless is_true}"
+	task(notask_name) { $options[option_name] = false }
+end
+
+# Gather a string option from an environment variable:
+# 
+#     rake option="the value of the option"
+# 
+#   task_name::   the task name to use
+#   option_name:: the option name (if different from
+#                 the task name)
+# 
+def string_option( task_name, option_name=nil )
+	option_name = task_name unless option_name
+	option_name = option_name.intern if option_name.kind_of? String
+
+	$options[option_name] = ENV["#{task_name}"] if ENV["#{task_name}"]
+end
+
+bool_option :"sdl-gfx",    nil,  "SDL_gfx support"
+bool_option :"sdl-image",  nil,  "SDL_image support"
+bool_option :"sdl-mixer",  nil,  "SDL_mixer support"
+bool_option :"sdl-ttf",    nil,  "SDL_ttf support"
+bool_option :"sdl-config", nil,  "guess compiler flags for SDL"
+bool_option :opengl,       nil,  "OpenGL support"
+bool_option :debug,        nil,  "compil with debug symbols"
+bool_option :verbose,      nil,  "show compiler commands"
+
+string_option "RUBYARCHDIR", :sitearchdir
+string_option :sitearchdir
+
+string_option "RUBYLIBDIR", :sitelibdir
+string_option :sitelibdir
+
+
+CFLAGS = [from_env_or_config("CFLAGS"),
+          try_sdl_config("--cflags"),
+          "-I. -I#{CONFIG['topdir']}",
+          ("-g" if $options[:debug]) ].join(" ")
+
+LINK_FLAGS = [from_env_or_config("LIBRUBYARG_SHARED"),
+              from_env_or_config("LDFLAGS"),
+              try_sdl_config("--libs")].join(" ")
+
+DEFAULT_EXTDIR = File.join('ext','rubygame','')
+
+class ExtensionModule
+  @@libflag = " -l%s " # compiler flag for giving linked libraries
+  attr_accessor :dynlib, :objs, :libs, :cflags, :lflags, :directory
+  def initialize(&block)
+    @directory = DEFAULT_EXTDIR
+    @dynlib = ""
+    @objs = []
+    @libs = []
+    @lflags = ""
+    yield self if block_given?
+  end
+
+  def add_lib( lib )
+    @lflags << @@libflag%lib
+  end
+
+  def add_header( header )
+    #CFLAGS << " -DHAVE_#{header.upcase.gsub('.','_')} "
+  end
+
+  def create_all_tasks()
+    create_obj_task
+    create_dl_task
+    CLEAN.include("#{@directory}/*.#{OBJEXT}")
+    CLOBBER.include("#{@directory}/*.#{DLEXT}")
+  end
+
+  # Create a file task for each dynamic library (.so) we want to generate.
+  # 
+  # The file task invokes another task which does the actual compiling, and
+  # has the true prerequisites.
+  # 
+  # This is done so that the prerequisites don't have to be compiled when 
+  # the final product already exists (such as in the precompiled win32 gem).
+	# 
+  def create_dl_task
+    dynlib_full  = File.join( @directory, "#{dynlib}.#{DLEXT}" )
+    objs_full = @objs.collect { |obj|
+      File.join( @directory, "#{obj}.#{OBJEXT}" )
+    }
+
+    desc "Compile the #{@dynlib} extension"
+    file dynlib_full => objs_full do |task|
+      link_command = "#{from_env_or_config('LDSHARED')} #{LINK_FLAGS} #{@lflags} -o #{dynlib_full} #{task.prerequisites.join(' ')}"
+      if( $options[:verbose] )
+        try_shell { sh link_command }
+      else
+        puts "Linking compiled files to create #{File.basename(@directory)}/#{File.basename(dynlib_full)}"
+        try_shell { `#{link_command}` }
+      end
+    end
+
+    task :build => [dynlib_full]   # Add this as a prereq of the build
+    task :install_ext => [dynlib_full] # ...and install_ext tasks
+  end
+
+  def create_obj_task
+    # A rule for object files (".o" on linux).
+    # This won't work for rake < 0.7.2, because the proc returns an Array.
+    # If it raises an exception, we'll try a more compatible way.
+    rule(/#{@directory}.+\.#{OBJEXT}$/ =>
+         [
+          # Generate dependencies for this .o file
+          proc do |objfile|
+            source = objfile.sub(".#{OBJEXT}", ".c") # the .c file
+            [source] + depends_headers( source ) # Array of .c + .h dependencies
+          end
+         ])\
+    do |t|
+      compile_command = "#{from_env_or_config('CC')} -c #{CFLAGS} #{t.source} -o #{t.name}"
+      if( $options[:verbose] )
+        try_shell { sh compile_command }
+      else
+        puts "Compiling #{File.basename(@directory)}/#{File.basename(t.source)}"
+        try_shell { `#{compile_command}` }
+      end
+    end
+  rescue
+    # Generate a .o rule for each .c file in the directory.
+    FileList.new("#{@directory}*.c").each do |source|
+      object = source.sub(".c", ".#{OBJEXT}")
+      file object => ([source] + depends_headers( source )) do |t|
+        compile_command = "#{CONFIG['CC']} -c #{CFLAGS} #{source} -o #{t.name}"
+        if( $options[:verbose] )
+          try_shell { sh compile_command }
+        else
+          puts "Compiling #{File.basename(@directory)}/#{File.basename(source)}"
+          try_shell { `#{compile_command}` }
+        end
+      end
+    end
+  end
+
+  # Extracts the names of all the headers that the C file depends on.
+  def depends_headers( filename )
+    return []                   # workaround for a bug
+    depends = []
+    File.open(filename, "r") do |file|
+      file.each_line do |line|
+        if /#include\s+"(\w+\.h)"/ =~ line
+          depends << @directory+$1
+        end
+      end
+    end
+    return depends
+  end
+end
+
+rubygame_core = ExtensionModule.new do |core|
+  core.dynlib = 'rubygame_core'
+  core.objs = ['rubygame_main',
+               'rubygame_shared',
+               'rubygame_event',
+               'rubygame_gl',
+               'rubygame_joystick',
+               'rubygame_screen',
+               'rubygame_surface',
+               'rubygame_time',
+              ]
+  core.create_all_tasks()
+end
+
+# TODO: We should check if the libraries exist?
+
+rubygame_gfx = ExtensionModule.new do |gfx|
+  gfx.dynlib = 'rubygame_gfx'
+  gfx.objs = ['rubygame_shared', 'rubygame_gfx']
+  gfx.add_lib( 'SDL_gfx' )
+  gfx.add_header( 'SDL_gfxPrimitives.h')
+  gfx.add_header( 'SDL_rotozoom.h' )
+  gfx.create_all_tasks() if $options[:"sdl-gfx"]
+end
+
+rubygame_image = ExtensionModule.new do |image|
+  image.dynlib = 'rubygame_image'
+  image.objs = ['rubygame_shared', 'rubygame_image']
+  image.add_lib('SDL_image')
+  image.add_header('SDL_image.h')
+  image.create_all_tasks() if $options[:"sdl-image"]
+end
+
+rubygame_mixer = ExtensionModule.new do |mixer|
+  mixer.dynlib = 'rubygame_mixer'
+  mixer.objs = ['rubygame_shared', 'rubygame_mixer']
+  mixer.add_lib('SDL_mixer')
+  mixer.add_header('SDL_mixer.h')
+  mixer.create_all_tasks() if $options[:"sdl-mixer"]
+end
+
+rubygame_ttf = ExtensionModule.new do |ttf|
+  ttf.dynlib = 'rubygame_ttf'
+  ttf.add_lib('SDL_ttf')
+  ttf.objs = ['rubygame_shared', 'rubygame_ttf']
+  ttf.add_header('SDL_ttf.h')
+  ttf.create_all_tasks() if $options[:"sdl-ttf"]
+end
+
+if $options[:opengl]
+  CFLAGS << " -DHAVE_OPENGL "
+end
+
+desc "(Called when installing via Rubygems)"
+task :extension => [:fix_filenames, :build]
+
+task :fix_filenames do
+	unless DLEXT == 'so'
+		Rake::Task[:install_ext].prerequisites.each do |prereq|
+			prereq = prereq.ext('so')
+			if File.exist? prereq
+				mv prereq, prereq.ext(DLEXT)
+			end
+		end
+	end
+end
+
+desc "Install just the extensions"
+task :install_ext do |task|
+  puts "Installing extensions to #{$options[:sitearchdir]}"
+  mkdir_p $options[:sitearchdir]
+  cp task.prerequisites.to_a, $options[:sitearchdir]
+end
+
+desc "Install just the library"
+task :install_lib do |task|
+  puts "Installing library to #{$options[:sitelibdir]}"
+
+  files = FileList.new do |fl|
+    fl.include("lib/**/*.rb")
+    fl.exclude(/svn/)
+  end
+
+  files.each do |f|
+    dir = File.join($options[:sitelibdir], File.dirname(f).sub('lib',''), "")
+    mkdir_p dir
+    cp f, dir
+  end
+end
+
+desc "Install both the extensions and the library"
+task :install => [:install_ext, :install_lib]