gosu 0.8.7.2-x64-mingw32 → 0.9.0-x64-mingw32

data/examples/CptnRuby.rb

@@ -1,223 +0,0 @@
-# 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/GosuZen.rb

@@ -1,68 +0,0 @@
-# Gosu Zen example based on erisdiscord's comment here:
-# https://github.com/jlnr/gosu/pull/120
-
-# Gosu Zen is the (inline) Sinatra of Ruby multimedia programming.
-# The interface is still in flux. If you want to tune the interface
-# a little further or provide more examples, please fork Gosu and
-# send a pull request. Thanks!
-
-require 'rubygems'
-require 'gosu/zen'
-include Gosu::Zen
-
-window 480, 240, :fullscreen => false
-
-button_down Gosu::KbEscape do
-  close
-end
-
-update do
-  t = Gosu.milliseconds / 1000.0
-
-  @radius = [width, height].min * 0.37
-  @angle = t * Math::PI
-
-  a, b =\
-    (Math.cos(t) + 0.5) * 0xff,
-    (Math.sin(t) + 0.5) * 0xff
-
-  c = (a + b) / 2
-
-  @colors = [
-    Gosu::Color.rgb(a, b, 0xff),
-    Gosu::Color.rgb(a, 0x00, b),
-    Gosu::Color.rgb(0xff, b, a),
-    Gosu::Color.rgb(b, a, 0x00),
-    Gosu::Color.rgb(b, 0xff, a),
-    Gosu::Color.rgb(0x00, a, b) ]
-
-  @background = Gosu::Color.rgb(c, c, c)
-end
-
-draw do
-  draw_quad\
-    0,     0,      @background,
-    0,     height, @background,
-    width, height, @background,
-    width, 0,      @background, 0
-
-  translate width / 2, height / 2 do
-    @colors.each.with_index do |color, i|
-
-      angle = @angle + i.to_f / @colors.length * 2.0 * Math::PI
-      x = @radius * Math.sin(angle)
-      y = @radius * Math.cos(angle)
-      w, h = x, y
-
-      translate x, y do
-        rotate Gosu.radians_to_degrees(angle) do
-          draw_quad\
-            -w, +h, color,
-            -w, -h, color,
-            +w, -h, color,
-            +w, +h, color, 0
-        end
-      end
-    end
-  end
-end

data/examples/MoreChipmunkAndRMagick.rb

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