rubygame 2.2.0-i586-linux

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]

data/doc/extended_readme.rdoc

@@ -0,0 +1,49 @@
+ = Extended README
+
+ (Stuff that didn't make it into the main README file.)
+
+ == Internal structure of Rubygame
+
+ Rubygame's core is a low-level extension written in C; it
+ provides a basic interface to SDL and its companion libraries.
+ Building upon that is a ruby library which implements high-level
+ concepts like game objects, event management, etc.
+
+ Rubygame is modular, meaning you can pick and choose which parts to use.
+ For example, if you don't need TrueType font support, SDL_ttf is not
+ required to compile Rubygame. It is possible for a game to detect at
+ run-time which features are present, and behave accordingly (for example,
+ the game might disable certain optional features).
+
+ Rubygame is multi-tiered, meaning you can access Rubygame's functionality
+ on a number of levels, each level being built on the level below it. 
+ Each higher level is closer to a complete game, but is also less flexible.
+ The idea here is that developers will use the higher levels most of the
+ time, but be free to hack lower levels when they need to do something
+ special.
+
+ == About the version number
+
+ The version number of Rubygame has a strict meaning, to help you decide
+ whether the new version might break your application. The version number has
+ 3 parts: the major version number, the minor version number, and the patch
+ number. For the example of Rubygame 2.0.0:
+
+     2   .   0   .   0
+   MAJOR . MINOR . PATCH
+
+ When a new release of Rubygame is made, one of the version numbers will
+ go up, and the numbers that come after it will be reset to 0. Which number
+ will go up depends on how much the Rubygame API changed:
+
+ - *MAJOR*: API has changed, and old apps must be updated.
+   An example of this is when a class has been significantly changed, or a
+   method has renamed/moved to another module and the old name is removed.
+
+ - *MINOR*: API has changed, but old apps will still work.
+   An example of this is when a new feature has been added, or a
+   method has been renamed but the old name is still supported.
+
+ - *PATCH*: API has not changed at all.
+   An example of this is when a bug has been fixed, or existing code has 
+   been improved beneath the surface.

data/doc/getting_started.rdoc

@@ -0,0 +1,47 @@
+= Getting Started with Rubygame
+
+== About Rubygame
+
+Rubygame is a combination extension and library for the Ruby language,
+designed for creating computer games (and having fun doing it!).
+As an extension, it provides an interface to the Simple DirectMedia Library
+(SDL) and its companion libraries SDL_gfx, SDL_image, SDL_ttf, and SDL_mixer.
+As a Ruby library, it provides classes/modules which implement some useful
+concepts such as Sprites, Event Queues, and rasterized fonts (SFont).
+
+== Suggested Order
+
+To get acquainted with Rubygame, we recommend exploring the available classes
+and modules in this order.
+
+First, take a look at the most fundamental classes: 
+- Rubygame::Screen (the display window, what the user sees)
+- Rubygame::Surface (stores image data which can be copied to the Screen)
+- Rubygame::Rect (stores a rectangular area, like part of the Screen)
+
+As a next step, read about the event Queue and the hardware events, which
+allow you to take keyboard and mouse input, among other things.
+- Rubygame::EventQueue (stores events for processing)
+- Rubygame::KeyDownEvent (keyboard button is pressed)
+- Rubygame::KeyUpEvent (keyboard button is released)
+- Rubygame::MouseDownEvent (mouse button is clicked)
+- Rubygame::MouseUpEvent (mouse button is released)
+- Rubygame::MouseMotionEvent (mouse cursor is moved)
+- Rubygame::QuitEvent (user tries to close the window)
+- Rubygame::JoyDownEvent (joystick button is pressed)
+- Rubygame::JoyUpEvent (joystick button is released)
+- Rubygame::JoyAxisEvent (joystick axis is moved)
+- Rubygame::JoyBallEvent (joystick trackball is moved)
+- Rubygame::JoyHatEvent (joystick 8-directional hat switch is moved)
+- Rubygame::ActiveEvent (the Screen gets keyboard and/or mouse focus)
+- Rubygame::ResizeEvent (the Screen is resized)
+- Rubygame::ExposeEvent (the Screen is redrawn, mostly for OpenGL)
+
+Finally, familiarize yourself with:
+- Rubygame::Clock for monitoring and controlling framerate to save resources
+- Rubygame::Sprites for an easy-to-use yet flexible on-screen object framework
+- Rubygame::TTF and Rubygame::SFont for rendering text
+- Rubygame::GL for hardware-accelerated 3D graphics with OpenGL
+
+There are several sample applications in the rubygame/samples/ directory
+packaged with Rubygame which can also help you get started.

data/doc/macosx_install.rdoc

@@ -0,0 +1,70 @@
+= How to install Rubygame on Mac OS X
+
+This is an outline of the steps to compile and use Rubygame on Mac OS X!
+
+== Installing dependencies...
+
+You have two options for installing the software libraries that Rubygame
+depends on: Darwinports or Fink. Which option you choose is just a matter of
+preference.
+
+=== ...with Darwinports[http://darwinports.opendarwin.org/]
+
+
+1. {Install darwinports}[http://darwinports.opendarwin.org/getdp/]
+2. Open a new terminal (can be found in /Applications/Utilities).
+3. Install SDL: 
+
+    sudo port install libsdl
+
+4. (Optional, but *highly* recommended:) Install the SDL companion 
+   libraries: 
+
+    sudo port install libsdl_gfx libsdl_image libsdl_mixer libsdl_ttf
+
+=== ...with Fink[http://www.finkproject.org/]
+
+1. {Install Fink}[http://www.finkproject.org/download/index.php?phpLang=en]
+   and update to the latest version.
+2. Open a new terminal (can be found in /Applications/Utilities).
+3. Install SDL:
+
+    sudo apt-get install sdl
+
+4. (Optional, but *highly* recommended:) Install the SDL companion
+   libraries:
+
+    sudo apt-get install sdl-gfx13 sdl-image sdl-mixer sdl-ttf
+
+== Installing rsdl
+
+In order to use Rubygame applications on Mac OS X, you must use a special wrapper for the ruby interpreter, called rsdl.
+
+1. {Download and unpack rsdl}[http://www.kumaryu.net/?c=plugin;plugin=attach_download;p=%28Ruby%29+Ruby%2FSDL%CD%D1ruby;file_name=rsdl.tar.gz].
+2. From within the rsdl directory:
+
+    make
+    sudo cp rsdl /usr/local/bin/
+    
+
+== Installing Rubygame
+1. {Download and unpack Rubygame}[https://sourceforge.net/project/showfiles.php?group_id=172781].
+2. From within the rubygame directory:
+
+    sudo rake install
+
+3. Please refer to the README file for options that you can pass to setup.rb
+   or rake (depending on your version of Rubygame)
+
+== Running an application
+
+If all went well, you can now run Rubygame applications like so: 
+<code>rsdl a_rubygame_app.rb</code>
+
+If something bad happened along the way, you can {submit a support request}[https://sourceforge.net/tracker/?func=add&group_id=172781&atid=862995]
+and we'll try to help! Be sure to include plenty of details and paste any error
+messages that occur (plus a good bit of the text right before the error
+messages).
+
+(Many thanks to Raffael Mancini (sepisultrum) and Matt Crinklaw for
+instructions to install dependencies with darwinports and fink, respectively.)

data/doc/windows_install.rdoc

@@ -0,0 +1,123 @@
+= Compiling Rubygame on Windows
+
+(For the most up-to-date version of this document, see the Rubygame wiki:
+http://rubygame.wiki.sourceforge.net/win32_compile)
+
+This document gives some helpful guidelines to for compiling and installing
+Rubygame on Microsoft Windows. However, these instructions are not perfect,
+so they might not work for you. If you use this guide, we'd love to hear about
+what worked and what didn't; just send a message to the {rubygame-users mailing
+list}[https://sourceforge.net/mail/?group_id=172781]!
+
+The usual caveats apply: follow these instructions at your own risk and so
+forth.  Please direct comments or questions to the {Rubygame user's mailing
+list}[http://sourceforge.net/mail/?group_id=172781].
+
+== Step 1: Gather Dependencies
+
+- You'll need a build environment for Windows. In this guide, we'll use 
+  {MinGW}[http://www.mingw.org/MinGWiki/index.php/GettingStarted].  
+  - Grab MinGW-NNN.exe (e.g. MinGW-5.12.exe) from the {downloads page}[http://sourceforge.net/project/showfiles.php?group_id=2435&package_id=82721]
+    and install it. (Note: you might need to expand the "MinGW" section to see
+    the MinGW-NNN.exe files.)
+  - Optional, but recommended: install MSYS-NNNN.exe (e.g. MSYS-1.0.10.exe)
+    from the same page as above. (You might have to expand the MSYS section.)
+  - Add the full path to the compiler executible to your system PATH if it 
+    isn't there already.  You should be able to type <code>gcc -v</code> at a
+    command line and see a version number.
+
+- {Download Ruby}[http://www.ruby-lang.org/en/downloads/], the language itself.
+  The easiest option here is the one-click installer.  This will install
+  Ruby and a number of useful libraries without any hassle.
+
+- {SDL}[http://www.libsdl.org/download-1.2.php]. In the <b>Development 
+  Libraries</b> section (near the bottom of the page), grab the 
+  SDL-devel-1.2.??-VC6.zip file. (The VC6 package is just fine, even though
+  we're using with MinGW to compile.)
+
+The rest are optional dependencies, but highly recommended. If you don't have
+them, you won't be able to use certain features of Rubygame.
+
+- {SDL_image}[http://www.libsdl.org/projects/SDL_image/]. Grab the Win32 
+  binary package with 'devel' in the name.
+- {SDL_mixer}[http://www.libsdl.org/projects/SDL_mixer/]. Just like before,
+  grab the Win32 binary package with 'devel' in the name.
+- {SDL_ttf}[http://www.libsdl.org/projects/SDL_ttf/]. Again, get the
+  Win32 binary package with 'devel' in the name
+- {SDL_gfx}[http://www.ferzkopp.net/joomla/content/view/19/14/].  This is
+  the trickiest dependency, because there is currently no official package for
+  a precompiled version of SDL_gfx. If you are able to compile this yourself,
+  great! Otherwise, some nice features of Rubygame have to be disabled;
+  make sure you add the --no-gfx flag when you get to the "Set up environment
+  variables" section, below.
+
+Once you have downloaded everything, extract each archive into a convenient
+location on your hard drive.  You'll thank yourself later if you use a short
+path with no spaces in it.  For this example, we'll unzip everything under 
+<code>C:\\src\\</code>.
+
+Next, copy the *.dll file from each library's folder into 
+<code>C:\\windows\\system32\\</code>.
+This will allow the libraries to be detected properly later on.
+
+== Step 2: Get Rubygame
+
+If you haven't already, download the latest Rubygame source from the 
+{download page}[http://sourceforge.net/project/showfiles.php?group_id=172781]. 
+If you're feeling adventurous, you could try the in-development code from
+the {Subversion repository}[http://sourceforge.net/svn/?group_id=172781].  
+You can decompress the .tar.bz2 file with either MSYS' <code>tar</code>
+(<code>tar xvjf rubygame-2.0.0.tar.bz2</code>) or a program like 
+{7zip}[http://www.7-zip.org].
+
+Extract the source into another folder of your choice, such as 
+<code>C:\\src\\rubygame</code>.
+
+== Step 3: Set up environment variables
+
+Environment variables are used to configure the build process for your
+system; it helps the compiler to locate the headers and libraries it needs to
+compile Rubygame. 
+
+Create a text file in your Rubygame directory called "envsetup.bat".
+In it, use code based on the following to set your variables.
+Be sure to replace '\src\' (lines 3-7) with the path to where you unpacked
+the libraries.
+
+ set CC=gcc
+ set CFLAGS=-DHAVE_ISINF -D_MSC_VER=1200 
+ set CFLAGS=%CFLAGS% -I \src\SDL-1.2.11\include
+ set CFLAGS=%CFLAGS% -I \src\SDL_gfx-2.0.15
+ set CFLAGS=%CFLAGS% -I \src\SDL_image-1.2.5\include
+ set CFLAGS=%CFLAGS% -I \src\SDL_mixer-1.2.7\include
+ set CFLAGS=%CFLAGS% -I \src\SDL_ttf-2.0.8\include
+ 
+ set LDSHARED=gcc -shared
+ set LINK_FLAGS=-L \windows\system32 -lSDL
+ set LIBRUBYARG_SHARED=-L \ruby\bin -lmsvcrt-ruby18
+
+The -L parameter for LIBRUBYARG_SHARED may be different if you installed
+Ruby to a path other than C:/ruby.
+
+== Step 4: Compile and install Rubygame
+
+Open a command prompt and navigate to the root of your Rubygame source
+directory.  Type:
+
+ envsetup.bat
+ rake install
+
+IMPORTANT: If you are missing an optional library (such as SDL_gfx), you must
+disable optional features by passing a "no-???" command to rake before the word
+"install". For example, to disable features that depend on SDL_gfx, you would
+type this instead of the above:
+
+ envsetup.bat
+ rake no-gfx install
+
+If all goes well, you have built and installed Rubygame.
+Try to execute <code>require 'rubygame'</code> in an irb session and run
+the provided samples to ensure that everything is acceptable.
+
+(Thanks to Ash Wilson (smashwilson) for contributing the original version of 
+these instructions.)