gosu-examples 1.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8eb4367ee4c008b79167bda5845113c7513eedd4
+  data.tar.gz: 9b6fe668a5ed7f24da588abdb4f6f9dcbe600f81
+SHA512:
+  metadata.gz: cacab6fb2e19440bb1b1b84043f4a3936c5b84c48734809a3e8452252ac5509cd9b743d117afc81fa2d7a300c5593a35e32dfb13a0d030ffeb8bef0efe5367eb
+  data.tar.gz: aed9c85c7dc6c65a7bf585867f77344a6617273310bcba784f1a15ca0c932ab8eb9984fe3900c3bbf1d693371e10b8fb58e13a7b7325f23d52c14a5ca363869f

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Julian Raschke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,14 @@
+Gosu Examples
+=============
+
+This is a collection of Ruby example games for the [Gosu media library](https://libgosu.org/).
+
+To run the examples, simply install the `gosu-examples` Ruby gem and then run `gosu-examples` in the terminal.
+
+Some examples require the following libraries to be installed:
+
+`gem install chipmunk`
+`gem install rmagick`
+`gem install opengl`
+
+(This is a very rough first version of this gem. Feel free to contribute to all parts of this repository via Pull Requests - media files, more examples, cleaning up code... - as long as we can use your contributions under the MIT license.)

data/bin/gosu-examples

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'gosu'
+
+Dir.chdir "#{File.dirname __FILE__}/../examples"
+
+$LOAD_PATH << "#{File.dirname __FILE__}/../lib/gosu-examples"
+
+require 'example'
+require 'sidebar'
+
+Example.load_examples "{.,../features}/*.rb" # TODO - should be *.rb
+
+class ExampleBox < Gosu::Window
+  # TODO - the ExampleWindow should resize to fit once Gosu::Window#resize has been added.
+  # See https://github.com/jlnr/gosu/issues/255
+  EXAMPLE_WIDTH  = 600
+  EXAMPLE_HEIGHT = 600
+  
+  def initialize
+    super Sidebar::WIDTH + EXAMPLE_WIDTH, EXAMPLE_HEIGHT, :fullscreen => ARGV.include?('--fullscreen')
+    
+    @sidebar = Sidebar.new { |example| change_example(example) }
+    
+    welcome_class = Example.examples.find { |example| example.name =~ /::Welcome$/ }
+    @current_example = welcome_class.new
+  end
+  
+  def update
+    self.caption = "Gosu Example Box - #{@current_example.caption} (#{Gosu::fps} FPS)"
+    
+    @current_example.update
+  end
+  
+  def draw
+    @current_example.draw
+    
+    flush
+    
+    translate(EXAMPLE_WIDTH, 0) do
+      current_filename = @current_example.class.source_file
+      @sidebar.draw(current_filename)
+    end
+  end
+  
+  def button_down(id)
+    case id
+    when Gosu::KbEscape
+      close
+    when char_to_button_id('S')
+      if filename = @current_example.class.source_file then
+        open_file_or_folder filename
+      end
+    when char_to_button_id('O')
+      if filename = @current_example.class.source_file then
+        open_file_or_folder File.dirname(filename)
+      end
+    else
+      if id == Gosu::MsLeft and mouse_x >= EXAMPLE_WIDTH then
+        @sidebar.click(mouse_x - EXAMPLE_WIDTH, mouse_y)
+      else
+        @current_example.button_down(id)
+      end
+    end
+  end
+  
+  def button_up(id)
+    @current_example.button_up(id)
+  end
+  
+  def needs_cursor?
+    true
+  end
+  
+  private
+  
+  def change_example(example)
+    if @current_example.class != example then
+      @current_example = nil
+      GC.start
+      @current_example = example.new
+    end
+  end
+  
+  def open_file_or_folder(filename)
+    if RUBY_PLATFORM =~ /darwin[0-9]*$/ then
+      `open '#{filename}'`
+    elsif RUBY_PLATFORM =~ /mingw[0-9]*$/ then
+      `explorer '#{filename}'`
+    else
+      `xdg-open '#{filename}'`
+    end
+  end
+end
+
+ExampleBox.new.show

data/examples/chipmunk_and_rmagick.rb

@@ -0,0 +1,152 @@
+# Encoding: UTF-8
+
+# Based on the C Demo3 demonstration distributed with Chipmunk.
+# Also with some help from the chipmunk_integration.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'
+
+# Layering of sprites
+module ZOrder
+  Background, Box = *0..1
+end
+
+WIDTH = 600
+HEIGHT = 600
+TICK = 1.0/60.0
+NUM_POLYGONS = 80
+NUM_SIDES = 4
+EDGE_SIZE = 15
+
+class ChipmunkAndRMagick < (Example rescue Gosu::Window)
+  def radians_to_vec2(radians)
+    CP::Vec2.new(Math::cos(radians), Math::sin(radians))
+  end
+  
+  def initialize
+    super WIDTH, HEIGHT
+    
+    self.caption = "Chipmunk, RMagick and Gosu"
+    
+    @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(WIDTH, HEIGHT, fill)
+    setup_triangles(background)
+    @background_image = Gosu::Image.new(background, :tileable => 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
+    8.times do |i|
+      8.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 << radians_to_vec2(angle) * 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(box_image)
+  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(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 > HEIGHT + EDGE_SIZE or pos.x > WIDTH + EDGE_SIZE or pos.x < -EDGE_SIZE
+      @body.p = CP::Vec2.new(rand * WIDTH, 0)
+    end
+  end
+  
+  def draw
+    @image.draw_rot(@body.p.x, @body.p.y, ZOrder::Box, @body.a.radians_to_gosu)
+  end
+end
+
+ChipmunkAndRMagick.new.show if __FILE__ == $0

data/examples/chipmunk_integration.rb

@@ -0,0 +1,278 @@
+# Encoding: UTF-8
+
+## File: ChipmunkIntegration.rb
+## Author: Dirk Johnson
+## Version: 1.0.0
+## Date: 2007-10-05
+## License: Same as for Gosu (MIT)
+## Comments: Based on the Gosu Ruby Tutorial, but incorporating the Chipmunk Physics Engine
+## See https://github.com/jlnr/gosu/wiki/Ruby-Chipmunk-Integration for the accompanying text.
+
+require 'rubygems'
+require 'gosu'
+require 'chipmunk'
+
+WIDTH = 600
+HEIGHT = 600
+
+# The number of steps to process every Gosu update
+# The Player ship can get going so fast as to "move through" a
+# star without triggering a collision; an increased number of
+# Chipmunk step calls per update will effectively avoid this issue
+SUBSTEPS = 6
+
+# Layering of objects
+module ZOrder
+  Background, Stars, Player, UI = *0..3
+end
+
+# This game will have one Player in the form of a ship
+class Player
+  attr_reader :shape
+
+  def initialize(shape)
+    @image = Gosu::Image.new("media/starfighter.bmp")
+    @shape = shape
+    @shape.body.p = CP::Vec2.new(0.0, 0.0) # position
+    @shape.body.v = CP::Vec2.new(0.0, 0.0) # velocity
+    
+    # Keep in mind that down the screen is positive y, which means that PI/2 radians,
+    # which you might consider the top in the traditional Trig unit circle sense is actually
+    # the bottom; thus 3PI/2 is the top
+    @shape.body.a = (3*Math::PI/2.0) # angle in radians; faces towards top of screen
+  end
+  
+  # Directly set the position of our Player
+  def warp(vect)
+    @shape.body.p = vect
+  end
+  
+  # Apply negative Torque; Chipmunk will do the rest
+  # SUBSTEPS is used as a divisor to keep turning rate constant
+  # even if the number of steps per update are adjusted
+  def turn_left
+    @shape.body.t -= 400.0/SUBSTEPS
+  end
+  
+  # Apply positive Torque; Chipmunk will do the rest
+  # SUBSTEPS is used as a divisor to keep turning rate constant
+  # even if the number of steps per update are adjusted
+  def turn_right
+    @shape.body.t += 400.0/SUBSTEPS
+  end
+  
+  # Apply forward force; Chipmunk will do the rest
+  # SUBSTEPS is used as a divisor to keep acceleration rate constant
+  # even if the number of steps per update are adjusted
+  # Here we must convert the angle (facing) of the body into
+  # forward momentum by creating a vector in the direction of the facing
+  # and with a magnitude representing the force we want to apply
+  def accelerate
+    @shape.body.apply_force((radians_to_vec2(@shape.body.a) * (3000.0/SUBSTEPS)), CP::Vec2.new(0.0, 0.0))
+  end
+  
+  # Apply even more forward force
+  # See accelerate for more details
+  def boost
+    @shape.body.apply_force((radians_to_vec2(@shape.body.a) * (3000.0)), CP::Vec2.new(0.0, 0.0))
+  end
+  
+  # Apply reverse force
+  # See accelerate for more details
+  def reverse
+    @shape.body.apply_force(-(radians_to_vec2(@shape.body.a) * (1000.0/SUBSTEPS)), CP::Vec2.new(0.0, 0.0))
+  end
+  
+  # Wrap to the other side of the screen when we fly off the edge
+  def validate_position
+    l_position = CP::Vec2.new(@shape.body.p.x % WIDTH, @shape.body.p.y % HEIGHT)
+    @shape.body.p = l_position
+  end
+  
+  def draw
+    @image.draw_rot(@shape.body.p.x, @shape.body.p.y, ZOrder::Player, @shape.body.a.radians_to_gosu)
+  end
+  
+  private
+  
+  # Convenience method for converting from radians to a Vec2 vector.
+  def radians_to_vec2(radians)
+    CP::Vec2.new(Math::cos(radians), Math::sin(radians))
+  end
+end
+
+# See how simple our Star is?
+# Of course... it just sits around and looks good...
+class Star
+  attr_reader :shape
+  
+  def initialize(animation, shape)
+    @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
+    @shape = shape
+    @shape.body.p = CP::Vec2.new(rand * WIDTH, rand * HEIGHT) # position
+    @shape.body.v = CP::Vec2.new(0.0, 0.0) # velocity
+    @shape.body.a = (3*Math::PI/2.0) # angle in radians; faces towards top of screen
+  end
+
+  def draw  
+    img = @animation[Gosu::milliseconds / 100 % @animation.size];
+    img.draw(@shape.body.p.x - img.width / 2.0, @shape.body.p.y - img.height / 2.0, ZOrder::Stars, 1, 1, @color, :add)
+  end
+end
+
+# The Gosu::Window is always the "environment" of our game
+# It also provides the pulse of our game
+class ChipmunkIntegration < (Example rescue Gosu::Window)
+  def initialize
+    super WIDTH, HEIGHT
+    
+    self.caption = "Gosu & Chipmunk Integration Demo"
+    
+    @background_image = Gosu::Image.new("media/space.png", :tileable => true)
+
+    # Put the beep here, as it is the environment now that determines collision
+    @beep = Gosu::Sample.new("media/beep.wav")
+    
+    # Put the score here, as it is the environment that tracks this now
+    @score = 0
+    @font = Gosu::Font.new(20)
+    
+    # Time increment over which to apply a physics "step" ("delta t")
+    @dt = (1.0/60.0)
+    
+    # Create our Space and set its damping
+    # A damping of 0.8 causes the ship bleed off its force and torque over time
+    # This is not realistic behavior in a vacuum of space, but it gives the game
+    # the feel I'd like in this situation
+    @space = CP::Space.new
+    @space.damping = 0.8    
+    
+    # Create the Body for the Player
+    body = CP::Body.new(10.0, 150.0)
+    
+    # In order to create a shape, we must first define it
+    # Chipmunk defines 3 types of Shapes: Segments, Circles and Polys
+    # We'll use s simple, 4 sided Poly for our Player (ship)
+    # You need to define the vectors so that the "top" of the Shape is towards 0 radians (the right)
+    shape_array = [CP::Vec2.new(-25.0, -25.0), CP::Vec2.new(-25.0, 25.0), CP::Vec2.new(25.0, 1.0), CP::Vec2.new(25.0, -1.0)]
+    shape = CP::Shape::Poly.new(body, shape_array, CP::Vec2.new(0,0))
+    
+    # The collision_type of a shape allows us to set up special collision behavior
+    # based on these types.  The actual value for the collision_type is arbitrary
+    # and, as long as it is consistent, will work for us; of course, it helps to have it make sense
+    shape.collision_type = :ship
+    
+    @space.add_body(body)
+    @space.add_shape(shape)
+
+    @player = Player.new(shape)
+    @player.warp(CP::Vec2.new(320, 240)) # move to the center of the window
+    
+    @star_anim = Gosu::Image.load_tiles("media/star.png", 25, 25)
+    @stars = Array.new
+        
+    # Here we define what is supposed to happen when a Player (ship) collides with a Star
+    # I create a @remove_shapes array because we cannot remove either Shapes or Bodies
+    # from Space within a collision closure, rather, we have to wait till the closure
+    # is through executing, then we can remove the Shapes and Bodies
+    # In this case, the Shapes and the Bodies they own are removed in the Gosu::Window.update phase
+    # by iterating over the @remove_shapes array
+    # Also note that both Shapes involved in the collision are passed into the closure
+    # in the same order that their collision_types are defined in the add_collision_func call
+    @remove_shapes = []
+    @space.add_collision_func(:ship, :star) do |ship_shape, star_shape|
+      @score += 10
+      @beep.play
+      @remove_shapes << star_shape
+    end
+    
+    # Here we tell Space that we don't want one star bumping into another
+    # The reason we need to do this is because when the Player hits a Star,
+    # the Star will travel until it is removed in the update cycle below
+    # which means it may collide and therefore push other Stars
+    # To see the effect, remove this line and play the game, every once in a while
+    # you'll see a Star moving
+    @space.add_collision_func(:star, :star, &nil)
+  end
+
+  def update
+    # Step the physics environment SUBSTEPS times each update
+    SUBSTEPS.times do
+      # This iterator makes an assumption of one Shape per Star making it safe to remove
+      # each Shape's Body as it comes up
+      # If our Stars had multiple Shapes, as would be required if we were to meticulously
+      # define their true boundaries, we couldn't do this as we would remove the Body
+      # multiple times
+      # We would probably solve this by creating a separate @remove_bodies array to remove the Bodies
+      # of the Stars that were gathered by the Player
+      @remove_shapes.each do |shape|
+        @stars.delete_if { |star| star.shape == shape }
+        @space.remove_body(shape.body)
+        @space.remove_shape(shape)
+      end
+      @remove_shapes.clear # clear out the shapes for next pass
+      
+      # When a force or torque is set on a Body, it is cumulative
+      # This means that the force you applied last SUBSTEP will compound with the
+      # force applied this SUBSTEP; which is probably not the behavior you want
+      # We reset the forces on the Player each SUBSTEP for this reason
+      @player.shape.body.reset_forces
+      
+      # Wrap around the screen to the other side
+      @player.validate_position
+      
+      # Check keyboard
+      if Gosu::button_down? Gosu::KbLeft
+        @player.turn_left
+      end
+      if Gosu::button_down? Gosu::KbRight
+        @player.turn_right
+      end
+      
+      if Gosu::button_down? Gosu::KbUp
+        if Gosu::button_down?(Gosu::KbRightShift) or Gosu::button_down?(Gosu::KbLeftShift)
+          @player.boost
+        else
+          @player.accelerate
+        end
+      elsif Gosu::button_down? Gosu::KbDown
+        @player.reverse
+      end
+      
+      # Perform the step over @dt period of time
+      # For best performance @dt should remain consistent for the game
+      @space.step(@dt)
+    end
+    
+    # Each update (not SUBSTEP) we see if we need to add more Stars
+    if rand(100) < 4 and @stars.size < 25 then
+      body = CP::Body.new(0.0001, 0.0001)
+      shape = CP::Shape::Circle.new(body, 25/2, CP::Vec2.new(0.0, 0.0))
+      shape.collision_type = :star
+      
+      @space.add_body(body)
+      @space.add_shape(shape)
+      
+      @stars.push(Star.new(@star_anim, shape))
+    end
+  end
+
+  def draw
+    @background_image.draw(0, 0, ZOrder::Background)
+    @player.draw
+    @stars.each { |star| star.draw }
+    @font.draw("Score: #{@score}", 10, 10, ZOrder::UI, 1.0, 1.0, 0xff_ffff00)
+  end
+
+  def button_down(id)
+    if id == Gosu::KbEscape
+      close
+    end
+  end
+end
+
+ChipmunkIntegration.new.show if __FILE__ == $0