gosu 0.7.39-x86-mingw32

data/examples/CptnRuby.rb

@@ -0,0 +1,223 @@
+# 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'
+include Gosu
+
+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(milliseconds / 133.7))
+  end
+end
+
+# Player class.
+class CptnRuby
+  attr_reader :x, :y
+
+  def initialize(window, x, y)
+    @x, @y = x, y
+    @dir = :left
+    @vy = 0 # Vertical velocity
+    @map = window.map
+    # Load all animation frames
+    @standing, @walk1, @walk2, @jump =
+      *Image.load_tiles(window, "media/CptnRuby.png", 50, 50, false)
+    # 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 = (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(window, filename)
+    # Load 60x60 tiles, 5px overlap in all four directions.
+    @tileset = Image.load_tiles(window, "media/CptnRuby Tileset.png", 60, 60, true)
+
+    gem_img = Image.new(window, "media/CptnRuby Gem.png", false)
+    @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 Game < Window
+  attr_reader :map
+
+  def initialize
+    super(640, 480, false)
+    self.caption = "Cptn. Ruby"
+    @sky = Image.new(self, "media/Space.png", true)
+    @map = Map.new(self, "media/CptnRuby Map.txt")
+    @cptn = CptnRuby.new(self, 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 button_down? KbLeft
+    move_x += 5 if button_down? KbRight
+    @cptn.update(move_x)
+    @cptn.collect_gems(@map.gems)
+    # Scrolling follows player
+    @camera_x = [[@cptn.x - 320, 0].max, @map.width * 50 - 640].min
+    @camera_y = [[@cptn.y - 240, 0].max, @map.height * 50 - 480].min
+  end
+  def draw
+    @sky.draw 0, 0, 0
+    translate(-@camera_x, -@camera_y) do
+      @map.draw
+      @cptn.draw
+    end
+  end
+  def button_down(id)
+    if id == KbUp then @cptn.try_to_jump end
+    if id == KbEscape then close end
+  end
+end
+
+Game.new.show

data/examples/MoreChipmunkAndRMagick.rb

@@ -0,0 +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

data/examples/OpenGLIntegration.rb

@@ -0,0 +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
+window.show