gosu 0.8.6-x86-mingw32 → 0.8.7-x86-mingw32

data/examples/MoreChipmunkAndRMagick.rb

@@ -1,155 +1,155 @@
-# Based on the C Demo3 demonstration distributed with Chipmunk.
-# Also with some help from the ChipmunkIntegration.rb program.
-#
-# License: Same as for Gosu (MIT)
-# Created on 21/10/2007, 00:05:19 by Robert Sheehan
-
-require 'rubygems'
-require 'gosu'
-require 'chipmunk'
-require 'RMagick'
-
-# 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, Box = *0..1
-end
-
-SCREEN_WIDTH = 640
-SCREEN_HEIGHT = 480
-TICK = 1.0/60.0
-NUM_POLYGONS = 80
-NUM_SIDES = 4
-EDGE_SIZE = 15
-
-# Everything appears in the Gosu::Window.
-class DemoWindow < Gosu::Window
-
-   def initialize
-       super(SCREEN_WIDTH, SCREEN_HEIGHT, false)
-       self.caption = "A Chipmunk-RMagick-Gosu Demonstration"
-       @space = CP::Space.new
-       @space.iterations = 5
-       @space.gravity = CP::Vec2.new(0, 100)
-       # you can replace the background with any image with this line
-       #  background = Magick::ImageList.new( "media/Space.png")
-       fill = Magick::TextureFill.new(Magick::ImageList.new("granite:"))
-       background = Magick::Image.new(SCREEN_WIDTH, SCREEN_HEIGHT, fill)
-       setup_triangles(background)
-       @background_image = Gosu::Image.new(self, background, true) # turn the image into a Gosu one
-       @boxes = create_boxes(NUM_POLYGONS)
-   end
-
-   # Create all of the static triangles.
-   # Adds them to the space and the background image.
-   def setup_triangles(background)
-       gc = Magick::Draw.new
-       gc.stroke_width(2)
-       gc.stroke('red')
-       gc.fill('blue')
-       # all the triangles are part of the same body
-       body = CP::Body.new(Float::MAX, Float::MAX)
-       base = 15
-       height = 10
-       shape_vertices =  [CP::Vec2.new(-base, base), CP::Vec2.new(base, base), CP::Vec2.new(0, -height)]
-       # make shapes and images
-       9.times do |i|
-           6.times do |j|
-               stagger = (j % 2) * 40
-               x = i * 80 + stagger
-               y =  j * 70 + 80
-               shape = CP::Shape::Poly.new(body, shape_vertices, CP::Vec2.new(x, y))
-               shape.e = 1
-               shape.u = 1
-               @space.add_static_shape(shape)
-               gc.polygon(x - base + 1, y + base - 1, x + base - 1, y + base - 1,  x, y - height + 1)
-           end
-       end
-       # do the drawing
-       gc.draw(background)
-   end
-
-   # Produces the vertices of a regular polygon.
-   def polygon_vertices(sides, size)
-       vertices = []
-       sides.times do |i|
-           angle = -2 * Math::PI * i / sides
-           vertices << angle.radians_to_vec2() * size
-       end
-       return vertices
-   end
-
-   # Produces the image of a polygon.
-   def polygon_image(vertices)
-       box_image = Magick::Image.new(EDGE_SIZE  * 2, EDGE_SIZE * 2) { self.background_color = 'transparent' }
-       gc = Magick::Draw.new
-       gc.stroke('red')
-       gc.fill('plum')
-       draw_vertices = vertices.map { |v| [v.x + EDGE_SIZE, v.y + EDGE_SIZE] }.flatten
-       gc.polygon(*draw_vertices)
-       gc.draw(box_image)
-       return Gosu::Image.new(self, box_image, false)
-   end
-
-   # Produces the polygon objects and adds them to the space.
-   def create_boxes(num)
-       box_vertices = polygon_vertices(NUM_SIDES, EDGE_SIZE)
-       box_image = polygon_image(box_vertices)
-       boxes =  []
-       num.times do
-           body = CP::Body.new(1, CP::moment_for_poly(1.0, box_vertices, CP::Vec2.new(0, 0))) # mass, moment of inertia
-           body.p = CP::Vec2.new(rand(SCREEN_WIDTH), rand(40) - 50)
-           shape = CP::Shape::Poly.new(body, box_vertices, CP::Vec2.new(0, 0))
-           shape.e = 0.0
-           shape.u = 0.4
-           boxes << Box.new(box_image, body)
-           @space.add_body(body)
-           @space.add_shape(shape)      
-       end
-       return boxes
-   end
-
-   # All the simulation is done here.
-   def update
-       @space.step(TICK)
-       @boxes.each { |box| box.check_off_screen }
-   end
-
-   # All the updating of the screen is done here.
-   def draw
-       @background_image.draw(0, 0, ZOrder::Background)
-       @boxes.each { |box| box.draw }
-   end
-
-end
-
-# The falling boxes class.
-# Nothing more than a body and an image.
-class Box
-
-   def initialize(image, body)
-       @image = image
-       @body = body
-   end
-
-   # If it goes offscreen we put it back to the top.
-   def check_off_screen
-       pos = @body.p
-       if pos.y > SCREEN_HEIGHT + EDGE_SIZE or pos.x > SCREEN_WIDTH + EDGE_SIZE or pos.x < -EDGE_SIZE
-           @body.p = CP::Vec2.new(rand * SCREEN_WIDTH, 0)
-       end
-   end
-
-   def draw
-       @image.draw_rot(@body.p.x, @body.p.y, ZOrder::Box, @body.a.radians_to_gosu)
-   end
-end
-
-window = DemoWindow.new
-window.show
+# Based on the C Demo3 demonstration distributed with Chipmunk.
+# Also with some help from the ChipmunkIntegration.rb program.
+#
+# License: Same as for Gosu (MIT)
+# Created on 21/10/2007, 00:05:19 by Robert Sheehan
+
+require 'rubygems'
+require 'gosu'
+require 'chipmunk'
+require 'RMagick'
+
+# 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, Box = *0..1
+end
+
+SCREEN_WIDTH = 640
+SCREEN_HEIGHT = 480
+TICK = 1.0/60.0
+NUM_POLYGONS = 80
+NUM_SIDES = 4
+EDGE_SIZE = 15
+
+# Everything appears in the Gosu::Window.
+class DemoWindow < Gosu::Window
+
+   def initialize
+       super(SCREEN_WIDTH, SCREEN_HEIGHT, false)
+       self.caption = "A Chipmunk-RMagick-Gosu Demonstration"
+       @space = CP::Space.new
+       @space.iterations = 5
+       @space.gravity = CP::Vec2.new(0, 100)
+       # you can replace the background with any image with this line
+       #  background = Magick::ImageList.new( "media/Space.png")
+       fill = Magick::TextureFill.new(Magick::ImageList.new("granite:"))
+       background = Magick::Image.new(SCREEN_WIDTH, SCREEN_HEIGHT, fill)
+       setup_triangles(background)
+       @background_image = Gosu::Image.new(self, background, true) # turn the image into a Gosu one
+       @boxes = create_boxes(NUM_POLYGONS)
+   end
+
+   # Create all of the static triangles.
+   # Adds them to the space and the background image.
+   def setup_triangles(background)
+       gc = Magick::Draw.new
+       gc.stroke_width(2)
+       gc.stroke('red')
+       gc.fill('blue')
+       # all the triangles are part of the same body
+       body = CP::Body.new(Float::MAX, Float::MAX)
+       base = 15
+       height = 10
+       shape_vertices =  [CP::Vec2.new(-base, base), CP::Vec2.new(base, base), CP::Vec2.new(0, -height)]
+       # make shapes and images
+       9.times do |i|
+           6.times do |j|
+               stagger = (j % 2) * 40
+               x = i * 80 + stagger
+               y =  j * 70 + 80
+               shape = CP::Shape::Poly.new(body, shape_vertices, CP::Vec2.new(x, y))
+               shape.e = 1
+               shape.u = 1
+               @space.add_static_shape(shape)
+               gc.polygon(x - base + 1, y + base - 1, x + base - 1, y + base - 1,  x, y - height + 1)
+           end
+       end
+       # do the drawing
+       gc.draw(background)
+   end
+
+   # Produces the vertices of a regular polygon.
+   def polygon_vertices(sides, size)
+       vertices = []
+       sides.times do |i|
+           angle = -2 * Math::PI * i / sides
+           vertices << angle.radians_to_vec2() * size
+       end
+       return vertices
+   end
+
+   # Produces the image of a polygon.
+   def polygon_image(vertices)
+       box_image = Magick::Image.new(EDGE_SIZE  * 2, EDGE_SIZE * 2) { self.background_color = 'transparent' }
+       gc = Magick::Draw.new
+       gc.stroke('red')
+       gc.fill('plum')
+       draw_vertices = vertices.map { |v| [v.x + EDGE_SIZE, v.y + EDGE_SIZE] }.flatten
+       gc.polygon(*draw_vertices)
+       gc.draw(box_image)
+       return Gosu::Image.new(self, box_image, false)
+   end
+
+   # Produces the polygon objects and adds them to the space.
+   def create_boxes(num)
+       box_vertices = polygon_vertices(NUM_SIDES, EDGE_SIZE)
+       box_image = polygon_image(box_vertices)
+       boxes =  []
+       num.times do
+           body = CP::Body.new(1, CP::moment_for_poly(1.0, box_vertices, CP::Vec2.new(0, 0))) # mass, moment of inertia
+           body.p = CP::Vec2.new(rand(SCREEN_WIDTH), rand(40) - 50)
+           shape = CP::Shape::Poly.new(body, box_vertices, CP::Vec2.new(0, 0))
+           shape.e = 0.0
+           shape.u = 0.4
+           boxes << Box.new(box_image, body)
+           @space.add_body(body)
+           @space.add_shape(shape)      
+       end
+       return boxes
+   end
+
+   # All the simulation is done here.
+   def update
+       @space.step(TICK)
+       @boxes.each { |box| box.check_off_screen }
+   end
+
+   # All the updating of the screen is done here.
+   def draw
+       @background_image.draw(0, 0, ZOrder::Background)
+       @boxes.each { |box| box.draw }
+   end
+
+end
+
+# The falling boxes class.
+# Nothing more than a body and an image.
+class Box
+
+   def initialize(image, body)
+       @image = image
+       @body = body
+   end
+
+   # If it goes offscreen we put it back to the top.
+   def check_off_screen
+       pos = @body.p
+       if pos.y > SCREEN_HEIGHT + EDGE_SIZE or pos.x > SCREEN_WIDTH + EDGE_SIZE or pos.x < -EDGE_SIZE
+           @body.p = CP::Vec2.new(rand * SCREEN_WIDTH, 0)
+       end
+   end
+
+   def draw
+       @image.draw_rot(@body.p.x, @body.p.y, ZOrder::Box, @body.a.radians_to_gosu)
+   end
+end
+
+window = DemoWindow.new
+window.show

data/examples/OpenGLIntegration.rb

@@ -1,226 +1,226 @@
-# The tutorial game over a landscape rendered with OpenGL.
-# Basically shows how arbitrary OpenGL calls can be put into
-# the block given to Window#gl, and that Gosu Images can be
-# used as textures using the gl_tex_info call.
-
-require 'rubygems'
-require 'gosu'
-require 'gl'
-require 'glu'
-
-include Gl
-include Glu
-
-module ZOrder
-  Stars, Player, UI = *0..3
-end
-
-# The only really new class here.
-# Draws a scrolling, repeating texture with a randomized height map.
-class GLBackground
-  # Height map size
-  POINTS_X = 7
-  POINTS_Y = 7
-  # Scrolling speed
-  SCROLLS_PER_STEP = 50
-
-  def initialize(window)
-    @image = Gosu::Image.new(window, "media/Earth.png", true)
-    @scrolls = 0
-    @height_map = Array.new(POINTS_Y) { Array.new(POINTS_X) { rand } }
-  end
-  
-  def scroll
-    @scrolls += 1
-    if @scrolls == SCROLLS_PER_STEP then
-      @scrolls = 0
-      @height_map.shift
-      @height_map.push Array.new(POINTS_X) { rand }
-    end
-  end
-  
-  def exec_gl
-    # Get the name of the OpenGL texture the Image resides on, and the
-    # u/v coordinates of the rect it occupies.
-    # gl_tex_info can return nil if the image was too large to fit onto
-    # a single OpenGL texture and was internally split up.
-    info = @image.gl_tex_info
-    return unless info
-
-    # Pretty straightforward OpenGL code.
-    
-    glDepthFunc(GL_GEQUAL)
-    glEnable(GL_DEPTH_TEST)
-    glEnable(GL_BLEND)
-
-    glMatrixMode(GL_PROJECTION)
-    glLoadIdentity
-    glFrustum(-0.10, 0.10, -0.075, 0.075, 1, 100)
-
-    glMatrixMode(GL_MODELVIEW)
-    glLoadIdentity
-    glTranslate(0, 0, -4)
-  
-    glEnable(GL_TEXTURE_2D)
-    glBindTexture(GL_TEXTURE_2D, info.tex_name)
-    
-    offs_y = 1.0 * @scrolls / SCROLLS_PER_STEP
-    
-    0.upto(POINTS_Y - 2) do |y|
-      0.upto(POINTS_X - 2) do |x|
-        glBegin(GL_TRIANGLE_STRIP)
-          z = @height_map[y][x]
-          glColor4d(1, 1, 1, z)
-          glTexCoord2d(info.left, info.top)
-          glVertex3d(-0.5 + (x - 0.0) / (POINTS_X-1), -0.5 + (y - offs_y - 0.0) / (POINTS_Y-2), z)
-
-          z = @height_map[y+1][x]
-          glColor4d(1, 1, 1, z)
-          glTexCoord2d(info.left, info.bottom)
-          glVertex3d(-0.5 + (x - 0.0) / (POINTS_X-1), -0.5 + (y - offs_y + 1.0) / (POINTS_Y-2), z)
-        
-          z = @height_map[y][x + 1]
-          glColor4d(1, 1, 1, z)
-          glTexCoord2d(info.right, info.top)
-          glVertex3d(-0.5 + (x + 1.0) / (POINTS_X-1), -0.5 + (y - offs_y - 0.0) / (POINTS_Y-2), z)
-
-          z = @height_map[y+1][x + 1]
-          glColor4d(1, 1, 1, z)
-          glTexCoord2d(info.right, info.bottom)
-          glVertex3d(-0.5 + (x + 1.0) / (POINTS_X-1), -0.5 + (y - offs_y + 1.0) / (POINTS_Y-2), z)
-        glEnd
-      end
-    end
-  end
-end
-
-# Roughly adapted from the tutorial game. Always faces north.
-class Player
-  Speed = 7
-  
-  attr_reader :score
-
-  def initialize(window, x, y)
-    @image = Gosu::Image.new(window, "media/Starfighter.bmp", false)
-    @beep = Gosu::Sample.new(window, "media/Beep.wav")
-    @x, @y = x, y
-    @score = 0
-  end
-
-  def move_left
-    @x = [@x - Speed, 0].max
-  end
-  
-  def move_right
-    @x = [@x + Speed, 800].min
-  end
-  
-  def accelerate
-    @y = [@y - Speed, 50].max
-  end
-  
-  def brake
-    @y = [@y + Speed, 600].min
-  end
-  
-  def draw
-    @image.draw(@x - @image.width / 2, @y - @image.height / 2, ZOrder::Player)
-  end
-  
-  def collect_stars(stars)
-    stars.reject! do |star|
-      if Gosu::distance(@x, @y, star.x, star.y) < 35 then
-        @score += 10
-        @beep.play
-        true
-      else
-        false
-      end
-    end
-  end
-end
-
-# Also taken from the tutorial, but drawn with draw_rot and an increasing angle
-# for extra rotation coolness!
-class Star
-  attr_reader :x, :y
-  
-  def initialize(animation)
-    @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
-    @x = rand * 800
-    @y = 0
-  end
-
-  def draw  
-    img = @animation[Gosu::milliseconds / 100 % @animation.size];
-    img.draw_rot(@x, @y, ZOrder::Stars, @y, 0.5, 0.5, 1, 1, @color, :add)
-  end
-  
-  def update
-    # Move towards bottom of screen
-    @y += 3
-    # Return false when out of screen (gets deleted then)
-    @y < 650
-  end
-end
-
-class GameWindow < Gosu::Window
-  def initialize
-    super(800, 600, false)
-    self.caption = "Gosu & OpenGL Integration Demo"
-    
-    @gl_background = GLBackground.new(self)
-    
-    @player = Player.new(self, 400, 500)
-
-    @star_anim = Gosu::Image::load_tiles(self, "media/Star.png", 25, 25, false)
-    @stars = Array.new
-    
-    @font = Gosu::Font.new(self, Gosu::default_font_name, 20)
-  end
-
-  def update
-    @player.move_left if button_down? Gosu::KbLeft or button_down? Gosu::GpLeft
-    @player.move_right if button_down? Gosu::KbRight or button_down? Gosu::GpRight
-    @player.accelerate if button_down? Gosu::KbUp or button_down? Gosu::GpUp
-    @player.brake if button_down? Gosu::KbDown or button_down? Gosu::GpDown
-
-    @player.collect_stars(@stars)
-    
-    @stars.reject! { |star| !star.update }
-    
-    @gl_background.scroll
-    
-    @stars.push(Star.new(@star_anim)) if rand(20) == 0
-  end
-
-  def draw
-    # gl will execute the given block in a clean OpenGL environment, then reset
-    # everything so Gosu's rendering can take place again.
-    
-    gl do
-      glClearColor(0.0, 0.2, 0.5, 1.0)
-      glClearDepth(0)
-      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
-     
-      @gl_background.exec_gl
-    end
-    
-    @player.draw
-    @stars.each { |star| star.draw }
-    @font.draw("Score: #{@player.score}", 10, 10, ZOrder::UI, 1.0, 1.0, 0xffffff00)
-  end
-
-  def button_down(id)
-    if id == Gosu::KbEscape
-      close
-    end
-  end
-end
-
-window = GameWindow.new
+# The tutorial game over a landscape rendered with OpenGL.
+# Basically shows how arbitrary OpenGL calls can be put into
+# the block given to Window#gl, and that Gosu Images can be
+# used as textures using the gl_tex_info call.
+
+require 'rubygems'
+require 'gosu'
+require 'gl'
+require 'glu'
+
+include Gl
+include Glu
+
+module ZOrder
+  Stars, Player, UI = *0..3
+end
+
+# The only really new class here.
+# Draws a scrolling, repeating texture with a randomized height map.
+class GLBackground
+  # Height map size
+  POINTS_X = 7
+  POINTS_Y = 7
+  # Scrolling speed
+  SCROLLS_PER_STEP = 50
+
+  def initialize(window)
+    @image = Gosu::Image.new(window, "media/Earth.png", true)
+    @scrolls = 0
+    @height_map = Array.new(POINTS_Y) { Array.new(POINTS_X) { rand } }
+  end
+  
+  def scroll
+    @scrolls += 1
+    if @scrolls == SCROLLS_PER_STEP then
+      @scrolls = 0
+      @height_map.shift
+      @height_map.push Array.new(POINTS_X) { rand }
+    end
+  end
+  
+  def exec_gl
+    # Get the name of the OpenGL texture the Image resides on, and the
+    # u/v coordinates of the rect it occupies.
+    # gl_tex_info can return nil if the image was too large to fit onto
+    # a single OpenGL texture and was internally split up.
+    info = @image.gl_tex_info
+    return unless info
+
+    # Pretty straightforward OpenGL code.
+    
+    glDepthFunc(GL_GEQUAL)
+    glEnable(GL_DEPTH_TEST)
+    glEnable(GL_BLEND)
+
+    glMatrixMode(GL_PROJECTION)
+    glLoadIdentity
+    glFrustum(-0.10, 0.10, -0.075, 0.075, 1, 100)
+
+    glMatrixMode(GL_MODELVIEW)
+    glLoadIdentity
+    glTranslate(0, 0, -4)
+  
+    glEnable(GL_TEXTURE_2D)
+    glBindTexture(GL_TEXTURE_2D, info.tex_name)
+    
+    offs_y = 1.0 * @scrolls / SCROLLS_PER_STEP
+    
+    0.upto(POINTS_Y - 2) do |y|
+      0.upto(POINTS_X - 2) do |x|
+        glBegin(GL_TRIANGLE_STRIP)
+          z = @height_map[y][x]
+          glColor4d(1, 1, 1, z)
+          glTexCoord2d(info.left, info.top)
+          glVertex3d(-0.5 + (x - 0.0) / (POINTS_X-1), -0.5 + (y - offs_y - 0.0) / (POINTS_Y-2), z)
+
+          z = @height_map[y+1][x]
+          glColor4d(1, 1, 1, z)
+          glTexCoord2d(info.left, info.bottom)
+          glVertex3d(-0.5 + (x - 0.0) / (POINTS_X-1), -0.5 + (y - offs_y + 1.0) / (POINTS_Y-2), z)
+        
+          z = @height_map[y][x + 1]
+          glColor4d(1, 1, 1, z)
+          glTexCoord2d(info.right, info.top)
+          glVertex3d(-0.5 + (x + 1.0) / (POINTS_X-1), -0.5 + (y - offs_y - 0.0) / (POINTS_Y-2), z)
+
+          z = @height_map[y+1][x + 1]
+          glColor4d(1, 1, 1, z)
+          glTexCoord2d(info.right, info.bottom)
+          glVertex3d(-0.5 + (x + 1.0) / (POINTS_X-1), -0.5 + (y - offs_y + 1.0) / (POINTS_Y-2), z)
+        glEnd
+      end
+    end
+  end
+end
+
+# Roughly adapted from the tutorial game. Always faces north.
+class Player
+  Speed = 7
+  
+  attr_reader :score
+
+  def initialize(window, x, y)
+    @image = Gosu::Image.new(window, "media/Starfighter.bmp", false)
+    @beep = Gosu::Sample.new(window, "media/Beep.wav")
+    @x, @y = x, y
+    @score = 0
+  end
+
+  def move_left
+    @x = [@x - Speed, 0].max
+  end
+  
+  def move_right
+    @x = [@x + Speed, 800].min
+  end
+  
+  def accelerate
+    @y = [@y - Speed, 50].max
+  end
+  
+  def brake
+    @y = [@y + Speed, 600].min
+  end
+  
+  def draw
+    @image.draw(@x - @image.width / 2, @y - @image.height / 2, ZOrder::Player)
+  end
+  
+  def collect_stars(stars)
+    stars.reject! do |star|
+      if Gosu::distance(@x, @y, star.x, star.y) < 35 then
+        @score += 10
+        @beep.play
+        true
+      else
+        false
+      end
+    end
+  end
+end
+
+# Also taken from the tutorial, but drawn with draw_rot and an increasing angle
+# for extra rotation coolness!
+class Star
+  attr_reader :x, :y
+  
+  def initialize(animation)
+    @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
+    @x = rand * 800
+    @y = 0
+  end
+
+  def draw  
+    img = @animation[Gosu::milliseconds / 100 % @animation.size];
+    img.draw_rot(@x, @y, ZOrder::Stars, @y, 0.5, 0.5, 1, 1, @color, :add)
+  end
+  
+  def update
+    # Move towards bottom of screen
+    @y += 3
+    # Return false when out of screen (gets deleted then)
+    @y < 650
+  end
+end
+
+class GameWindow < Gosu::Window
+  def initialize
+    super(800, 600, false)
+    self.caption = "Gosu & OpenGL Integration Demo"
+    
+    @gl_background = GLBackground.new(self)
+    
+    @player = Player.new(self, 400, 500)
+
+    @star_anim = Gosu::Image::load_tiles(self, "media/Star.png", 25, 25, false)
+    @stars = Array.new
+    
+    @font = Gosu::Font.new(self, Gosu::default_font_name, 20)
+  end
+
+  def update
+    @player.move_left if button_down? Gosu::KbLeft or button_down? Gosu::GpLeft
+    @player.move_right if button_down? Gosu::KbRight or button_down? Gosu::GpRight
+    @player.accelerate if button_down? Gosu::KbUp or button_down? Gosu::GpUp
+    @player.brake if button_down? Gosu::KbDown or button_down? Gosu::GpDown
+
+    @player.collect_stars(@stars)
+    
+    @stars.reject! { |star| !star.update }
+    
+    @gl_background.scroll
+    
+    @stars.push(Star.new(@star_anim)) if rand(20) == 0
+  end
+
+  def draw
+    # gl will execute the given block in a clean OpenGL environment, then reset
+    # everything so Gosu's rendering can take place again.
+    
+    gl do
+      glClearColor(0.0, 0.2, 0.5, 1.0)
+      glClearDepth(0)
+      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+     
+      @gl_background.exec_gl
+    end
+    
+    @player.draw
+    @stars.each { |star| star.draw }
+    @font.draw("Score: #{@player.score}", 10, 10, ZOrder::UI, 1.0, 1.0, 0xffffff00)
+  end
+
+  def button_down(id)
+    if id == Gosu::KbEscape
+      close
+    end
+  end
+end
+
+window = GameWindow.new
 window.show