singpolyma-xgame 0.0.1 → 0.1.0

data/COPYING

@@ -20,3 +20,5 @@ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
+
+"panda.png" copyright (C) 2004 John Croisant licensed under the Creative Commons Attribution-ShareAlike 2.5 License. 

data/README

@@ -1,8 +1,27 @@
 This is XGame, a cross-platform game development framework based on RubyGame and SDL.
 
-To run this demo you must have ruby and the rubygems system installed, then run:
+You may install rubygame using:
 
 sudo gem install rubygame
 
-to install the rubygame dependency.  You may need to install build tools, ruby headers, and SDL
+or by simply placing it somewhere in your ruby require path.
+
+You may need to install build tools, ruby headers, and SDL
 libraries/headers in order to install rubygame.  These should be in your software repositories.
+
+You must also install Chipmunk <http://wiki.slembcke.net/main/published/Chipmunk> in your ruby require path.
+
+To install XGame on your system, just run the traditional:
+	./configure
+	make
+	sudo make install
+
+== Long Term ==
+
+For those that are curious or poking around, XGame is part of a longer vision by singpolyma and psycotica0 
+to start a company that does game development and distribution.  Our vision is to help other developers 
+create and distribute / sell games to a market they might not othewise be able to reach.
+
+While the code is this repo is subject to the COPYING file, we would also ask that the community abide by 
+the spirit of FrieNDA while we get our product ready for launch.  Everyone will benefit once the network 
+is up and able to be used by developers to distribute their games.

data/TODO

@@ -1 +1,49 @@
-* Scrollable background
+Run `git grep -e TODO: -e XXX: -e FIXME:` to see notes about cleanup in the source.
+
+== Roadmap ==
+
+== General ==
+
+* Pick names for company and products.  XGame is kind of random, and while good on Google, all related domains are taken.
+* Get domain and website
+* Get people to test stuff as more of it becomes available
+* Run contests to get people interested in developing for the platform?
+
+=== For library ===
+
+* Scrollable background (psycotica0 working on this?)
+* EventListeners needs to wrap the new event stuff in rubygame2.4 -- the rubygame stuff is ugly raw though (Low priority until rubygame2.4 is official)
+* Music/SFX wrapper/demo/tests?
+* Board game-style demo + other demos
+* Continue to improve self-documentation of code and RDoc
+
+* Python port
+* DOMScripting (aka JavaScript) port
+* C port
+* C++ port
+* Java port?
+
+== For packager ==
+
+* Package Rubygame, Chipmunk, XGame, and demos as *.deb and *.rpm i386, AMD64, PPC, x86 for Windows, and source
+** Include the two extension files as defined at <http://github.com/singpolyma/xgame/wikis/package-file-extensions>
+* Set up an APT repository somewhere
+** Set up MD5, SHA1, SHA256, and GPG verification
+* Test with apt-get
+* Write prototype script to install from *.deb, *.rpm, or APT repo (with OAuth support for APT)
+** Test security (only authorized accounts download certain packages)
+* Set up gratis and non-gratis repos
+** Test end-to-end installing a "purchased" game with gratis dependencies
+* Get nice installer environment and GUI in C and Tk
+
+== For editor ==
+
+* Prototype editor
+** User can add sprites
+** User can move sprites around
+** User can assign mass, and bind basic controls right from GUI
+** User can set backgrounds, air resistance, and gravity
+** Provide basic default behaviours (moving platforms)
+** Allow binding and storage of arbitrary code in the target language
+* Decide on output/storage format (may not want to store as code, parsing is hard)
+* Get nice installer and GUI in C and Tk

data/lib/xgame.rb

@@ -1,9 +1,13 @@
+# All distances in pixels
+# All times in milliseconds
+
 begin
 	require 'rubygame'
+	require 'chipmunk'
 
 	# If we are operating without rubygems (preferred) some features are still nice
 	# define the Gem class to keep a standard API
-	class Gem
+	module Gem
 		@@user_home = '/'
 		def self.user_home
 			@@user_home ||= find_home
@@ -32,6 +36,25 @@ begin
 rescue LoadError
 	require 'rubygems'
 	require 'rubygame'
+	require 'chipmunk'
+end
+
+# Extend the CP namespace
+module CP
+	INFINITY = 1.0/0.0
+
+	class Vec2
+		ZERO = self.new(0,0)
+		
+		def [](k)
+			case k
+				when 0: x
+				when 1: y
+				else raise ArgumentError.new("Bad CP::Vec2 'index' #{k}")
+			end
+		end
+	end
+
 end
 
 # Extend the Rubygame namespace
@@ -39,333 +62,351 @@ module Rubygame
 
 	# This class defines an easy way to manage callbacks
 	class ListenerList < Hash
+		def world=(w)
+			@world = w
+		end
+
 		def addEventListener(event, callback=nil, &block)
 			callback = block unless callback
-			self[event] = [] unless self.key?event
-			self[event] << callback
+			if @world and event.is_a?CollisionEvent
+				@world.add_collision_func(event.by, event.to) { |by, to| callback.call(by, to) }
+			else
+				self[event] = [] unless self.key?event
+				self[event] << callback
+			end
 		end
 	end
 
 	class LoopEvent < Event
 	end
 
+	class CollisionEvent < Event
+		attr_accessor :by, :to
+		def initialize(by, to)
+			@by = by
+			@to = to
+		end
+	end
+
+	class Rect
+		def shape_for(body)
+			CP::Shape::Poly.new(body, vertices, CP::Vec2::ZERO)
+		end
+
+		def vertices
+			[CP::Vec2::ZERO, CP::Vec2.new(0, height), CP::Vec2.new(width, height), CP::Vec2.new(width, 0)]
+		end
+	end # end Rect
+
 	# Extend the Sprites namespace
 	module Sprites
 
-		# This is a mixin module for sprites that move
-		module MovingSprite
+		module Sprite 
 
-			def initialize(*args)
-				super
-				@velocity = {:left => 0, :right => 0, :up => 0, :down => 0} # These are the initial components of velocity
-				@going = {:left => false, :right => false, :up => false, :down => false} # Are we "going" in these directions or just travelling?
-				@reference = [0,0] # Moving frame of reference
-				@animating = {:left => [0,0], :right => [0,0], :up => [0,0], :down => [0,0]}
-				@speed = 50 # This can be overidden by implementations: it is how fast / massive the sprite is
+			# This method lets you check if the sprite is moving in a certain direction
+			def moving?(direction)
+				false # We're not a moving sprite
 			end
 
-			def velocity
-				[@velocity[:left]*-1 + @velocity[:right], @velocity[:up]*-1 + @velocity[:down]]
+			# Call this function every frame to have the Sprite calculate things about itself
+			def update(time); end
+
+		end
+
+		# This class basically just turns the Sprite module into an inheritable class
+		class BasicSprite
+			include Rubygame::Sprites::Sprite
+		end
+
+		# This is a basic class for image-based, sprites with a rectangular box matching their image
+		class ImageSprite < Rubygame::Sprites::BasicSprite
+
+			# Override this in subclasses to have a default image
+			# (actually, Surface, you can just draw vector stuff on it)
+			def self.default_image; end;
+
+			# Create a new BasicSprite. Pass x, y coordinates for location to spawn.
+			# Pass path to image if you have not ovrriden default_image
+			def initialize(x,y,image=nil)
+				super()
+				if image
+					@image = Rubygame::Surface[image]
+					raise "Image #{image} failed to load. Looking in: #{Rubygame::Surface.autoload_dirs.join(":")}" unless @image
+				else
+					@image = default_image
+					raise "No image to load. No default image, no image specified." unless @image
+				end
+				@rect = Rubygame::Rect.new(x,y,*@image.size)
+			end
+
+		end # class ImageSprite
+
+		# This is a class for Sprites to be used with the Chipmunk Physics Engine
+		# It is a subclass of ImageSprite since overriding defaulit_image
+		# with any Surface solves not having an image file
+		class ChipmunkPhysicsSprite < ImageSprite
+
+			attr_accessor :shape
+
+			def default_mass; 5; end
+
+			def initialize(x, y, mass=nil, moment=nil, image=nil)
+				super(x, y, image)
+				mass = default_mass unless mass
+				moment = CP::moment_for_poly(mass, @rect.vertices, CP::Vec2::ZERO) unless moment
+				body = CP::Body.new(mass, moment)
+				@shape = @rect.shape_for(body)
+				body.p = CP::Vec2.new(rect.x, rect.y)
+				@going = { :left => 0, :right => 0, :up => 0, :down =>0 }
+				@jumps = 0
 			end
 
-			def going
-				@going
+			def velocity
+				@shape.body.v
 			end
 
-			def reference=(v)
-				@reference = v
+			def moving?(direction)
+				return velocity.x > 0 if direction == :right
+				return velocity.x < 0 if direction == :left
+				return velocity.y > 0 if direction == :down
+				return velocity.y < 0 if direction == :up
+				false
 			end
 
 			# Go in some direction [vx, vy]. If either is nil, motion on that axis will not be affected.
-			def go(v, duration=0)
+			def go(v)
 				if v[0]
-					if v[0] <= 0
-						@animating[:left] = [duration, @velocity[:left]]
-						@velocity[:left] = v[0]*-1
-						@going[:left] = true
-					end
-					if v[0] >= 0
-						@animating[:right] = [duration, @velocity[:right]]
-						@velocity[:right] = v[0]
-						@going[:right] = true
-					end
+					@going[:left] = v[0]*-1	if v[0] <= 0
+					@going[:right] = v[0] if v[0] >= 0
 				end
 				if v[1]
-					if v[1] <= 0
-						@animating[:up] = [duration, @velocity[:up]]
-						@velocity[:up] = v[1]*-1
-						@going[:up] = true
-					end
-					if v[1] >= 0
-						@animating[:down] = [duration, @velocity[:down]]
-						@velocity[:down] = v[1]
-						@going[:down] = true
-					end
+					@going[:up] = v[1]*-1 if v[1] <= 0
+					@going[:down] = v[1] if v[1] >= 0
 				end
 			end
 
 			# Stop some component of motion
-			def stop(direction, duration=0)
-				@animating[direction] = [duration, @animating[direction][0] >= 1 ? @animating[direction][1] : @velocity[direction]]
-				@velocity[direction] = 0
-				@going[direction] = false
+			def stop(direction)
+				@going[direction] = 0
 			end
 
-			# Strike the sprite in a certain direction
-			def hit(v, by=nil)
-				self.go(v,[2,(1/(XGame.framerate/1000.0))/(@speed/4)].max)
+			# Apply a constant force along a certain vector
+			def apply_force(force)
+				case force
+					when Array
+						@shape.body.apply_force(CP::Vec2.new(force[0], force[1]), CP::Vec2::ZERO)
+					when CP::Vec2
+						@shape.body.apply_force(force, CP::Vec2::ZERO)
+					else
+						raise ArgumentError.new("Bad type for force: #{force.class}")
+				end
 			end
 
-			# Apply a force to this sprite [vx, vy, max_applied (optional)]
-			def apply_force(value)
-				@velocity[:left] += value[0]*-1 if value[0] < 0 and (!value[2][:left] or @velocity[:left] < value[2][:left])
-				@velocity[:right] += value[0] if value[0] > 0 and (!value[2][:right] or @velocity[:right] < value[2][:right])
-				@velocity[:up] += value[1]*-1 if value[1] < 0 and (!value[2][:up] or @velocity[:up] < value[2][:up])
-				@velocity[:down] += value[1] if value[1] > 0 and (!value[2][:down] or @velocity[:down] < value[2][:down])
+			def jump(strength=1000)
+				if @jumps < 1
+					apply_impulse [0, -strength]
+					@jumps += 1
+				end
 			end
 
-			def self.included(base)
-				base.class_eval {alias_method :update_no_moving, :update; alias_method :update, :update_moving}
+			def reset_jumps
+				@jumps = 0
 			end
 
-			def update_moving(time)
-				update_no_moving(time)
-
-				if @animating[:left][0] > 0
-					@animating[:left][0] -= 1
-					@velocity[:left] = @animating[:left][1] if @animating[:left][0] < 1
-				end
-				if @animating[:right][0] > 0
-					@animating[:right][0] -= 1
-					@velocity[:right] = @animating[:right][1] if @animating[:right][0] < 1
-				end
-				if @animating[:up][0] > 0
-					@animating[:up][0] -= 1
-					@velocity[:up] = @animating[:up][1] if @animating[:up][0]  < 1
-				end
-				if @animating[:down][0] > 0
-					@animating[:down][0] -= 1
-					@velocity[:down] = @animating[:down][1] if @animating[:down][0] < 1
+			# Apply a momentary force impulse
+			def apply_impulse(impulse)
+				case impulse
+					when Array
+						@shape.body.apply_impulse(CP::Vec2.new(impulse[0], impulse[1]), CP::Vec2::ZERO)
+					when CP::Vec2
+						@shape.body.apply_impulse(impulse, CP::Vec2::ZERO)
+					else
+						raise ArgumentError.new("Bad type for impulse: #{force.class}")
 				end
-				x,y = @rect.center
-				base = @speed * time/1000.0
-
-				@rect.centerx = x + (@reference[0] + velocity[0]) * base
-				@rect.centery = y + (@reference[1] + velocity[1]) * base
-				@reference = [0,0] # Frame of reference must be reset every frame
 			end
 
-		end # module MovingSprite
+			def update(time)
+				super
+				reset_jumps if velocity.y.abs < 1 # XXX: velocity.y == 0 at the exact peak of a jump. not a huge problem in practice?
+				apply_impulse(CP::Vec2.new(@going[:left]*-1 + @going[:right], @going[:up]*-1 + @going[:down]))
 
-		# This is a mixin module to allow a sprite to let things pass through some edges
-		module EdgeSprite
-			attr_accessor :edges
-		end
+				#@image = @image.rotozoom(@shape.body.a, 1)
+				rect.x = @shape.body.p.x
+				rect.y = @shape.body.p.y
+			end
 
-		# This is a mixin module for groups that keep their sprites in a particular region of the screen
-		module BoundedGroup
+		end # ChipmunkPhysicsSprite
 
-			# Bounding box (of type Rubygame::Rect)
-			attr_accessor :bounds
-			def bounds
-				@bounds ||= Rubygame::Screen.get_surface().make_rect()
-			end
+		module ChipmunkPhysicsSpaceGroup
 
-			def update(*args)
-				super(*args)
-				self.each { |sprite|
-					if sprite.rect.top < bounds.top
-						sprite.rect.top = bounds.top
-						sprite.stop(:up) if sprite.respond_to?(:stop)
-					end
-					if sprite.rect.bottom > bounds.bottom
-						sprite.rect.bottom = bounds.bottom
-						sprite.stop(:down) if sprite.respond_to?(:stop)
-					end
-					if sprite.rect.left < bounds.left
-						sprite.rect.left = bounds.left
-						sprite.stop(:left) if sprite.respond_to?(:stop)
-					end
-					if sprite.rect.right > bounds.right
-						sprite.rect.right = bounds.right
-						sprite.stop(:right) if sprite.respond_to?(:stop)
-					end	
-				}
+			# Get the Chipmunk Space
+			def space
+				@space ||= CP::Space.new
 			end
-			
-		end
 
-		# This is a mixin module for groups of sprites with a constant force acting on them
-		module ForceGroup
-			# Force vector [vx, vy, max_applied (optional)]
-			def force=(value)
-				value[2] = {} unless value
-				@force = value
+			# adds a collision callback (usually done by a listener)
+			def add_collision_func(by, to)
+				@space.add_collision_func(by, to) { |by, to| yield by, to }
 			end
 
-			def update(*args)
-				super(*args)
-				force = [@force[0] * args[0]/1000.0, @force[1] * args[0]/1000.0, @force[2]] # Make sure force is applied the same no matter how fast we're rendering
-				self.each { |sprite|
-					sprite.apply_force(force) if sprite.respond_to?(:apply_force)
-				}
-			end
-		end # module ForceGroup
-
-		# This is a mixin module for collisions between sprites
-		module CollideGroup
-
-			def update(*args)
-				super(*args)
-				self.each { |sprite|
-					self.each { |sprite2|
-						if sprite != sprite2 and sprite.respond_to?(:stop) and sprite.collide_sprite?sprite2
-							@sprite2_edges = {:top => true, :bottom => true, :left => true, :right => true}
-							@sprite2_edges = sprite2.edges if sprite2.respond_to?(:edges)
-							d = sprite2.rect.top - sprite.rect.bottom
-							if d < 0 and d > -5 and @sprite2_edges[:top] # Sprite is on top
-								if !sprite.respond_to?(:velocity) or sprite.velocity[1] > 0
-									sprite2.hit([nil,sprite.velocity[1]], sprite) if sprite2.respond_to?(:hit)
-									sprite.rect.bottom += d if (!sprite.respond_to?(:edges) or sprite.edges[:bottom])
-								end
-								sprite.stop(:down, (!sprite.respond_to?(:going) or sprite.going[:down]) ? 1/(args[0]/1000.0) * 0.1 : 0)
-							end
-							d = sprite.rect.top - sprite2.rect.bottom
-							if d < 0 and d > -5 and @sprite2_edges[:bottom] # Sprite is on bottom
-								if !sprite.respond_to?(:velocity) or sprite.velocity[1] < 0
-									sprite2.hit([nil,sprite.velocity[1]], sprite) if sprite2.respond_to?(:hit)
-									sprite.rect.top += d if !sprite.respond_to?(:edges) or sprite.edges[:top]
-								end
-								sprite.stop(:up, (!sprite.respond_to?(:going) or sprite.going[:up]) ? 1/(args[0]/1000.0) * 0.1 : 0)
-							end
-							d = sprite2.rect.left - sprite.rect.right
-							if d < 0 and d > -5 and @sprite2_edges[:left] # Sprite is on left
-								if !sprite.respond_to?(:velocity) or sprite.velocity[0] > 0
-									sprite2.hit([sprite.velocity[0],nil], sprite) if sprite2.respond_to?(:hit)
-									sprite.rect.right += d if !sprite.respond_to?(:edges) or sprite.edges[:right]
-								end
-								sprite.stop(:right, (!sprite.respond_to?(:going) or sprite.going[:right]) ? 1/(args[0]/1000.0) * 0.1 : 0)
-							end
-							d = sprite.rect.left - sprite2.rect.right
-							if d < 0 and d > -5 and @sprite2_edges[:right] # Sprite is on right
-								if !sprite.respond_to?(:velocity) or sprite.velocity[0] < 0
-									sprite2.hit([sprite.velocity[0],nil], sprite) if sprite2.respond_to?(:hit)
-									sprite.rect.left += d if (!sprite.respond_to?(:edges) or sprite.edges[:left])
-								end
-								sprite.stop(:left, (!sprite.respond_to?(:going) or sprite.going[:left]) ? 1/(args[0]/1000.0) * 0.1 : 0)
-							end
-						end
-					}
-				}
+			# Set the gravity (set in a vector so that horizontal "gravity" is also possible)
+			def gravity=(v)
+				case v
+					when Array
+						space.gravity = CP::Vec2.new(v[0], v[1])
+					when CP::Vec2
+						space.gravity = v
+					when Numeric
+						space.gravity = CP::Vec2.new(0, v)
+					else
+						raise ArgumentError.new("Invalid gravity value type #{v.class}")
+				end
 			end
-		end
 
-		# This is a basic class for updatable, image-based, sprites with a rectangular box matching their image
-		class BasicSprite
-			include Rubygame::Sprites::Sprite
+			# Set the damping/friction across all space
+			def damping=(v)
+				space.damping = v
+			end
 
-			# Override this in subclasses to have a default image
-			def self.default_image; end;
+			# Add a sprite to this group
+			def push(*args)
+				super
+				args.each do |sprite|
+					next unless sprite.respond_to?:shape
+					space.add_body sprite.shape.body unless sprite.shape.body.m == CP::INFINITY
+					space.add_shape sprite.shape
+				end
+			end
 
-			# Create a new BasicSprite. Pass x, y coordinates for location to spawn.
-			# Pass path to image if you have not ovrriden default_image
-			def initialize(x,y,image=nil)
-				super()
-				if image
-					@image = Rubygame::Surface[image]
-					throw "Image #{image} failed to load. Looking in: #{Rubygame::Surface.autoload_dirs.join(":")}" unless @image
-				else
-					@image = default_image
+			# Add bounds to sides of a rectangle (usually the screen)
+			def bound(screen, side)
+				case side
+					when Array
+						side.each { |side| bound(screen, side)  }
+						return
+					when :top
+						side_shape = CP::Shape::Segment.new(CP::Body.new(CP::INFINITY, CP::INFINITY), CP::Vec2::ZERO, CP::Vec2.new(screen.width, 0), 0)
+						side_shape.body.p = CP::Vec2.new(0, 0)
+					when :bottom
+						side_shape = CP::Shape::Segment.new(CP::Body.new(CP::INFINITY, CP::INFINITY), CP::Vec2::ZERO, CP::Vec2.new(screen.width, 0), 0)
+						side_shape.body.p = CP::Vec2.new(0, screen.height)
+					when :left
+						side_shape = CP::Shape::Segment.new(CP::Body.new(CP::INFINITY, CP::INFINITY), CP::Vec2::ZERO, CP::Vec2.new(0, screen.height), 0)
+						side_shape.body.p = CP::Vec2.new(0, 0)
+					when :right
+						side_shape = CP::Shape::Segment.new(CP::Body.new(CP::INFINITY, CP::INFINITY), CP::Vec2::ZERO, CP::Vec2.new(0, screen.height), 0)
+						side_shape.body.p = CP::Vec2.new(screen.width, 0)
+					else
+						raise ArgumentError.new("Invalid side to bound #{side}")
 				end
-				@rect = Rubygame::Rect.new(x,y,*@image.size)
+				side_shape.collision_type = :wall
+				space.add_static_shape side_shape
 			end
 
-			def update(time); end
+			# Update the Chipmunk space
+			def update(time, *args)
+				super
+				space.step(time/1000.0)
+			end
 
-		end # class BasicMovingBoundedSprit
+		end # ChipmunkPhysicsSpaceGroup
 
 	end # module Sprites
 
-end # module Rubygame
+	# Default rubygame clock sucks the CPU. We can do better.
+	class Clock
+		def tick()
+			passed = Clock::runtime - @last_tick # how long since the last tick?
+			if @target_frametime and (wait = @target_frametime - passed) > 0
+				return Clock::wait(wait) + passed
+			end
+			return passed
+		ensure
+			@last_tick = Clock::runtime
+			@ticks += 1
+		end
+	end
 
-class XGame
+end # module Rubygame
 
-	@@framerate = 60
-	def self.framerate
-		@@framerate
-	end
+module XGame
+	# NOTE: Remember to update this in ./configure as well as xgame.gemspec
+	VERSION = [0,1,0] # MAJOR, MINOR, PATCH
+end
 
-	# This method is the heart of XGame. Call it with a block that sets up your program.
-	def self.run(title = 'XGame', size = [], framerate = @@framerate, ignore_events = [], &block)
+# This method is the heart of XGame. Call it with a block that sets up your program.
+def XGame(title = 'XGame', size = [], frametime = 15, ignore_events = [], &block)
 
-		Rubygame.init() # Set stuff up
+	Rubygame.init() # Set stuff up
 
-		if Rubygame::Screen.respond_to?(:get_resolution)
-			size[0] = Rubygame::Screen.get_resolution[0] unless size[0]
-			size[1] = Rubygame::Screen.get_resolution[1] unless size[1]
-		else
-			size[0] = 640 unless size[0]
-			size[1] = 480 unless size[1]
-		end
+	if Rubygame::Screen.respond_to?(:get_resolution)
+		size[0] = Rubygame::Screen.get_resolution[0] unless size[0]
+		size[1] = Rubygame::Screen.get_resolution[1] unless size[1]
+	else
+		size[0] = 320 unless size[0]
+		size[1] = 240 unless size[1]
+	end
 
-		# The events queue gets filled up with all user input into our window
-		events = Rubygame::EventQueue.new()
-		events.ignore = ignore_events # Let's save cycles by ignoring events of some types
-
-		# The clock keeps us from eating the CPU
-		clock = Rubygame::Clock.new()
-		clock.target_framerate = framerate # Let's aim to render at some framerate
-
-		# Set up autoloading for Surfaces. Surfaces will be loaded automatically the first time you use Surface["filename"].
-		Rubygame::Surface.autoload_dirs = [ File.dirname($0) ] # XXX: this should include other paths depending on the platform
-
-		# Create a world for sprites to live in
-		world = Rubygame::Sprites::Group.new
-		world.extend(Rubygame::Sprites::DepthSortGroup) # Let them get in front of each other
-
-		# Grab the screen and create a background
-		screen = Rubygame::Screen.new(size, 0, [Rubygame::HWSURFACE, Rubygame::NOFRAME])
-		background = Rubygame::Surface.new(screen.size)
-
-		# This is where event handlers will get stored
-		listeners = Rubygame::ListenerList.new
-
-		# Include the user code
-		yield screen, background, world, listeners
-
-		# Refresh the screen once. During the loop, we'll use 'dirty rect' updating
-		# to refresh only the parts of the screen that have changed.
-		screen.update()
-
-		catch(:quit) do
-			loop do
-				events.push Rubygame::LoopEvent.new
-				events.each do |event|
-					case event
-					when Rubygame::ActiveEvent
-						# ActiveEvent appears when the window gains or loses focus.
-						# This helps to ensure everything is refreshed after the Rubygame window has been covered up by a different window.
-						screen.update()
-					when Rubygame::QuitEvent
-						# QuitEvent appears when the user closes the window, or otherwise signals they wish to quit
-						throw :quit
-					else
-						listeners[event.class].each { |callback| callback.call(event) } if listeners.key?(event.class)
-					end
+	# The events queue gets filled up with all user input into our window
+	events = Rubygame::EventQueue.new()
+	events.ignore = ignore_events # Let's save cycles by ignoring events of some types
+
+	# The clock keeps us from eating the CPU
+	clock = Rubygame::Clock.new()
+	clock.target_frametime = frametime # Let's aim to render at some framerate
+
+	# Set up autoloading for Surfaces. Surfaces will be loaded automatically the first time you use Surface["filename"].
+	Rubygame::Surface.autoload_dirs = [ File.dirname($0) ] # XXX: this should include other paths depending on the platform
+
+	# Create a world for sprites to live in
+	world = Rubygame::Sprites::Group.new
+	world.extend(Rubygame::Sprites::UpdateGroup) # The world can undraw and draw its Sprites
+	world.extend(Rubygame::Sprites::DepthSortGroup) # Let them get in front of each other
+
+	# Grab the screen and create a background
+	screen = Rubygame::Screen.new(size, 0, [Rubygame::HWSURFACE, Rubygame::NOFRAME])
+	screen.title = title # Set the window title
+	background = Rubygame::Surface.new(screen.size)
+
+	# This is where event handlers will get stored
+	listeners = Rubygame::ListenerList.new
+	listeners.world = world
+
+	# Include the user code
+	yield screen, background, world, listeners
+
+	# Refresh the screen once. During the loop, we'll use 'dirty rect' updating
+	# to refresh only the parts of the screen that have changed.
+	screen.update()
+
+	catch(:quit) do
+		loop do
+
+			world.undraw(screen, background)
+
+			events.push Rubygame::LoopEvent.new
+			events.each do |event|
+				case event
+				when Rubygame::ActiveEvent
+					# ActiveEvent appears when the window gains or loses focus.
+					# This helps to ensure everything is refreshed after the Rubygame window has been covered up by a different window.
+					screen.update()
+				when Rubygame::QuitEvent
+					# QuitEvent appears when the user closes the window, or otherwise signals they wish to quit
+					throw :quit
+				else
+					listeners[event.class].each { |callback| callback.call(event) } if listeners.key?(event.class)
 				end
+			end
 
-				world.undraw(screen, background)
-				@@framerate = clock.tick
-				world.update(@@framerate)
-				screen.update_rects(world.draw(screen))
+			world.update(clock.tick)
+			screen.update_rects(world.draw(screen))
 
-				screen.title = "#{title} [#{clock.framerate.to_i} fps]"
-			end
+			screen.title = "#{title} [#{clock.framerate.to_i} fps]" if $DEBUG
 		end
+	end
 
-		puts "#{title} is Quitting!"
-		Rubygame.quit()
-
-	end #run
+	puts "#{title} is Quitting!"
+	Rubygame.quit()
 
 end #XGame

data/xgame.gemspec

@@ -1,11 +1,11 @@
 Gem::Specification.new do |s|
   s.name     = "xgame"
-  s.version  = "0.0.1"
-  s.date     = "2008-10-18"
-  s.summary  = "High-level game framework based on rubygame"
+  s.version  = "0.1.0" # NOTE: Don't forget to update the configure script and lib/xgame.rb
+  s.date     = "2008-11-15"
+  s.summary  = "High-level game framework based on rubygame and chipmunk"
   s.email    = "singpolyma@singpolyma.net"
   s.homepage = "http://github.com/singpolyma/xgame"
-  s.description = "High-level game framework based on rubygame"
+  s.description = "High-level game framework based on rubygame and chipmunk"
   s.has_rdoc = true
   s.authors  = ['Stephen Paul Weber']
   s.files    = ["README", 
@@ -14,6 +14,6 @@ Gem::Specification.new do |s|
 		"xgame.gemspec", 
 		"lib/xgame.rb"] 
   s.extra_rdoc_files = ["README", "COPYING", "TODO"]
-  s.add_dependency("rubygame", ["> 0.0.0"])
+  s.add_dependency("rubygame", ["> 2.3.0"])
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: singpolyma-xgame
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors: 
 - Stephen Paul Weber
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-18 00:00:00 -07:00
+date: 2008-11-15 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -19,9 +19,9 @@ dependencies:
     requirements: 
     - - ">"
       - !ruby/object:Gem::Version 
-        version: 0.0.0
+        version: 2.3.0
     version: 
-description: High-level game framework based on rubygame
+description: High-level game framework based on rubygame and chipmunk
 email: singpolyma@singpolyma.net
 executables: []
 
@@ -62,6 +62,6 @@ rubyforge_project:
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
-summary: High-level game framework based on rubygame
+summary: High-level game framework based on rubygame and chipmunk
 test_files: []