gosu-examples 1.0.3

data/examples/cptn_ruby.rb

@@ -0,0 +1,229 @@
+# Encoding: UTF-8
+
+# Basically, the tutorial game taken to a jump'n'run perspective.
+
+# Shows how to
+#  * implement jumping/gravity
+#  * implement scrolling using Window#translate
+#  * implement a simple tile-based map
+#  * load levels from primitive text files
+
+# Some exercises, starting at the real basics:
+#  0) understand the existing code!
+# As shown in the tutorial:
+#  1) change it use Gosu's Z-ordering
+#  2) add gamepad support
+#  3) add a score as in the tutorial game
+#  4) similarly, add sound effects for various events
+# Exploring this game's code and Gosu:
+#  5) make the player wider, so he doesn't fall off edges as easily
+#  6) add background music (check if playing in Window#update to implement 
+#     looping)
+#  7) implement parallax scrolling for the star background!
+# Getting tricky:
+#  8) optimize Map#draw so only tiles on screen are drawn (needs modulo, a pen
+#     and paper to figure out)
+#  9) add loading of next level when all gems are collected
+# ...Enemies, a more sophisticated object system, weapons, title and credits
+# screens...
+
+require 'rubygems'
+require 'gosu'
+
+WIDTH, HEIGHT = 600, 600
+
+module Tiles
+  Grass = 0
+  Earth = 1
+end
+
+class CollectibleGem
+  attr_reader :x, :y
+
+  def initialize(image, x, y)
+    @image = image
+    @x, @y = x, y
+  end
+  
+  def draw
+    # Draw, slowly rotating
+    @image.draw_rot(@x, @y, 0, 25 * Math.sin(Gosu::milliseconds / 133.7))
+  end
+end
+
+# Player class.
+class Player
+  attr_reader :x, :y
+
+  def initialize(map, x, y)
+    @x, @y = x, y
+    @dir = :left
+    @vy = 0 # Vertical velocity
+    @map = map
+    # Load all animation frames
+    @standing, @walk1, @walk2, @jump = *Gosu::Image.load_tiles("media/cptn_ruby.png", 50, 50)
+    # This always points to the frame that is currently drawn.
+    # This is set in update, and used in draw.
+    @cur_image = @standing    
+  end
+  
+  def draw
+    # Flip vertically when facing to the left.
+    if @dir == :left then
+      offs_x = -25
+      factor = 1.0
+    else
+      offs_x = 25
+      factor = -1.0
+    end
+    @cur_image.draw(@x + offs_x, @y - 49, 0, factor, 1.0)
+  end
+  
+  # Could the object be placed at x + offs_x/y + offs_y without being stuck?
+  def would_fit(offs_x, offs_y)
+    # Check at the center/top and center/bottom for map collisions
+    not @map.solid?(@x + offs_x, @y + offs_y) and
+      not @map.solid?(@x + offs_x, @y + offs_y - 45)
+  end
+  
+  def update(move_x)
+    # Select image depending on action
+    if (move_x == 0)
+      @cur_image = @standing
+    else
+      @cur_image = (Gosu::milliseconds / 175 % 2 == 0) ? @walk1 : @walk2
+    end
+    if (@vy < 0)
+      @cur_image = @jump
+    end
+    
+    # Directional walking, horizontal movement
+    if move_x > 0 then
+      @dir = :right
+      move_x.times { if would_fit(1, 0) then @x += 1 end }
+    end
+    if move_x < 0 then
+      @dir = :left
+      (-move_x).times { if would_fit(-1, 0) then @x -= 1 end }
+    end
+
+    # Acceleration/gravity
+    # By adding 1 each frame, and (ideally) adding vy to y, the player's
+    # jumping curve will be the parabole we want it to be.
+    @vy += 1
+    # Vertical movement
+    if @vy > 0 then
+      @vy.times { if would_fit(0, 1) then @y += 1 else @vy = 0 end }
+    end
+    if @vy < 0 then
+      (-@vy).times { if would_fit(0, -1) then @y -= 1 else @vy = 0 end }
+    end
+  end
+  
+  def try_to_jump
+    if @map.solid?(@x, @y + 1) then
+      @vy = -20
+    end
+  end
+  
+  def collect_gems(gems)
+    # Same as in the tutorial game.
+    gems.reject! do |c|
+      (c.x - @x).abs < 50 and (c.y - @y).abs < 50
+    end
+  end
+end
+
+# Map class holds and draws tiles and gems.
+class Map
+  attr_reader :width, :height, :gems
+  
+  def initialize(filename)
+    # Load 60x60 tiles, 5px overlap in all four directions.
+    @tileset = Gosu::Image.load_tiles("media/tileset.png", 60, 60, :tileable => true)
+
+    gem_img = Gosu::Image.new("media/gem.png")
+    @gems = []
+
+    lines = File.readlines(filename).map { |line| line.chomp }
+    @height = lines.size
+    @width = lines[0].size
+    @tiles = Array.new(@width) do |x|
+      Array.new(@height) do |y|
+        case lines[y][x, 1]
+        when '"'
+          Tiles::Grass
+        when '#'
+          Tiles::Earth
+        when 'x'
+          @gems.push(CollectibleGem.new(gem_img, x * 50 + 25, y * 50 + 25))
+          nil
+        else
+          nil
+        end
+      end
+    end
+  end
+  
+  def draw
+    # Very primitive drawing function:
+    # Draws all the tiles, some off-screen, some on-screen.
+    @height.times do |y|
+      @width.times do |x|
+        tile = @tiles[x][y]
+        if tile
+          # Draw the tile with an offset (tile images have some overlap)
+          # Scrolling is implemented here just as in the game objects.
+          @tileset[tile].draw(x * 50 - 5, y * 50 - 5, 0)
+        end
+      end
+    end
+    @gems.each { |c| c.draw }
+  end
+  
+  # Solid at a given pixel position?
+  def solid?(x, y)
+    y < 0 || @tiles[x / 50][y / 50]
+  end
+end
+
+class CptnRuby < (Example rescue Gosu::Window)
+  def initialize
+    super WIDTH, HEIGHT
+    
+    self.caption = "Cptn. Ruby"
+    
+    @sky = Gosu::Image.new("media/space.png", :tileable => true)
+    @map = Map.new("media/cptn_ruby_map.txt")
+    @cptn = Player.new(@map, 400, 100)
+    # The scrolling position is stored as top left corner of the screen.
+    @camera_x = @camera_y = 0
+  end
+  
+  def update
+    move_x = 0
+    move_x -= 5 if Gosu::button_down? Gosu::KbLeft
+    move_x += 5 if Gosu::button_down? Gosu::KbRight
+    @cptn.update(move_x)
+    @cptn.collect_gems(@map.gems)
+    # Scrolling follows player
+    @camera_x = [[@cptn.x - WIDTH / 2, 0].max, @map.width * 50 - WIDTH].min
+    @camera_y = [[@cptn.y - HEIGHT / 2, 0].max, @map.height * 50 - HEIGHT].min
+  end
+  
+  def draw
+    @sky.draw 0, 0, 0
+    Gosu::translate(-@camera_x, -@camera_y) do
+      @map.draw
+      @cptn.draw
+    end
+  end
+  
+  def button_down(id)
+    if id == Gosu::KbUp then
+      @cptn.try_to_jump
+    end
+  end
+end
+
+CptnRuby.new.show if __FILE__ == $0

data/examples/media/cptn_ruby_map.txt

@@ -0,0 +1,25 @@
+#....................................................#
+#....................................................#
+#.............xx......x.x............................#
+#............x..x....................................#
+#x....x...x..x.......#####..xxx....................x.#
+#.x.........................xxx.........##.........x.#
+#...............""..........###...##..........##.....#
+#..##..###..##..##...................................#
+#........................................xx........###
+#.............................###....................#
+##....##.............................................#
+#....................##....##......##....##....##....#
+#.................................................x..#
+#...x....##....##.......x...x.....................x..#
+#.....x...............x...x...x...................x..#
+#......x...##.....##.................................#
+#.......x.........................................#..#
+#...........##........#...#...#..#.......x...........#
+#...#................................................#
+#....."""".................x.......#..#####...###....#
+#x....#......................##......................#
+#"""""#.....#.....x..................#...............#
+##xxxx......#........................................#
+##xxxx...#####............."...""""".................#
+######"""#############################################

data/examples/media/landscape.svg

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" clip-rule="evenodd" stroke-miterlimit="10" viewBox="0 0 850.39 637.80">
+    <desc>SVG generated by Lineform</desc>
+    <defs/>
+    <g>
+        <rect width="940.00" height="734.00" x="-25.50" y="-55.50" fill="#5FB7FF" stroke="#000000" stroke-width="2.20"/>
+        <path d="M 223.50 49.00 C 171.16 49.00 118.84 59.51 78.91 80.50 C -0.96 122.48 -0.96 190.52 78.91 232.50 C 134.24 261.59 213.37 270.50 283.34 259.28 C 350.32 290.78 452.18 289.47 516.06 255.19 C 582.65 219.45 582.65 161.55 516.06 125.81 C 482.95 108.04 439.59 99.12 396.19 99.03 C 388.26 92.46 378.99 86.23 368.09 80.50 C 328.16 59.51 275.84 49.00 223.50 49.00 Z M 223.50 49.00 " fill="#FFFFFF" stroke="#BFBFBF" stroke-width="6.00"/>
+        <path d="M 735.48 183.00 C 699.52 183.00 663.55 187.05 636.11 195.16 C 607.54 203.59 593.99 214.76 595.17 225.81 C 561.74 227.76 529.60 233.37 503.83 242.72 C 438.71 266.35 438.71 304.65 503.83 328.28 C 568.96 351.91 674.56 351.91 739.69 328.28 C 787.65 310.88 800.17 285.50 777.48 263.91 C 798.41 261.97 818.28 258.74 834.86 253.84 C 889.73 237.64 889.73 211.36 834.86 195.16 C 807.42 187.05 771.44 183.00 735.48 183.00 Z M 735.48 183.00 " fill="#FFFFFF" stroke="#BFBFBF" stroke-width="6.00"/>
+    </g>
+</svg>

data/examples/opengl_integration.rb

@@ -0,0 +1,224 @@
+# Encoding: UTF-8
+
+# 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'
+
+WIDTH, HEIGHT = 600, 600
+
+module ZOrder
+  Background, 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
+    @image = Gosu::Image.new("media/earth.png", :tileable => 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 draw(z)
+    # gl will execute the given block in a clean OpenGL environment, then reset
+    # everything so Gosu's rendering can take place again.
+    Gosu::gl(z) { exec_gl }
+  end
+  
+  private
+  
+  include Gl
+  
+  def exec_gl
+    glClearColor(0.0, 0.2, 0.5, 1.0)
+    glClearDepth(0)
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+    
+    # 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(x, y)
+    @image = Gosu::Image.new("media/starfighter.bmp")
+    @beep = Gosu::Sample.new("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, WIDTH].min
+  end
+  
+  def accelerate
+    @y = [@y - Speed, 50].max
+  end
+  
+  def brake
+    @y = [@y + Speed, HEIGHT].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(0xff_000000)
+    @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 OpenGLIntegration < (Example rescue Gosu::Window)
+  def initialize
+    super WIDTH, HEIGHT
+    
+    self.caption = "OpenGL Integration"
+    
+    @gl_background = GLBackground.new
+    
+    @player = Player.new(400, 500)
+    
+    @star_anim = Gosu::Image::load_tiles("media/star.png", 25, 25)
+    @stars = Array.new
+    
+    @font = Gosu::Font.new(20)
+  end
+  
+  def update
+    @player.move_left if Gosu::button_down? Gosu::KbLeft or Gosu::button_down? Gosu::GpLeft
+    @player.move_right if Gosu::button_down? Gosu::KbRight or Gosu::button_down? Gosu::GpRight
+    @player.accelerate if Gosu::button_down? Gosu::KbUp or Gosu::button_down? Gosu::GpUp
+    @player.brake if Gosu::button_down? Gosu::KbDown or Gosu::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
+    @player.draw
+    @stars.each { |star| star.draw }
+    @font.draw("Score: #{@player.score}", 10, 10, ZOrder::UI, 1.0, 1.0, 0xff_ffff00)
+    @gl_background.draw(ZOrder::Background)
+  end
+end
+
+OpenGLIntegration.new.show if __FILE__ == $0