gosu 0.7.10.1

data/GosuImpl/X11vroot.h

@@ -0,0 +1,118 @@
+/*****************************************************************************/
+/**                   Copyright 1991 by Andreas Stolcke                     **/
+/**               Copyright 1990 by Solbourne Computer Inc.                 **/
+/**                          Longmont, Colorado                             **/
+/**                                                                         **/
+/**                           All Rights Reserved                           **/
+/**                                                                         **/
+/**    Permission to use, copy, modify, and distribute this software and    **/
+/**    its documentation  for  any  purpose  and  without  fee is hereby    **/
+/**    granted, provided that the above copyright notice appear  in  all    **/
+/**    copies and that both  that  copyright  notice  and  this  permis-    **/
+/**    sion  notice appear in supporting  documentation,  and  that  the    **/
+/**    name of Solbourne not be used in advertising                         **/
+/**    in publicity pertaining to distribution of the  software  without    **/
+/**    specific, written prior permission.                                  **/
+/**                                                                         **/
+/**    ANDREAS STOLCKE AND SOLBOURNE COMPUTER INC. DISCLAIMS ALL WARRANTIES **/
+/**    WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF    **/
+/**    MERCHANTABILITY  AND  FITNESS,  IN  NO  EVENT SHALL ANDREAS STOLCKE  **/
+/**    OR SOLBOURNE BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL    **/
+/**    DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA   **/
+/**    OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER    **/
+/**    TORTIOUS ACTION, ARISING OUT OF OR IN  CONNECTION  WITH  THE  USE    **/
+/**    OR PERFORMANCE OF THIS SOFTWARE.                                     **/
+/*****************************************************************************/
+/*
+ * vroot.h -- Virtual Root Window handling header file
+ *
+ * This header file redefines the X11 macros RootWindow and DefaultRootWindow,
+ * making them look for a virtual root window as provided by certain `virtual'
+ * window managers like swm and tvtwm. If none is found, the ordinary root
+ * window is returned, thus retaining backward compatibility with standard
+ * window managers.
+ * The function implementing the virtual root lookup remembers the result of
+ * its last invocation to avoid overhead in the case of repeated calls
+ * on the same display and screen arguments. 
+ * The lookup code itself is taken from Tom LaStrange's ssetroot program.
+ *
+ * Most simple root window changing X programs can be converted to using
+ * virtual roots by just including
+ *
+ * #include <X11/vroot.h>
+ *
+ * after all the X11 header files.  It has been tested on such popular
+ * X clients as xphoon, xfroot, xloadimage, and xaqua.
+ * It also works with the core clients xprop, xwininfo, xwd, and editres
+ * (and is necessary to get those clients working under tvtwm).
+ * It does NOT work with xsetroot; get the xsetroot replacement included in
+ * the tvtwm distribution instead.
+ *
+ * Andreas Stolcke <stolcke@ICSI.Berkeley.EDU>, 9/7/90
+ * - replaced all NULL's with properly cast 0's, 5/6/91
+ * - free children list (suggested by Mark Martin <mmm@cetia.fr>), 5/16/91
+ * - include X11/Xlib.h and support RootWindowOfScreen, too 9/17/91
+ */
+
+#ifndef _VROOT_H_
+#define _VROOT_H_
+
+#include <X11/X.h>
+#include <X11/Xatom.h>
+#include <X11/Xlib.h>
+
+static Window
+VirtualRootWindowOfScreen(Screen* screen)
+{
+	static Screen *save_screen = (Screen *)0;
+	static Window root = (Window)0;
+
+	if (screen != save_screen) {
+		Display *dpy = DisplayOfScreen(screen);
+		Atom __SWM_VROOT = None;
+		int i;
+		Window rootReturn, parentReturn, *children;
+		unsigned int numChildren;
+
+		root = RootWindowOfScreen(screen);
+
+		/* go look for a virtual root */
+		__SWM_VROOT = XInternAtom(dpy, "__SWM_VROOT", False);
+		if (XQueryTree(dpy, root, &rootReturn, &parentReturn,
+				 &children, &numChildren)) {
+			for (i = 0; i < numChildren; i++) {
+				Atom actual_type;
+				int actual_format;
+				unsigned long nitems, bytesafter;
+				Window *newRoot = (Window *)0;
+
+				if (XGetWindowProperty(dpy, children[i],
+					__SWM_VROOT, 0, 1, False, XA_WINDOW,
+					&actual_type, &actual_format,
+					&nitems, &bytesafter,
+					(unsigned char **) &newRoot) == Success
+				    && newRoot) {
+				    root = *newRoot;
+				    break;
+				}
+			}
+			if (children)
+				XFree((char *)children);
+		}
+
+		save_screen = screen;
+	}
+
+	return root;
+}
+
+#undef RootWindowOfScreen
+#define RootWindowOfScreen(s) VirtualRootWindowOfScreen(s)
+
+#undef RootWindow
+#define RootWindow(dpy,screen) VirtualRootWindowOfScreen(ScreenOfDisplay(dpy,screen))
+
+#undef DefaultRootWindow
+#define DefaultRootWindow(dpy) VirtualRootWindowOfScreen(DefaultScreenOfDisplay(dpy))
+
+#endif /* _VROOT_H_ */

data/README.txt

@@ -0,0 +1,13 @@
+Moin moin, dear Gosu user!
+
+* The latest documentation on how to install/set up Gosu can be found on:
+    http://code.google.com/p/gosu/wiki/DocsOverview
+
+* Try doing the tutorial there if you don't know how to start out!
+
+* If you have any questions or feedback,
+    leave a comment on one of Gosu's wiki page,
+    mail me at julian@raschke.de,
+    or try your luck in #gosu on irc.freenode.org.
+
+We hope you'll enjoy using Gosu!

data/Rakefile

@@ -0,0 +1,178 @@
+require 'ftools'
+require 'rake/gempackagetask'
+
+GOSU_VERSION = ENV['GOSU_RELEASE_VERSION']
+throw "GOSU_RELEASE_VERSION must be set" if GOSU_VERSION.nil?
+
+COMMON_FILES = FileList[
+  'COPYING.txt',
+  'README.txt',
+]
+
+COMMON_CPP_FILES = COMMON_FILES + FileList[
+  'examples/*.cpp',
+  'examples/media/*',
+  'reference/**/*',
+]
+
+COMMON_RUBY_FILES = COMMON_FILES + FileList[
+  'examples/*.rb',
+  'examples/media/*',
+]
+
+SOURCE_FILES = COMMON_CPP_FILES + COMMON_RUBY_FILES + FileList[
+  'Rakefile',
+  'Gosu/**/*', 'GosuImpl/**/*',
+  'linux/configure', 'linux/configure.ac', 'linux/Makefile.in',
+  'mac/Gosu.xcodeproj/**/*', 'mac/*.a', 'mac/English.lproj/**/*',
+  'mac/Gosu-Info.plist', 'mac/RubyGosu Template-Info.plist',
+  'windows/*.*',
+]
+SOURCE_FILES.uniq!
+
+# Sets everything except 'platform' and 'files'.
+def apply_gemspec_defaults s
+  #### Basic information.
+  s.name = 'gosu'
+  s.version = GOSU_VERSION
+  s.summary = '2D game development library.'
+  s.description = <<EOS
+  2D game development library.
+
+  Gosu features easy to use and game-friendly interfaces to 2D graphics
+  and text (accelerated by 3D hardware), sound samples and music as well as
+  keyboard, mouse and gamepad/joystick input.
+
+  Also includes demos for integration with RMagick, Chipmunk and Ruby-OpenGL.
+EOS
+  s.authors = ['Julian Raschke', 'Jan Luecker']
+  s.date = Time.now.strftime '%Y-%m-%d'
+  s.email = 'julian@raschke.de'
+  s.homepage = 'http://code.google.com/p/gosu/'
+  s.require_paths = ['lib']
+  s.required_ruby_version = Gem::Requirement.new('>= 1.8.2')
+  s.summary = '2D game development library.'
+end
+
+desc "Build C++ reference with doxygen"
+task :cpp_docs do
+  sh "cd reference && doxygen"
+end
+
+Rake.application.in_namespace :mac do
+  desc "Build Gosu.framework"
+  task :cpp => :cpp_docs do
+    sh "cd mac && xcodebuild -project Gosu.xcodeproj -target Gosu -configuration Release"
+  end
+
+  desc "Build lib/gosu.bundle and RubyGosu Deployment Template.app"
+  task :ruby do
+    sh "cd mac && xcodebuild -project Gosu.xcodeproj -target 'RubyGosu Core' -configuration Release"
+    sh "cd mac && xcodebuild -project Gosu.xcodeproj -target 'RubyGosu Deployment Template' -configuration Release"
+  end
+
+  MAC_ARCHIVE_FILENAME = "public/gosu-mac-#{GOSU_VERSION}.tar.gz"
+
+  desc "Build the archive #{MAC_ARCHIVE_FILENAME}"
+  task :archive => [:cpp, :ruby] do
+    files = COMMON_CPP_FILES + COMMON_RUBY_FILES + ['lib/gosu.bundle'] +
+            FileList['Gosu.framework/**/*', 'RubyGosu Deployment Template.app/**/*']
+    sh "tar -czf #{MAC_ARCHIVE_FILENAME} #{files.map { |filename| "'#{filename}'" }.join(' ')}"
+  end
+
+  desc "Releases the archive #{MAC_ARCHIVE_FILENAME} on GoogleCode"
+  task :release => :archive do
+    sh "./googlecode_upload.py --summary=\"Gosu #{GOSU_VERSION}, compiled for Mac OS X (C++ & Ruby)\"" +
+       " --project=gosu --user=julianraschke --labels=\"Featured,Type-Archive,OpSys-OSX\" #{MAC_ARCHIVE_FILENAME}"
+  end
+
+  task :gem => :ruby
+
+  MAC_SPEC = Gem::Specification.new do |s|
+    apply_gemspec_defaults s
+    s.platform = 'universal-darwin'
+    s.files = COMMON_RUBY_FILES + ['lib/gosu.bundle']
+  end
+  Rake::GemPackageTask.new(MAC_SPEC) { |t| t.package_dir = 'public/mac_gem' }
+end
+
+Rake.application.in_namespace :win do
+  WINDOWS_CPP_ARCHIVE_FILENAME = "public/gosu-windows-cpp-#{GOSU_VERSION}.zip"
+  
+  desc "Build the archive #{WINDOWS_CPP_ARCHIVE_FILENAME}"
+  task :cpp_archive do #=> [:cpp] do
+    files = COMMON_CPP_FILES + ['lib/Gosu.lib', 'lib/GosuDebug.lib', 'lib/fmod.dll']
+    sh "zip #{WINDOWS_CPP_ARCHIVE_FILENAME} #{files.map { |filename| "'#{filename}'" }.join(' ')}"
+  end
+
+  desc "Releases the archive #{WINDOWS_CPP_ARCHIVE_FILENAME} on GoogleCode"
+  task :cpp_release => :cpp_archive do
+    sh "./googlecode_upload.py --summary=\"Gosu #{GOSU_VERSION}, compiled for 32-bit Windows (C++)\"" +
+       " --project=gosu --user=julianraschke --labels=\"Featured,Type-Archive,OpSys-Windows\" #{WINDOWS_CPP_ARCHIVE_FILENAME}"
+  end
+
+  WINDOWS_RUBY_ARCHIVE_FILENAME = "public/gosu-windows-ruby-#{GOSU_VERSION}.zip"
+
+  desc "Build the archive #{WINDOWS_RUBY_ARCHIVE_FILENAME}"
+  task :ruby_archive do #=> [:ruby] do
+    files = COMMON_RUBY_FILES + ['lib/gosu.so', 'lib/fmod.dll']
+    sh "zip #{WINDOWS_RUBY_ARCHIVE_FILENAME} #{files.map { |filename| "'#{filename}'" }.join(' ')}"
+  end
+
+  desc "Releases the archive #{WINDOWS_RUBY_ARCHIVE_FILENAME} on GoogleCode"
+  task :ruby_release => :ruby_archive do
+    sh "./googlecode_upload.py --summary=\"Gosu #{GOSU_VERSION}, compiled for 32-bit Windows (Ruby)\"" +
+       " --project=gosu --user=julianraschke --labels=\"Featured,Type-Archive,OpSys-Windows\" #{WINDOWS_RUBY_ARCHIVE_FILENAME}"
+  end
+  
+  desc "Release both #{WINDOWS_CPP_ARCHIVE_FILENAME} and #{WINDOWS_RUBY_ARCHIVE_FILENAME}"
+  task :release => [:cpp_release, :ruby_release]
+
+  WINDOWS_SPEC = Gem::Specification.new do |s|
+    apply_gemspec_defaults s
+    s.platform = 'x86-mswin32-60'
+    s.files = COMMON_RUBY_FILES + ['lib/gosu.so', 'lib/fmod.dll']
+  end
+  Rake::GemPackageTask.new(WINDOWS_SPEC) { |t| t.package_dir = 'public/windows_gem' }
+end
+
+Rake.application.in_namespace :linux do
+  LINUX_ARCHIVE_FILENAME = "public/gosu-source-#{GOSU_VERSION}.tar.gz"
+
+  desc "Build the archive #{LINUX_ARCHIVE_FILENAME}"
+  task :archive => [:cpp_docs] do
+    files = SOURCE_FILES
+    sh "cd .. && tar -czf gosu/#{LINUX_ARCHIVE_FILENAME} #{files.map { |filename| "'gosu/#{filename}'" }.join(' ')}"
+  end
+
+  desc "Releases the archive #{LINUX_ARCHIVE_FILENAME} on GoogleCode"
+  task :release => :archive do
+    sh "./googlecode_upload.py --summary=\"Gosu #{GOSU_VERSION} source package (to compile on Linux)\"" +
+       " --project=gosu --user=julianraschke --labels=\"Featured,Type-Archive,OpSys-All\" #{LINUX_ARCHIVE_FILENAME}"
+  end
+  
+  LINUX_SPEC = Gem::Specification.new do |s|
+    apply_gemspec_defaults s
+    s.platform = 'ruby'
+    s.files = SOURCE_FILES + [ 'linux/extconf.rb' ]
+    s.extensions = [ 'linux/extconf.rb' ]
+    s.require_path = 'lib'
+    s.requirements = ['g++',
+                      'pkg-config',
+                      'libgl',
+                      'X11 includes and libraries',
+                      'pangoft2',
+                      'fmod or SDL_mixer',
+ 
+                      "(Packages for Debian/Ubuntu:\n" +
+                      ' g++ pkg-config ruby-dev xorg-dev' +
+                      ' libsdl-mixer1.2-dev libgl1-mesa-dev' +
+                      ' libpango1.0-dev' +
+                      "\n)"]
+  end
+  
+  Rake::GemPackageTask.new(LINUX_SPEC) { |t| t.package_dir = 'public/linux_gem' }
+end
+
+# TODO? Gem upload to RubyForge: http://nubyonrails.com/articles/tutorial-publishing-rubygems-with-hoe
+

data/examples/ChipmunkIntegration.rb

@@ -0,0 +1,275 @@
+## File: ChipmunkIntegration.rb
+## Author: Dirk Johnson
+## Version: 1.0.0
+## Date: 2007-10-05
+## License: Same as for Gosu (MIT)
+## Comments: Based on the Gosu Ruby Tutorial, but incorporating the Chipmunk Physics Engine
+## See http://code.google.com/p/gosu/wiki/RubyChipmunkIntegration for the accompanying text.
+
+require 'rubygems'
+require 'gosu'
+require 'chipmunk'
+
+SCREEN_WIDTH = 640
+SCREEN_HEIGHT = 480
+
+# The number of steps to process every Gosu update
+# The Player ship can get going so fast as to "move through" a
+# star without triggering a collision; an increased number of
+# Chipmunk step calls per update will effectively avoid this issue
+SUBSTEPS = 6
+
+# Convenience method for converting from radians to a Vec2 vector.
+class Numeric
+  def radians_to_vec2
+    CP::Vec2.new(Math::cos(self), Math::sin(self))
+  end
+end
+
+# Layering of sprites
+module ZOrder
+  Background, Stars, Player, UI = *0..3
+end
+
+# This game will have one Player in the form of a ship
+class Player
+  attr_reader :shape
+
+  def initialize(window, shape)
+    @image = Gosu::Image.new(window, "media/Starfighter.bmp", false)
+    @shape = shape
+    @shape.body.p = CP::Vec2.new(0.0, 0.0) # position
+    @shape.body.v = CP::Vec2.new(0.0, 0.0) # velocity
+    
+    # Keep in mind that down the screen is positive y, which means that PI/2 radians,
+    # which you might consider the top in the traditional Trig unit circle sense is actually
+    # the bottom; thus 3PI/2 is the top
+    @shape.body.a = (3*Math::PI/2.0) # angle in radians; faces towards top of screen
+  end
+  
+  # Directly set the position of our Player
+  def warp(vect)
+    @shape.body.p = vect
+  end
+  
+  # Apply negative Torque; Chipmunk will do the rest
+  # SUBSTEPS is used as a divisor to keep turning rate constant
+  # even if the number of steps per update are adjusted
+  def turn_left
+    @shape.body.t -= 400.0/SUBSTEPS
+  end
+  
+  # Apply positive Torque; Chipmunk will do the rest
+  # SUBSTEPS is used as a divisor to keep turning rate constant
+  # even if the number of steps per update are adjusted
+  def turn_right
+    @shape.body.t += 400.0/SUBSTEPS
+  end
+  
+  # Apply forward force; Chipmunk will do the rest
+  # SUBSTEPS is used as a divisor to keep acceleration rate constant
+  # even if the number of steps per update are adjusted
+  # Here we must convert the angle (facing) of the body into
+  # forward momentum by creating a vector in the direction of the facing
+  # and with a magnitude representing the force we want to apply
+  def accelerate
+    @shape.body.apply_force((@shape.body.a.radians_to_vec2 * (3000.0/SUBSTEPS)), CP::Vec2.new(0.0, 0.0))
+  end
+  
+  # Apply even more forward force
+  # See accelerate for more details
+  def boost
+    @shape.body.apply_force((@shape.body.a.radians_to_vec2 * (3000.0)), CP::Vec2.new(0.0, 0.0))
+  end
+  
+  # Apply reverse force
+  # See accelerate for more details
+  def reverse
+    @shape.body.apply_force(-(@shape.body.a.radians_to_vec2 * (1000.0/SUBSTEPS)), CP::Vec2.new(0.0, 0.0))
+  end
+  
+  # Wrap to the other side of the screen when we fly off the edge
+  def validate_position
+    l_position = CP::Vec2.new(@shape.body.p.x % SCREEN_WIDTH, @shape.body.p.y % SCREEN_HEIGHT)
+    @shape.body.p = l_position
+  end
+  
+  def draw
+    @image.draw_rot(@shape.body.p.x, @shape.body.p.y, ZOrder::Player, @shape.body.a.radians_to_gosu)
+  end
+end
+
+# See how simple our Star is?
+# Of course... it just sits around and looks good...
+class Star
+  attr_reader :shape
+  
+  def initialize(animation, shape)
+    @animation = animation
+    @color = Gosu::Color.new(0xff000000)
+    @color.red = rand(255 - 40) + 40
+    @color.green = rand(255 - 40) + 40
+    @color.blue = rand(255 - 40) + 40
+    @shape = shape
+    @shape.body.p = CP::Vec2.new(rand * SCREEN_WIDTH, rand * SCREEN_HEIGHT) # position
+    @shape.body.v = CP::Vec2.new(0.0, 0.0) # velocity
+    @shape.body.a = (3*Math::PI/2.0) # angle in radians; faces towards top of screen
+  end
+
+  def draw  
+    img = @animation[Gosu::milliseconds / 100 % @animation.size];
+    img.draw(@shape.body.p.x - img.width / 2.0, @shape.body.p.y - img.height / 2.0, ZOrder::Stars, 1, 1, @color, :additive)
+  end
+end
+
+# The Gosu::Window is always the "environment" of our game
+# It also provides the pulse of our game
+class GameWindow < Gosu::Window
+  def initialize
+    super(SCREEN_WIDTH, SCREEN_HEIGHT, false, 16)
+    self.caption = "Gosu & Chipmunk Integration Demo"
+    @background_image = Gosu::Image.new(self, "media/Space.png", true)
+
+    # Put the beep here, as it is the environment now that determines collision
+    @beep = Gosu::Sample.new(self, "media/Beep.wav")
+    
+    # Put the score here, as it is the environment that tracks this now
+    @score = 0
+    @font = Gosu::Font.new(self, Gosu::default_font_name, 20)
+    
+    # Time increment over which to apply a physics "step" ("delta t")
+    @dt = (1.0/60.0)
+    
+    # Create our Space and set its damping
+    # A damping of 0.8 causes the ship bleed off its force and torque over time
+    # This is not realistic behavior in a vacuum of space, but it gives the game
+    # the feel I'd like in this situation
+    @space = CP::Space.new
+    @space.damping = 0.8    
+    
+    # Create the Body for the Player
+    body = CP::Body.new(10.0, 150.0)
+    
+    # In order to create a shape, we must first define it
+    # Chipmunk defines 3 types of Shapes: Segments, Circles and Polys
+    # We'll use s simple, 4 sided Poly for our Player (ship)
+    # You need to define the vectors so that the "top" of the Shape is towards 0 radians (the right)
+    shape_array = [CP::Vec2.new(-25.0, -25.0), CP::Vec2.new(-25.0, 25.0), CP::Vec2.new(25.0, 1.0), CP::Vec2.new(25.0, -1.0)]
+    shape = CP::Shape::Poly.new(body, shape_array, CP::Vec2.new(0,0))
+    
+    # The collision_type of a shape allows us to set up special collision behavior
+    # based on these types.  The actual value for the collision_type is arbitrary
+    # and, as long as it is consistent, will work for us; of course, it helps to have it make sense
+    shape.collision_type = :ship
+    
+    @space.add_body(body)
+    @space.add_shape(shape)
+
+    @player = Player.new(self, shape)
+    @player.warp(CP::Vec2.new(320, 240)) # move to the center of the window
+    
+    @star_anim = Gosu::Image::load_tiles(self, "media/Star.png", 25, 25, false)
+    @stars = Array.new
+        
+    # Here we define what is supposed to happen when a Player (ship) collides with a Star
+    # I create a @remove_shapes array because we cannot remove either Shapes or Bodies
+    # from Space within a collision closure, rather, we have to wait till the closure
+    # is through executing, then we can remove the Shapes and Bodies
+    # In this case, the Shapes and the Bodies they own are removed in the Gosu::Window.update phase
+    # by iterating over the @remove_shapes array
+    # Also note that both Shapes involved in the collision are passed into the closure
+    # in the same order that their collision_types are defined in the add_collision_func call
+    @remove_shapes = []
+    @space.add_collision_func(:ship, :star) do |ship_shape, star_shape|
+      @score += 10
+      @beep.play
+      @remove_shapes << star_shape
+    end
+    
+    # Here we tell Space that we don't want one star bumping into another
+    # The reason we need to do this is because when the Player hits a Star,
+    # the Star will travel until it is removed in the update cycle below
+    # which means it may collide and therefore push other Stars
+    # To see the effect, remove this line and play the game, every once in a while
+    # you'll see a Star moving
+    @space.add_collision_func(:star, :star, &nil)
+  end
+
+  def update
+    # Step the physics environment SUBSTEPS times each update
+    SUBSTEPS.times do
+      # This iterator makes an assumption of one Shape per Star making it safe to remove
+      # each Shape's Body as it comes up
+      # If our Stars had multiple Shapes, as would be required if we were to meticulously
+      # define their true boundaries, we couldn't do this as we would remove the Body
+      # multiple times
+      # We would probably solve this by creating a separate @remove_bodies array to remove the Bodies
+      # of the Stars that were gathered by the Player
+      @remove_shapes.each do |shape|
+        @stars.delete_if { |star| star.shape == shape }
+        @space.remove_body(shape.body)
+        @space.remove_shape(shape)
+      end
+      @remove_shapes.clear # clear out the shapes for next pass
+      
+      # When a force or torque is set on a Body, it is cumulative
+      # This means that the force you applied last SUBSTEP will compound with the
+      # force applied this SUBSTEP; which is probably not the behavior you want
+      # We reset the forces on the Player each SUBSTEP for this reason
+      @player.shape.body.reset_forces
+      
+      # Wrap around the screen to the other side
+      @player.validate_position
+      
+      # Check keyboard
+      if button_down? Gosu::Button::KbLeft
+        @player.turn_left
+      end
+      if button_down? Gosu::Button::KbRight
+        @player.turn_right
+      end
+      
+      if button_down? Gosu::Button::KbUp
+        if ( (button_down? Gosu::Button::KbRightShift) || (button_down? Gosu::Button::KbLeftShift) )
+          @player.boost
+        else
+          @player.accelerate
+        end
+      elsif button_down? Gosu::Button::KbDown
+        @player.reverse
+      end
+      
+      # Perform the step over @dt period of time
+      # For best performance @dt should remain consistent for the game
+      @space.step(@dt)
+    end
+    
+    # Each update (not SUBSTEP) we see if we need to add more Stars
+    if rand(100) < 4 and @stars.size < 25 then
+      body = CP::Body.new(0.0001, 0.0001)
+      shape = CP::Shape::Circle.new(body, 25/2, CP::Vec2.new(0.0, 0.0))
+      shape.collision_type = :star
+      
+      @space.add_body(body)
+      @space.add_shape(shape)
+      
+      @stars.push(Star.new(@star_anim, shape))
+    end
+  end
+
+  def draw
+    @background_image.draw(0, 0, ZOrder::Background)
+    @player.draw
+    @stars.each { |star| star.draw }
+    @font.draw("Score: #{@score}", 10, 10, ZOrder::UI, 1.0, 1.0, 0xffffff00)
+  end
+
+  def button_down(id)
+    if id == Gosu::Button::KbEscape
+      close
+    end
+  end
+end
+
+window = GameWindow.new
+window.show