rubygame 2.1.0

data/samples/demo_gl.rb

@@ -0,0 +1,151 @@
+#!/usr/bin/env ruby
+
+# This demonstrates the use of ruby-opengl alongside rubygame to produce
+# hardware-accelerated three-dimensional graphics. 
+#
+# Please note that rubygame itself does not perform any OpenGL functions,
+# it only allows ruby-opengl to use the Screen as its viewport. You MUST
+# have ruby-opengl installed to run this demo!
+
+require 'rubygame'
+
+begin
+  require 'opengl'
+rescue LoadError
+  puts "ATTENTION: This demo requires the opengl extension for ruby."
+  raise
+end
+
+WIDE = 640
+HIGH = 480
+
+Rubygame.init
+
+Rubygame::GL.set_attrib(Rubygame::GL::RED_SIZE, 5)
+Rubygame::GL.set_attrib(Rubygame::GL::GREEN_SIZE, 5)
+Rubygame::GL.set_attrib(Rubygame::GL::BLUE_SIZE, 5)
+Rubygame::GL.set_attrib(Rubygame::GL::DEPTH_SIZE, 16)
+Rubygame::GL.set_attrib(Rubygame::GL::DOUBLEBUFFER, 1)
+
+Rubygame::Screen.set_mode([WIDE,HIGH], 16, [Rubygame::OPENGL])
+queue = Rubygame::EventQueue.new()
+clock = Rubygame::Clock.new { |c| c.target_framerate = 60 }
+
+ObjectSpace.garbage_collect
+GL::Viewport( 0, 0, WIDE, HIGH )
+
+GL::MatrixMode( GL::PROJECTION )
+GL::LoadIdentity( )
+GLU::Perspective( 35, WIDE/(HIGH.to_f), 3, 10)
+
+GL::MatrixMode( GL::MODELVIEW )
+GL::LoadIdentity( )
+
+GL::Enable(GL::DEPTH_TEST)
+GL::DepthFunc(GL::LESS)
+
+GL::ShadeModel(GL::FLAT)
+
+color =
+  [[ 1.0,  1.0,  0.0], 
+  [ 1.0,  0.0,  0.0],
+  [ 0.0,  0.0,  0.0],
+  [ 0.0,  1.0,  0.0],
+  [ 0.0,  1.0,  1.0],
+  [ 1.0,  1.0,  1.0],
+  [ 1.0,  0.0,  1.0],
+  [ 0.0,  0.0,  1.0]]
+
+cube =
+  [[ 0.5,  0.5, -0.5], 
+  [ 0.5, -0.5, -0.5],
+  [-0.5, -0.5, -0.5],
+  [-0.5,  0.5, -0.5],
+  [-0.5,  0.5,  0.5],
+  [ 0.5,  0.5,  0.5],
+  [ 0.5, -0.5,  0.5],
+  [-0.5, -0.5,  0.5]]
+
+cube_list = 1
+
+GL::NewList(cube_list,GL::COMPILE_AND_EXECUTE)
+  GL::PushMatrix()
+		GL::Begin(GL::QUADS) 
+			GL::Color(1.0, 0.0, 0.0);
+			GL::Vertex(cube[0]);
+			GL::Vertex(cube[1]);
+			GL::Vertex(cube[2]);
+			GL::Vertex(cube[3]);
+			
+			GL::Color(0.0, 1.0, 0.0);
+			GL::Vertex(cube[3]);
+			GL::Vertex(cube[4]);
+			GL::Vertex(cube[7]);
+			GL::Vertex(cube[2]);
+			
+			GL::Color(0.0, 0.0, 1.0);
+			GL::Vertex(cube[0]);
+			GL::Vertex(cube[5]);
+			GL::Vertex(cube[6]);
+			GL::Vertex(cube[1]);
+			
+			GL::Color(0.0, 1.0, 1.0);
+			GL::Vertex(cube[5]);
+			GL::Vertex(cube[4]);
+			GL::Vertex(cube[7]);
+			GL::Vertex(cube[6]);
+			
+			GL::Color(1.0, 1.0, 0.0);
+			GL::Vertex(cube[5]);
+			GL::Vertex(cube[0]);
+			GL::Vertex(cube[3]);
+			GL::Vertex(cube[4]);
+			
+			GL::Color(1.0, 0.0, 1.0);
+			GL::Vertex(cube[6]);
+			GL::Vertex(cube[1]);
+			GL::Vertex(cube[2]);
+			GL::Vertex(cube[7]);
+  GL::PopMatrix()
+	GL::End()
+GL::EndList()
+
+angle = 0
+
+catch(:rubygame_quit) do
+	loop do
+		queue.each do |event|
+			case event
+			when Rubygame::KeyDownEvent
+				case event.key
+				when Rubygame::K_ESCAPE
+					throw :rubygame_quit 
+				when Rubygame::K_Q
+					throw :rubygame_quit 
+        end
+      when Rubygame::QuitEvent
+        throw :rubygame_quit
+      end
+		end
+
+    GL.ClearColor(0.0, 0.0, 0.0, 1.0);
+		GL.Clear(GL::COLOR_BUFFER_BIT|GL::DEPTH_BUFFER_BIT);
+
+		GL::MatrixMode(GL::MODELVIEW);
+    GL::LoadIdentity( )
+    GL::Translate(0, 0, -4)
+    GL::Rotate(45, 0, 1, 0)
+    GL::Rotate(45, 1, 0, 0)
+    GL::Rotate(angle, 0.0, 0.0, 1.0)
+    GL::Rotate(angle*2, 0.0, 1.0, 0.0)
+
+    GL::CallList(cube_list)
+
+		Rubygame::GL.swap_buffers()
+		ObjectSpace.garbage_collect
+
+    angle += clock.tick()/50.0
+    angle -= 360 if angle >= 360
+
+	end
+end

data/samples/demo_gl_tex.rb

@@ -0,0 +1,197 @@
+#!/usr/bin/env ruby
+
+# This demonstrates the use of ruby-opengl alongside rubygame to produce
+# hardware-accelerated three-dimensional graphics. Additionally, it
+# demonstrates the use of rubygame Surfaces as OpenGL textures.
+#
+# Please note that rubygame itself does not perform any OpenGL functions,
+# it only allows ruby-opengl to use the Screen as its viewport. You MUST
+# have ruby-opengl installed to run this demo!
+
+require 'rubygame'
+
+begin
+  require 'opengl'
+rescue LoadError
+  puts "ATTENTION: This demo requires the opengl extension for ruby."
+  raise
+end
+
+WIDE = 640
+HIGH = 480
+SCALE = 500.0
+shadedCube=true
+TEXTURE = "ruby.png"
+
+Rubygame.init
+
+Rubygame::GL.set_attrib(Rubygame::GL::RED_SIZE, 5)
+Rubygame::GL.set_attrib(Rubygame::GL::GREEN_SIZE, 5)
+Rubygame::GL.set_attrib(Rubygame::GL::BLUE_SIZE, 5)
+Rubygame::GL.set_attrib(Rubygame::GL::DEPTH_SIZE, 16)
+Rubygame::GL.set_attrib(Rubygame::GL::DOUBLEBUFFER, 1)
+
+Rubygame::Screen.set_mode([WIDE,HIGH], 16, [Rubygame::OPENGL])
+queue = Rubygame::EventQueue.new()
+clock = Rubygame::Clock.new { |c| c.target_framerate = 60 }
+
+ObjectSpace.garbage_collect
+GL::Viewport( 0, 0, WIDE, HIGH )
+
+GL::MatrixMode( GL::PROJECTION )
+GL::LoadIdentity( )
+GLU::Perspective( 35, WIDE/(HIGH.to_f), 3, 10)
+
+GL::MatrixMode( GL::MODELVIEW )
+GL::LoadIdentity( )
+
+GL::Enable(GL::DEPTH_TEST)
+GL::DepthFunc(GL::LESS)
+
+GL::ShadeModel(GL::FLAT)
+
+surface = Rubygame::Surface.load_image(TEXTURE)
+
+tex_id = GL::GenTextures(1)
+GL::BindTexture(GL::TEXTURE_2D, tex_id[0])
+GL::TexImage2D(GL::TEXTURE_2D, 0, GL::RGB, surface.w, surface.h, 0, GL::RGB,
+               GL::UNSIGNED_BYTE, surface.pixels)
+GL::TexParameter(GL::TEXTURE_2D,GL::TEXTURE_MIN_FILTER,GL::NEAREST);
+GL::TexParameter(GL::TEXTURE_2D,GL::TEXTURE_MAG_FILTER,GL::LINEAR);
+
+color =
+  [[ 1.0,  1.0,  0.0], 
+  [ 1.0,  0.0,  0.0],
+  [ 0.0,  0.0,  0.0],
+  [ 0.0,  1.0,  0.0],
+  [ 0.0,  1.0,  1.0],
+  [ 1.0,  1.0,  1.0],
+  [ 1.0,  0.0,  1.0],
+  [ 0.0,  0.0,  1.0]]
+
+cube =
+  [[ 0.5,  0.5, -0.5], 
+  [ 0.5, -0.5, -0.5],
+  [-0.5, -0.5, -0.5],
+  [-0.5,  0.5, -0.5],
+  [-0.5,  0.5,  0.5],
+  [ 0.5,  0.5,  0.5],
+  [ 0.5, -0.5,  0.5],
+  [-0.5, -0.5,  0.5]]
+
+cube_st =
+  [[[ 1,  1], [ 1,  0], [ 0,  0], [ 0,  1]],
+  [[ 1,  1], [ 1,  0], [ 0,  0], [ 0,  1]],
+  [[ 1,  1], [ 1,  0], [ 0,  0], [ 0,  1]],
+  [[ 1,  1], [ 1,  0], [ 0,  0], [ 0,  1]],
+  [[ 1,  1], [ 1,  0], [ 0,  0], [ 0,  1]],
+  [[ 1,  1], [ 1,  0], [ 0,  0], [ 0,  1]],
+  [[ 1,  1], [ 1,  0], [ 0,  0], [ 0,  1]],
+  [[ 1,  1], [ 1,  0], [ 0,  0], [ 0,  1]]]
+
+cube_list = 1
+
+GL::NewList(cube_list,GL::COMPILE_AND_EXECUTE)
+  GL::PushMatrix()
+		GL::Enable(GL::TEXTURE_2D)
+		GL::BindTexture(GL::TEXTURE_2D, tex_id[0])
+
+		GL::Begin(GL::QUADS) 
+
+    GL::TexCoord(cube_st[0][0]);
+    GL::Vertex(cube[0]);
+    GL::TexCoord(cube_st[0][1]);
+    GL::Vertex(cube[1]);
+    GL::TexCoord(cube_st[0][2]);
+    GL::Vertex(cube[2]);
+    GL::TexCoord(cube_st[0][3]);
+    GL::Vertex(cube[3]);
+    
+    GL::TexCoord(cube_st[1][0]);
+    GL::Vertex(cube[3]);
+    GL::TexCoord(cube_st[1][1]);
+    GL::Vertex(cube[4]);
+    GL::TexCoord(cube_st[1][2]);
+    GL::Vertex(cube[7]);
+    GL::TexCoord(cube_st[1][3]);
+    GL::Vertex(cube[2]);
+    
+    GL::TexCoord(cube_st[2][0]);
+    GL::Vertex(cube[0]);
+    GL::TexCoord(cube_st[2][1]);
+    GL::Vertex(cube[5]);
+    GL::TexCoord(cube_st[2][2]);
+    GL::Vertex(cube[6]);
+    GL::TexCoord(cube_st[2][3]);
+    GL::Vertex(cube[1]);
+    
+    GL::TexCoord(cube_st[3][0]);
+    GL::Vertex(cube[5]);
+    GL::TexCoord(cube_st[3][1]);
+    GL::Vertex(cube[4]);
+    GL::TexCoord(cube_st[3][2]);
+    GL::Vertex(cube[7]);
+    GL::TexCoord(cube_st[3][3]);
+    GL::Vertex(cube[6]);
+    
+    GL::TexCoord(cube_st[4][0]);
+    GL::Vertex(cube[5]);
+    GL::TexCoord(cube_st[4][1]);
+    GL::Vertex(cube[0]);
+    GL::TexCoord(cube_st[4][2]);
+    GL::Vertex(cube[3]);
+    GL::TexCoord(cube_st[4][3]);
+    GL::Vertex(cube[4]);
+    
+    GL::TexCoord(cube_st[5][0]);
+    GL::Vertex(cube[6]);
+    GL::TexCoord(cube_st[5][1]);
+    GL::Vertex(cube[1]);
+    GL::TexCoord(cube_st[5][2]);
+    GL::Vertex(cube[2]);
+    GL::TexCoord(cube_st[5][3]);
+    GL::Vertex(cube[7]);
+  GL::PopMatrix()
+	GL::End()
+GL::EndList()
+
+angle = 0
+
+catch(:rubygame_quit) do
+	loop do
+		queue.each do |event|
+			case event
+			when Rubygame::KeyDownEvent
+				case event.key
+				when Rubygame::K_ESCAPE
+					throw :rubygame_quit 
+				when Rubygame::K_Q
+					throw :rubygame_quit 
+        end
+      when Rubygame::QuitEvent
+        throw :rubygame_quit
+      end
+    end
+  
+
+    GL.ClearColor(0.0, 0.0, 0.0, 1.0);
+		GL.Clear(GL::COLOR_BUFFER_BIT|GL::DEPTH_BUFFER_BIT);
+
+		GL::MatrixMode(GL::MODELVIEW);
+    GL::LoadIdentity( )
+    GL::Translate(0, 0, -4)
+    GL::Rotate(45, 0, 1, 0)
+    GL::Rotate(45, 1, 0, 0)
+    GL::Rotate(angle, 0.0, 0.0, 1.0)
+    GL::Rotate(angle*2, 0.0, 1.0, 0.0)
+
+    GL::CallList(cube_list)
+
+		Rubygame::GL.swap_buffers()
+		ObjectSpace.garbage_collect
+
+    angle += clock.tick()/50.0
+    angle -= 360 if angle >= 360
+
+	end
+end

data/samples/demo_music.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+require 'rubygame'
+
+Rubygame.init()
+
+def test_music() 
+	mix = Rubygame::Mixer
+
+	# Use the lines below to get rid of artsd and contact ALSA directly on Linux.
+	# ARTSD happens to be buggy on my old, old linux distro. 
+	if false
+		if RUBY_PLATFORM =~ /linux/
+			`killall artsd`
+			ENV['SDL_AUDIODRIVER'] = "alsa"
+		end
+	end
+
+	mix.open_audio
+	puts "Using audio driver:" + mix.driver_name
+	music = mix::Music
+
+	if ARGV[0]
+		file = ARGV[0]
+	else
+		file = "song.ogg"
+		puts "If you want, you could give a filename as an argument to this script."
+	end
+
+	mus = music.load_audio(file);
+
+	puts "Testing fading in over 3 seconds, repeating forever."
+	mus.fade_in(3, -1);
+	puts('ERROR: Music not fading in') unless mus.fading?(:in)
+	sleep 3
+
+	puts "Playing for 2 seconds."
+	sleep 2
+
+	puts "Lowering volume to half for 3 seconds."
+	mus.volume = 0.5;
+	puts "ERROR: Volume wasn't adjusted" unless mus.volume == 0.5
+	sleep 3
+
+	puts "Restoring volume to full."
+	mus.volume = 1.0;
+	sleep 2
+
+	puts "Pausing for 1 seconds."
+	mus.pause
+	puts "ERROR: Music not paused." unless mus.paused?
+	sleep 1
+
+	puts "Resuming."
+	mus.resume
+	puts "ERROR: Music not resumed" unless mus.playing?
+
+	puts "Playing for 2 seconds."
+	sleep 2
+
+	puts "Fading out over 2 seconds."
+	mus.fade_out(2);
+	puts "ERROR: Music not fading out " unless mus.fading?(:out)
+
+	while mus.playing? or mus.fading? == :out do Thread.pass end
+	# Test playing of music to the end
+
+	puts "ERROR: Music not ended" if mus.playing?
+	mix.close_audio
+end
+
+music_thread = Thread.new do test_music() end
+music_thread.join
+Rubygame.quit()
+

data/samples/demo_rubygame.rb

@@ -0,0 +1,279 @@
+#!/usr/bin/env ruby
+
+# This program is released to the PUBLIC DOMAIN.
+# It is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# This script is messy, but it demonstrates almost all of
+# Rubygame's features, so it acts as a test program to see
+# whether your installation of Rubygame is working.
+
+require "rubygame"
+include Rubygame
+
+$stdout.sync = true
+
+# Use smooth scaling/rotating? You can toggle this with S key
+$smooth = false                 
+
+Rubygame.init()
+
+queue = EventQueue.new() # new EventQueue with autofetch
+queue.ignore = [MouseMotionEvent]
+clock = Clock.new()
+clock.target_framerate = 50
+
+unless ($gfx_ok = (VERSIONS[:sdl_gfx] != nil))
+  raise "SDL_gfx is not available. Bailing out." 
+end
+
+class Panda
+	include Sprites::Sprite
+	@@pandapic = Surface.load_image("panda.png")
+	@@pandapic.set_colorkey(@@pandapic.get_at(0,0))
+	attr_accessor :vx, :vy, :speed
+	def initialize(x,y)
+		super()
+		@vx, @vy = 0,0
+		@speed = 40
+		@image = @@pandapic
+		@rect = Rect.new(x,y,*@@pandapic.size)
+	end
+
+	def update_image(time)
+		# do nothing in base class, rotate/zoom image in subs
+	end
+
+	def update(time)
+		x,y = @rect.center
+		self.update_image(time)
+		@rect.size = @image.size
+		
+		base = @speed * time/1000.0
+		@rect.centerx = x + @vx * base
+		@rect.centery = y + @vy * base
+	end
+
+end
+
+class SpinnyPanda < Panda
+	attr_accessor :rate
+	def initialize(x,y,rate=0.1)
+		super(x,y)
+		@rate = rate
+		@angle = 0
+	end
+
+	def update_image(time)
+		@angle += (@rate * time) % 360
+		@image = @@pandapic.rotozoom(@angle,1,$smooth)
+	end
+end
+
+class ExpandaPanda < Panda
+	attr_accessor :rate
+	def initialize(x,y,rate=0.1)
+		super(x,y)
+		@rate = rate
+		@delta = 0
+	end
+
+	def update_image(time)
+		@delta = (@delta + time*@rate/36) % (Math::PI*2)
+		zoom = 1 + Math.sin(@delta)/2
+		@image = @@pandapic.zoom(zoom,$smooth)
+	end
+end
+
+class WobblyPanda < Panda
+	attr_accessor :rate
+	def initialize(x,y,rate=0.1)
+		super(x,y)
+		@rate = rate
+		@delta = 0
+	end
+
+	def update_image(time)
+		@delta = (@delta + time*@rate/36) % (Math::PI*2)
+		zoomx = (1.5 + Math.sin(@delta)/6) * @@pandapic.width
+		zoomy = (1.5 + Math.cos(@delta)/5) * @@pandapic.height
+		@image = @@pandapic.zoom_to(zoomx,zoomy,$smooth)
+	end
+end
+
+pandas = Sprites::Group.new
+pandas.extend(Sprites::UpdateGroup)
+pandas.extend(Sprites::DepthSortGroup)
+
+# Create the SDL window
+screen = Screen.set_mode([320,240])
+screen.title = "Rubygame test"
+screen.show_cursor = false;
+
+# Create the very cute panda objects!
+panda1 = SpinnyPanda.new(100,50)
+panda2 = ExpandaPanda.new(150,50)
+panda3 = WobblyPanda.new(200,50,0.5)
+
+panda1.depth = 0        # in between the others
+panda2.depth = 10       # behind both of the others
+panda3.depth = -10      # in front of both of the others
+
+# Put the pandas in a sprite group
+pandas.push(panda1,panda2,panda3)
+
+# Make the background surface
+background = Surface.new(screen.size)
+
+# Create and test a new surface
+a = Surface.new([100,100])
+
+# Draw a bunch of shapes on the new surface to try out the drawing module
+a.fill([70,70,255])
+rect1 = Rect.new([3,3,94,94])
+a.fill([40,40,1500],rect1)
+a.draw_box_s([30,30],[70,70],[0,0,0])
+a.draw_box([31,31],[69,69],[255,255,255])
+a.draw_circle_s([50,50],10,[100,150,200])
+# Two diagonal white lines, the right anti-aliased, the left not.
+a.draw_line([31,69],[49,31],[255,255,255])
+a.draw_line_a([49,31],[69,69],[255,255,255])
+# Finally, copy this interesting surface onto the background image 
+a.blit(background,[50,50],[0,0,90,80])
+
+# Draw some shapes on the background for fun
+# ... a filled pentagon with a lighter border
+background.draw_polygon_s(\
+	[[50,150],[100,140],[150,160],[120,180],[60,170]],\
+	[100,100,100])
+background.draw_polygon_a(\
+	[[50,150],[100,140],[150,160],[120,180],[60,170]],\
+	[200,200,200])
+# ... a pepperoni pizza!! (if you use your imagination...)
+background.draw_arc_s([250,200],34,[210,150],[180,130,50])
+background.draw_arc_s([250,200],30,[210,150],[230,180,80])
+background.draw_circle_s([240,180],4,[200,50,10])
+background.draw_circle_s([265,185],4,[200,50,10])
+background.draw_circle_s([258,200],4,[200,50,10])
+background.draw_circle_s([240,215],4,[200,50,10])
+background.draw_circle_s([260,220],4,[200,50,10])
+
+# _Try_ to make an anti-aliased, filled ellipse, but it doesn't work well.
+# If you look closely at the white ellipse, you can see that it isn't
+# AA on the left and right side, and there are some black specks on the top
+# and bottom where the two ellipses don't quite match.
+background.draw_ellipse_s([200,150],[30,25],[250,250,250])
+background.draw_ellipse_a([200,150],[30,25],[250,250,250])
+
+# Let's make some labels
+require "rubygame/sfont"
+sfont = SFont.new("term16.png")
+sfont.render("Arrow keys move the spinning panda!").blit(background,[10,10])
+
+TTF.setup()
+ttfont = TTF.new("FreeSans.ttf",20)
+ttfont.render("This is some TTF text!",true,[250,250,250]).blit(background,[20,200])
+
+
+# Create another surface to test transparency blitting
+b = Surface.new([200,50])
+b.fill([150,20,40])
+b.set_alpha(123)# approx. half transparent
+b.blit(background,[20,40])
+background.blit(screen,[0,0])
+
+# 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()
+
+if Joystick.num_joysticks > 0
+	Joystick.new(0)  # So that joystick events will appear on the queue
+end
+
+update_time = 0
+framerate = 0
+
+catch(:rubygame_quit) do
+	loop do
+		queue.each do |event|
+			case event
+			when KeyDownEvent
+				case event.key
+				when K_ESCAPE
+					throw :rubygame_quit 
+				when K_Q
+					throw :rubygame_quit 
+				when K_UP
+					panda1.vy = -1
+				when K_DOWN
+					panda1.vy = 1
+				when K_LEFT
+					panda1.vx = -1
+				when K_RIGHT
+					panda1.vx = 1
+				when K_S
+					$smooth = !$smooth
+					puts "#{$smooth?'En':'Dis'}abling smooth scale/rotate."
+				else
+					print "%s"%[event.string]
+				end
+			when KeyUpEvent
+				case event.key
+				when K_UP
+					panda1.vy = 0
+				when K_DOWN
+					panda1.vy = 0
+				when K_LEFT
+					panda1.vx = 0
+				when K_RIGHT
+					panda1.vx = 0
+				end
+			when 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 QuitEvent
+				throw :rubygame_quit
+			when MouseDownEvent
+				puts "click: [%d,%d]"%event.pos
+			when JoyDownEvent
+				case event.button
+				when 4; panda1.speed = 80
+				when 5; panda2.speed = 80
+				end
+				#puts "jdown: %d"%[event.button]
+			when JoyUpEvent
+				case event.button
+				when 4; panda1.speed = 40
+				when 5; panda2.speed = 40
+				end
+				#puts "jup: %d"%[event.button]
+			when JoyAxisEvent
+				# max = 32767
+				case(event.axis)
+				when 0; panda1.vx = event.value / 32767.0
+				when 1; panda1.vy = event.value / 32767.0
+				when 2; panda2.vx = event.value / 32767.0
+				when 3; panda2.vy = event.value / 32767.0
+				end
+				#puts "jaxis: %d %d"%[event.axis,event.value]
+			end
+		end
+
+		pandas.undraw(screen,background)
+		pandas.update(update_time)
+		dirty_rects = pandas.draw(screen)
+		screen.update_rects(dirty_rects)
+
+		update_time = clock.tick()
+		unless framerate == clock.framerate
+			framerate = clock.framerate
+			screen.title = "Rubygame test [%d fps]"%framerate
+		end
+	end
+end
+
+puts "Quitting!"
+Rubygame.quit()