gosu 0.7.9-x86-mswin32-60

data/examples/MoreChipmunkAndRMagick.rb

@@ -0,0 +1,159 @@
+# 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 between radians, Gosu degrees and Vec2 vectors.
+class Numeric 
+   def radians_to_gosu
+       self * 180.0 / Math::PI + 90
+   end
+
+   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

@@ -0,0 +1,232 @@
+# 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.
+
+begin
+  # In case you use Gosu via RubyGems.
+  require 'rubygems'
+rescue LoadError
+  # In case you don't.
+end
+
+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, :additive)
+  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::Button::KbLeft or button_down? Gosu::Button::GpLeft
+    @player.move_right if button_down? Gosu::Button::KbRight or button_down? Gosu::Button::GpRight
+    @player.accelerate if button_down? Gosu::Button::KbUp or button_down? Gosu::Button::GpUp
+    @player.brake if button_down? Gosu::Button::KbDown or button_down? Gosu::Button::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::Button::KbEscape
+      close
+    end
+  end
+end
+
+window = GameWindow.new
+window.show

data/examples/RMagickIntegration.rb

@@ -0,0 +1,449 @@
+# A (too) simple Gorilla-style shooter for two players.
+# Shows how Gosu and RMagick can be used together to generate a map, implement
+# a dynamic landscape and generally look great.
+# Also shows a very minimal, yet effective way of designing a game's object system.
+
+# Doesn't make use of Gosu's Z-ordering. Not many different things to draw, it's
+# easy to get the order right without it.
+
+# Known issues:
+# * Collision detection of the missiles is lazy, allows shooting through thin walls.
+# * The look of dead soldiers is, err, by accident. Soldier.png needs to be
+#   designed in a less obfuscated way :)
+
+begin
+  # In case you use Gosu via RubyGems.
+  require 'rubygems'
+rescue LoadError
+  # In case you don't.
+end
+
+require 'gosu'
+require 'rmagick'
+
+NULL_PIXEL = Magick::Pixel.from_color('none')
+
+# The class for this game's map.
+# Design:
+# * Dynamic map creation at startup, holding it as RMagick Image in @image
+# * Testing for solidity by testing @image's pixel values
+# * Drawing by (re)creating an array of Gosu::Image instances, each representing
+#   a part of the large @image
+# * Blasting holes into the map is implemented by drawing and erasing portions
+#   of @image, then setting the corresponding Gosu::Image instances to nil, so
+#   they will be recreated in Map#draw
+# Note: The splitting is done because recreating such a large Gosu::Image for
+#       every map change would be a very noticeable delay!
+
+class Map
+  WIDTH, HEIGHT = 800, 600
+  TILE_SIZE = 100
+  TILES_X = WIDTH / TILE_SIZE
+  TILES_Y = HEIGHT / TILE_SIZE
+  
+  def initialize(window)
+    # We'll need the window later for re-creating Gosu images.
+    @window = window
+
+    # Let's start with something simple and load the sky via RMagick.
+    # Loading JPEG files isn't possible with Gosu, so say wow!
+    sky = Magick::Image.read("media/Sky.jpg").first
+    @sky = Gosu::Image.new(window, sky, true)
+    
+    # This is the one large RMagick image that represents the map.
+    @image = Magick::Image.new(WIDTH, HEIGHT) { self.background_color = 'none' }
+    
+    # Set up a Draw object that fills with an earth texture.
+    earth = Magick::Image.read('media/Earth.png').first.resize(1.5)
+    gc = Magick::Draw.new
+    gc.pattern('earth', 0, 0, earth.columns, earth.rows) { gc.composite(0, 0, 0, 0, earth) }    
+    gc.fill('earth')
+    gc.stroke('#603000').stroke_width(1.5)
+    # Draw a smooth bezier island onto the map!
+    polypoints = [0, HEIGHT]
+    0.upto(TILES_X) do |x|
+      polypoints += [x * TILE_SIZE, HEIGHT * 0.2 + rand(HEIGHT * 0.8)]
+    end
+    polypoints += [WIDTH, HEIGHT]
+    gc.bezier(*polypoints)
+    gc.draw(@image)
+    
+    # Create a bright-dark gradient fill, an image from it and change the map's
+    # brightness with it.
+    fill = Magick::GradientFill.new(0, HEIGHT * 0.4, WIDTH, HEIGHT * 0.4, '#fff', '#666')
+    gradient = Magick::Image.new(WIDTH, HEIGHT, fill)
+    gradient = @image.composite(gradient, 0, 0, Magick::InCompositeOp)
+    @image.composite!(gradient, 0, 0, Magick::MultiplyCompositeOp)
+
+    # Finally, place the star in the middle of the map, just onto the ground.
+    star = Magick::Image.read('media/LargeStar.png').first
+    star_y = 0
+    star_y += 20 until solid?(WIDTH / 2, star_y)
+    @image.composite!(star, (WIDTH - star.columns) / 2, star_y - star.rows * 0.85,
+      Magick::DstOverCompositeOp)
+
+    # Creates an X*Y array for the Gosu images.
+    # (Initialized to nil automatically).
+    @gosu_images = Array.new(TILES_X) { Array.new(TILES_Y) }
+  end
+  
+  def solid?(x, y)
+    # Map is open at the top.
+    return false if y < 0
+    # Map is closed on all other sides.
+    return true if x < 0 or x >= 800 or y >= 600
+    # Inside of the map, determine solidity from the map image.
+    @image.pixel_color(x, y) != NULL_PIXEL
+  end
+  
+  def draw
+    # Sky background.
+    @sky.draw(0, 0, 0)
+    # All the tiles.
+    TILES_Y.times do |y|
+      TILES_X.times do |x|
+        # Recreate images that haven't been created yet, or need to be recreated
+        # due to map changes.
+        if @gosu_images[x][y].nil? then
+          part = @image.crop(x * TILE_SIZE, y * TILE_SIZE, TILE_SIZE, TILE_SIZE)
+          @gosu_images[x][y] = Gosu::Image.new(@window, part, true)
+        end
+        # At last - draw it!
+        @gosu_images[x][y].draw(x * TILE_SIZE, y * TILE_SIZE, 0)
+      end
+    end
+  end
+
+  # Radius of a crater.
+  RADIUS = 25
+  # Radius of a crater, SHadow included.
+  SH_RADIUS = 45
+  
+  def blast(x, y)
+    # This code assumes at most 2x2 tiles are affected by a blast, so
+    # don't change the RADIUS to 200 or something ;)
+    # Calculate the x/y indices of the two to four affected tiles.
+    # (left/right and top/bottom might be the same).
+    
+    left = (x - SH_RADIUS) / TILE_SIZE
+    right = (x + SH_RADIUS) / TILE_SIZE
+    top = (y - SH_RADIUS) / TILE_SIZE
+    bottom = (y + SH_RADIUS) / TILE_SIZE
+
+    # Set affected images to nil.
+    # A 'double-free' doesn't hurt if e.g. left == right! However, we have to watch out
+    # for out-of-bounds errors.
+    
+    @gosu_images[left][top] = nil unless left < 0 or top < 0
+    @gosu_images[right][top] = nil unless right >= TILES_X or top < 0
+    @gosu_images[left][bottom] = nil unless left < 0 or bottom >= TILES_Y
+    @gosu_images[right][bottom] = nil unless right >= TILES_X or bottom >= TILES_Y
+
+    # Create the crater image (basically a circle shape that is used to erase
+    # parts of the map) and the crater shadow image, if they don't exist
+    # already.
+    
+    if @crater_image.nil? then
+      @crater_image = Magick::Image.new(2 * RADIUS, 2 * RADIUS) { self.background_color = 'none' }
+      gc = Magick::Draw.new
+      gc.fill('black').circle(RADIUS, RADIUS, RADIUS, 0)
+      gc.draw(@crater_image)
+      @crater_shadow = @crater_image.shadow(0, 0, (SH_RADIUS - RADIUS) / 2, 1)
+    end
+    
+    # Draw the shadow (twice for more intensity), then erase a circle from the map.
+    @image.composite!(@crater_shadow, x - SH_RADIUS, y - SH_RADIUS, Magick::AtopCompositeOp)
+    @image.composite!(@crater_shadow, x - SH_RADIUS, y - SH_RADIUS, Magick::AtopCompositeOp)
+    @image.composite!(@crater_image, x - RADIUS, y - RADIUS, Magick::DstOutCompositeOp)
+  end
+end
+
+# Player class.
+# Note that applies to the whole game:
+# All objects implement an informal interface.
+# draw: Draws the object (obviously)
+# update: Moves the object etc., returns false if the object is to be deleted
+# hit_by?(missile): Returns true if an object is hit by the missile, causing
+#                   it to explode on this object. 
+
+class Player
+  # Magic numbers considered harmful! This is the height of the
+  # player as used for collision detection.
+  HEIGHT = 14
+  
+  attr_reader :x, :y, :dead
+  
+  def initialize(window, x, y, color)
+    # Only load the images once for all instances of this class.
+    @@images ||= Gosu::Image.load_tiles(window, "media/Soldier.png", 40, 50, false)
+    
+    @window, @x, @y, @color = window, x, y, color
+    @vy = 0
+    
+    # -1: left, +1: right
+    @dir = -1
+
+    # Aiming angle.
+    @angle = 90
+  end
+  
+  def draw
+    if dead then
+      # Poor, broken soldier.
+      @@images[0].draw_rot(x, y, 0, 290 * @dir, 0.5, 0.65, @dir * 0.5, 0.5, @color)
+      @@images[2].draw_rot(x, y, 0, 160 * @dir, 0.95, 0.5, 0.5, @dir * 0.5, @color)
+    else
+      # Was moved last frame?
+      if @show_walk_anim
+        # Yes: Display walking animation.
+        frame = Gosu::milliseconds / 200 % 2
+      else
+        # No: Stand around (boring).
+        frame = 0
+      end
+      
+      # Draw feet, then chest.
+      @@images[frame].draw(x - 10 * @dir, y - 20, 0, @dir * 0.5, 0.5, @color)
+      angle = @angle
+      angle = 180 - angle if @dir == -1
+      @@images[2].draw_rot(x, y - 5, 0, angle, 1, 0.5, 0.5, @dir * 0.5, @color)
+    end
+  end
+  
+  def update
+    # First, assume that no walking happened this frame.
+    @show_walk_anim = false
+    
+    # Gravity.
+    @vy += 1
+    
+    if @vy > 1 then
+      # Move upwards until hitting something.
+      @vy.times do
+        if @window.map.solid?(x, y + 1)
+          @vy = 0
+          break
+        else
+          @y += 1
+        end
+      end
+    else
+      # Move downwards until hitting something.
+      (-@vy).times do
+        if @window.map.solid?(x, y - HEIGHT - 1)
+          @vy = 0
+          break
+        else
+          @y -= 1
+        end
+      end
+    end
+    
+    # Soldiers are never deleted (they may die, though, but that is a different
+    # concept).
+    true
+  end
+  
+  def aim_up
+    @angle -= 2 unless @angle < 10
+  end
+  
+  def aim_down
+    @angle += 2 unless @angle > 170
+  end
+  
+  def try_walk(dir)
+    @show_walk_anim = true
+    @dir = dir
+    # First, magically move up (so soldiers can run up hills)
+    2.times { @y -= 1 unless @window.map.solid?(x, y - HEIGHT - 1) }
+    # Now move into the desired direction.
+    @x += dir unless @window.map.solid?(x + dir, y) or
+                     @window.map.solid?(x + dir, y - HEIGHT) 
+    # To make up for unnecessary movement upwards, sink downward again.
+    2.times { @y += 1 unless @window.map.solid?(x, y + 1) }
+  end
+  
+  def try_jump
+    @vy = -12 if @window.map.solid?(x, y + 1)
+  end
+  
+  def shoot
+    @window.objects << Missile.new(@window, x + 10 * @dir, y - 10, @angle * @dir)
+  end
+  
+  def hit_by?(missile)
+    if Gosu::distance(missile.x, missile.y, x, y) < 30 then
+      # Was hit :(
+      @dead = true
+      return true
+    else
+      return false
+    end    
+  end
+end
+
+# Implements the same interface as Player, except it'S a missile!
+
+class Missile
+  attr_reader :x, :y, :vx, :vy
+  
+  def initialize(window, x, y, angle)
+    # All missile instances use the same sound.
+    @@explosion_sound ||= Gosu::Sample.new(window, "media/Explosion.wav")
+    
+    # Horizontal/vertical velocity.
+    @vx, @vy = Gosu::offset_x(angle, 20).to_i, Gosu::offset_y(angle, 20).to_i
+    
+    @window, @x, @y = window, x + @vx, y + @vy
+  end
+  
+  def update
+    # Movement, gravity
+    @x += @vx
+    @y += @vy
+    @vy += 1
+    # Hit anything?
+    if @window.map.solid?(x, y) or @window.objects.any? { |o| o.hit_by?(self) } then
+      # Create great particles.
+      5.times { @window.objects << Particle.new(@window, x - 25 + rand(51), y - 25 + rand(51)) }
+      @window.map.blast(x, y)
+      # Weeee, stereo sound!
+      @@explosion_sound.play_pan((2 * @x - Map::WIDTH) / Map::WIDTH)
+      return false
+    else
+      return true
+    end
+  end
+  
+  def draw
+    # Just draw a small quad.
+    @window.draw_quad(x-2, y-2, 0xff800000, x+2, y-2, 0xff800000, 
+      x-2, y+2, 0xff800000, x+2, y+2, 0xff800000, 0)
+  end
+  
+  def hit_by?(missile)
+    # Missiles can't be hit by other missiles!
+    false
+  end
+end
+
+# Very minimal object that just draws a fading particle.
+
+class Particle
+  def initialize(window, x, y)
+    # All Particle instances use the same image
+    @@image ||= Gosu::Image.new(window, 'media/Smoke.png', false)
+    
+    @x, @y = x, y
+    @color = Gosu::Color.new(255, 255, 255, 255)
+  end
+  
+  def update
+    @y -= 5
+    @x = @x - 1 + rand(3)
+    @color.alpha -= 5
+    
+    # Remove if faded completely.
+    @color.alpha > 0
+  end
+  
+  def draw
+    @@image.draw(@x - 25, @y - 25, 0, 1, 1, @color)
+  end
+  
+  def hit_by?(missile)
+    # Smoke can't be hit!
+    false
+  end
+end
+
+# Finally, the class that ties it all together.
+# Very straightforward implementation.
+
+class GameWindow < Gosu::Window
+  attr_reader :map, :objects
+  
+  def initialize()
+    super(800, 600, false)
+    self.caption = "Medal of Anna - Gosu & RMagick Integration Demo"
+
+    # Texts to display in the appropriate situations.
+    @player_instructions = []
+    @player_won_messages = []
+    2.times do |plr|
+      @player_instructions << Gosu::Image.from_text(self,
+        "It is the #{ plr == 0 ? 'green' : 'red' } toy soldier's turn.\n" +
+        "(Arrow keys to walk and aim, Return to jump, Space to shoot)",
+        Gosu::default_font_name, 25, 0, width, :center)
+      @player_won_messages << Gosu::Image.from_text(self,
+        "The #{ plr == 0 ? 'green' : 'red' } toy soldier has won!",
+        Gosu::default_font_name, 25, 5, width, :center)
+    end
+
+    # Create everything!
+    @map = Map.new(self)
+    @players = [Player.new(self, 200, 40, 0xff308000), Player.new(self, 600, 40, 0xff803000)]
+    @objects = @players.dup
+    
+    # Let any player start.
+    @current_player = rand(2)
+    # Currently not waiting for a missile to hit something.
+    @waiting = false
+  end
+  
+  def draw
+    # Draw the main game.
+    @map.draw
+    @objects.each { |o| o.draw }
+    
+    # If any text should be displayed, draw it - and add a nice black border around it
+    # by drawing it four times, with a little offset in each direction.
+    
+    cur_text = @player_instructions[@current_player] if not @waiting
+    cur_text = @player_won_messages[1 - @current_player] if @players[@current_player].dead
+    
+    if cur_text then
+      x, y = 0, 30
+      cur_text.draw(x - 1, y, 0, 1, 1, 0xff000000)
+      cur_text.draw(x + 1, y, 0, 1, 1, 0xff000000)
+      cur_text.draw(x, y - 1, 0, 1, 1, 0xff000000)
+      cur_text.draw(x, y + 1, 0, 1, 1, 0xff000000)
+      cur_text.draw(x, y, 0, 1, 1, 0xffffffff)
+    end
+  end
+  
+  def update
+    # if waiting for the next player's turn, continue to do so until the missile has
+    # hit something.
+    @waiting &&= !@objects.grep(Missile).empty?
+     
+    # Remove all objects whose update method returns false. 
+    @objects.reject! { |o| o.update == false }
+
+    # If it's a player's turn, forward controls.
+    if not @waiting and not @players[@current_player].dead then
+      player = @players[@current_player]
+      player.aim_up if button_down? Gosu::KbUp
+      player.aim_down if button_down? Gosu::KbDown
+      player.try_walk(-1) if button_down? Gosu::KbLeft
+      player.try_walk(1) if button_down? Gosu::KbRight
+      player.try_jump if button_down? Gosu::KbReturn
+    end
+  end
+  
+  def button_down(id)
+    if id == Gosu::KbSpace and not @waiting and not @players[@current_player].dead then
+      # Shoot! This is handled in button_down because holding space shouldn't
+      # auto-fire - the shots would come from different players.
+      @players[@current_player].shoot
+      @current_player = 1 - @current_player
+      @waiting = true
+    end
+    # Very important feature! ;)
+    close if id == Gosu::KbEscape
+  end
+end
+
+# So far we have only defined how everything *should* work - now set it up and run it!
+GameWindow.new.show