chingu 0.7.0 → 0.7.5

data/examples/example11_animation.rb

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
 require 'rubygems'
-require 'opengl'
 require File.join(File.dirname($0), "..", "lib", "chingu")
 include Gosu
 include Chingu
@@ -14,14 +13,15 @@ class Game < Chingu::Window
   def initialize
     super    
     @factor = 6
-    self.input = { :escape => :exit }          
+    self.input = { :escape => :exit }
+		Gosu::enable_undocumented_retrofication
     self.caption = "Chingu::Animation / retrofy example. Move with arrows!"
     Droid.create(:x => $window.width/2, :y => $window.height/2)
   end
 end
 
 class Droid < Chingu::GameObject
-  has_traits :timer
+  traits :timer
   
   def initialize(options = {})
     super
@@ -33,18 +33,11 @@ class Droid < Chingu::GameObject
     self.input = [:holding_left, :holding_right, :holding_up, :holding_down]
     
     # Load the full animation from tile-file media/droid.bmp
-    @full_animation = Chingu::Animation.new(:file => "droid.bmp", :size => [11,16]).retrofy
+    @animation = Chingu::Animation.new(:file => "droid_11x15.bmp")
+    @animation.frame_names = { :scan => 0..5, :up => 6..7, :down => 8..9, :left => 10..11, :right => 12..13 }
     
-    # Create new animations from specific frames and stuff them into easy to access hash
-    @animations = {}
-    @animations[:scan] = @full_animation[0..5]
-    @animations[:up] = @full_animation[6..7]
-    @animations[:down] = @full_animation[8..9]
-    @animations[:left] = @full_animation[10..11]
-    @animations[:right] = @full_animation[12..13]
-    
-    # Start out by animation frames 0-5 (contained by @animations[:scan])
-    @animation = @animations[:scan]
+    # Start out by animation frames 0-5 (contained by @animation[:scan])
+    @frame_name = :scan
     
     self.factor = $window.factor
     @last_x, @last_y = @x, @y
@@ -53,22 +46,22 @@ class Droid < Chingu::GameObject
     
   def holding_left
     @x -= 2
-    @animation = @animations[:left]
+    @frame_name = :left
   end
 
   def holding_right
     @x += 2
-    @animation = @animations[:right]
+    @frame_name = :right
   end
-
+  
   def holding_up
     @y -= 2
-    @animation = @animations[:up]
+    @frame_name = :up
   end
 
   def holding_down
     @y += 2
-    @animation = @animations[:down]
+    @frame_name = :down
   end
 
   # We don't need to call super() in update().
@@ -77,14 +70,12 @@ class Droid < Chingu::GameObject
     
     # Move the animation forward by fetching the next frame and putting it into @image
     # @image is drawn by default by GameObject#draw
-    @image = @animation.next
+    @image = @animation[@frame_name].next
     
     #
     # If droid stands still, use the scanning animation
     #
-    if @x == @last_x && @y == @last_y
-      @animation = @animations[:scan]
-    end
+    @frame_name = :scan if @x == @last_x && @y == @last_y
     
     @x, @y = @last_x, @last_y if outside_window?  # return to previous coordinates if outside window
     @last_x, @last_y = @x, @y                     # save current coordinates for possible use next time

data/examples/example12_trait_timer.rb

@@ -18,7 +18,7 @@ class Game < Chingu::Window
 end
 
 class Cube < GameObject
-  has_trait :timer
+  trait :timer
   
   def initialize(options)
     super

data/examples/example13_high_scores.rb

@@ -65,7 +65,7 @@ end
 # colorful pulsating text...
 #
 class PulsatingText < Text
-  has_traits :timer, :effect
+  traits :timer, :effect
   
   def initialize(text, options = {})
     super(text, options)

data/examples/example14_bounding_box_circle.rb

@@ -64,11 +64,10 @@ class Game < Chingu::Window
 end
 
 class Circle < GameObject
-  has_trait :bounding_circle, :debug => true
-  has_traits :velocity, :collision_detection
+  trait :bounding_circle, :debug => true
+  traits :velocity, :collision_detection
   
-  def initialize(options)
-    super
+  def setup
     @image = Image["circle.png"]
     self.velocity_x = 3 - rand * 6
     self.velocity_y = 3 - rand * 6
@@ -89,11 +88,10 @@ class Circle < GameObject
 end
 
 class Box < GameObject
-  has_trait :bounding_box, :debug => true
-  has_traits :velocity, :collision_detection
+  trait :bounding_box, :debug => true
+  traits :velocity, :collision_detection
   
-  def initialize(options)
-    super
+  def setup
     @image = Image["rect.png"]
     self.velocity_x = 3 - rand * 6
     self.velocity_y = 3 - rand * 6
@@ -104,8 +102,6 @@ class Box < GameObject
   def update
     self.velocity_x = -self.velocity_x  if @x < 0 || @x > $window.width
     self.velocity_y = -self.velocity_y  if @y < 0 || @y > $window.height
-    #@x = @x.to_i
-    #@y = @y.to_i
   end
 end
 

data/examples/example15_trait_timer2.rb

@@ -16,7 +16,7 @@ class Game < Chingu::Window
 end
 
 class Stuff < GameState
-  has_trait :timer
+  trait :timer
   
   def initialize(options = {})
     super

data/examples/example16_online_high_scores.rb

@@ -57,7 +57,7 @@ end
 # colorful pulsating text...
 #
 class PulsatingText < Text
-  has_traits :timer, :effect
+  traits :timer, :effect
   @@red = Color.new(0xFFFF0000)
   @@green = Color.new(0xFF00FF00)
   @@blue = Color.new(0xFF0000FF)

data/examples/example17_gosu_tutorial.rb

@@ -38,8 +38,8 @@ class Game < Chingu::Window
 end
 
 class Player < GameObject
-  has_trait :bounding_circle, :debug => DEBUG
-  has_traits :collision_detection, :effect, :velocity
+  trait :bounding_circle, :debug => DEBUG
+  traits :collision_detection, :effect, :velocity
   
   def initialize(options={})
     super(options)
@@ -73,8 +73,8 @@ class Player < GameObject
 end
 
 class Star < GameObject
-  has_trait :bounding_circle, :debug => DEBUG
-  has_trait :collision_detection
+  trait :bounding_circle, :debug => DEBUG
+  trait :collision_detection
   
   def initialize(options={})
     super(:zorder=>1)

data/examples/example18_animation_trait.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require File.join(File.dirname($0), "..", "lib", "chingu")
+include Gosu
+include Chingu
+
+#
+# animation-trait example
+# 
+class Game < Chingu::Window	
+  def initialize
+    super(400, 400)
+    self.input = { :escape => :exit }
+    switch_game_state(Play)
+  end
+end
+
+class Play < Chingu::GameState
+  trait :timer
+	
+  def setup
+    Droid.create(:x => 200, :y => 300, :factor => 4, :alpha => 100)
+    every(1000) { Spaceship.create(:x => 10, :y => 300, :velocity_x => 1) }
+    every(1000) { Plane.create(:x => 10, :y => 350, :velocity => [1,0] ) }
+    every(500) { FireBullet.create(:x => 10, :y => 370, :velocity_x => 1) }
+    every(500) { Star.create(:x => 400, :y => 400, :velocity => [-2,-rand*2]) }
+    #every(400) { Heli.create(:x => 10, :y => 10, :velocity_x => 1) }
+  end
+
+  def update
+    super
+    game_objects.select { |game_object| game_object.outside_window? }.each(&:destroy)
+    $window.caption = "game_objects: #{game_objects.size}"
+  end
+end
+	
+class Actor < GameObject
+  trait :velocity
+  
+  def setup
+    @image = Image["#{self.filename}.png"]
+    @zorder = 10
+  end
+  
+end
+
+class Spaceship < Actor; end  # spaceship.png will be loaded
+class Plane < Actor; end      # plane.png will be loaded
+class FireBullet < Actor; end # fire_bullet.png will be loaded
+
+#
+# droid_11x16.png will be loaded and animated with :delay parameter, each frame beeing 11 x 16 pixels
+#
+class Droid < Actor
+  trait :animation, :delay => 200
+  
+  def update
+    @image = self.animation.next  if self.animation
+  end
+end
+
+#
+# heli.png will be loaded
+# since it doesn't contain any framesize information, chingu will assume same width and height
+#
+class Heli < Actor
+  trait :animation, :delay => 200
+  
+  def update
+    @image = self.animation.next  if self.animation
+    p self.animation
+  end
+end
+
+#
+# star_25x25_default.png and star_25x25_explode.png will be loaded.
+# Access the 2 animation-"states" with self.animations[:default] and self.animations[:explode]
+# self.animation will point to self.animations[:default]
+#
+class Star < Actor
+  trait :animation, :delay => 100
+  
+  def setup
+    self.animations[:explode].loop = false
+  end
+  
+  def update
+    
+    if @x < $window.width/2 || @y < $window.height/2
+      @image = self.animations[:explode].next
+    else
+      @image = self.animations[:default].next
+    end
+  end
+  
+end
+
+Game.new.show

data/examples/example19_edit_viewport.rb

@@ -0,0 +1,223 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require File.join(File.dirname($0), "..", "lib", "chingu")
+include Gosu
+include Chingu
+
+#
+# viewport-trait / edit-trait example
+#
+# Press 'E' when demo is running to edit the playfield!
+# 
+class Game < Chingu::Window 
+  def setup
+    Gosu::enable_undocumented_retrofication
+    self.factor = 3
+    #self.input = { :escape => :exit }
+    switch_game_state(Level.new)
+  end    
+end
+
+class Level < GameState
+  #
+  # This adds accessor 'viewport' to class and overrides draw() to use it.
+  #
+  trait :viewport
+  
+  #
+  # We create our 3 different game objects in this order: 
+  # 1) map 2) stars 3) player
+  # Since we don't give any zorders Chingu automatically increments zorder between each object created, putting player on top
+  #
+  def setup
+    self.input = { :escape => :exit, :e => :edit } 
+
+    Sound["laser.wav"] # cache sound by accessing it once
+    
+    self.viewport.lag = 0                           # 0 = no lag, 0.99 = a lot of lag.
+    self.viewport.game_area = [0, 0, 1000, 1000]    # Viewport restrictions, full "game world/map/area"
+    
+    #
+    # Create 40 stars scattered around the map. This is now replaced by load_game_objects()
+    # ## 40.times { |nr| Star.create(:x => rand * self.viewport.x_max, :y => rand * self.viewport.y_max) }
+    #
+    load_game_objects( :file => "example19_game_objects.yml" )
+  
+    # Create our mechanic star-hunter
+    @droid = Droid.create(:x => 100, :y => 100)    
+  end
+
+  def edit
+    push_game_state(GameStates::Edit.new(:file => "example19_game_objects.yml", :classes => [Star, StoneWall]))
+  end
+  
+  def update    
+    super
+
+    # Droid can pick up starts
+    @droid.each_collision(Star) do |droid, star|
+      star.destroy
+      Sound["laser.wav"].play(0.5)
+    end
+    
+    # Bullets collide with stone_walls
+    Bullet.each_collision(StoneWall) do |bullet, stone_wall|
+      bullet.die
+      stone_wall.destroy
+    end
+    
+    # Destroy game objects that travels outside the viewport
+    game_objects.destroy_if { |game_object| self.viewport.outside_game_area?(game_object) }
+    
+    #
+    # Align viewport with the droid in the middle.
+    # This will make droid will be in the center of the screen all the time...
+    # ...except when hitting outer borders and viewport x_min/max & y_min/max kicks in.
+    #
+    self.viewport.center_around(@droid)
+        
+    $window.caption = "viewport/edit-trait example. Move with arrows! Press 'E' to Edit. x/y: #{@droid.x.to_i}/#{@droid.y.to_i} - viewport x/y: #{self.viewport.x.to_i}/#{self.viewport.y.to_i} - FPS: #{$window.fps}"
+  end
+end
+
+class Droid < Chingu::GameObject
+  trait :bounding_box, :debug => false
+  traits :timer, :collision_detection , :timer
+  attr_accessor :last_x, :last_y, :direction
+  
+  def setup
+    #
+    # This shows up the shortened version of input-maps, where each key calls a method of the very same name.
+    # Use this by giving an array of symbols to self.input
+    #
+    self.input = {  [:holding_left, :holding_a] => :holding_left, 
+                    [:holding_right, :holding_d] => :holding_right,
+                    [:holding_up, :holding_w] => :holding_up,
+                    [:holding_down, :holding_s] => :holding_down,
+                    :space => :fire
+                  }
+    
+    # Load the full animation from tile-file media/droid.bmp
+    @animations = Chingu::Animation.new(:file => "droid_11x15.bmp")
+    @animations.frame_names = { :scan => 0..5, :up => 6..7, :down => 8..9, :left => 10..11, :right => 12..13 }
+    
+    # Start out by animation frames 0-5 (contained by @animations[:scan])
+    @animation = @animations[:scan]
+    @speed = 3
+    @last_x, @last_y = @x, @y
+    
+    update
+  end
+    
+  def holding_left
+    move(-@speed, 0)
+    @animation = @animations[:left]
+  end
+
+  def holding_right
+    move(@speed, 0)
+    @animation = @animations[:right]
+  end
+
+  def holding_up
+    move(0, -@speed)
+    @animation = @animations[:up]
+  end
+
+  def holding_down
+    move(0, @speed)
+    @animation = @animations[:down]
+  end
+
+  def fire
+    Bullet.create(:x => self.x, :y => self.y, :velocity => @direction)
+  end
+  
+  #
+  # Revert player to last positions when:
+  # - player is outside the viewport
+  # - player is colliding with at least one object of class StoneWall
+  #
+  def move(x,y)
+    @x += x
+    @x = @last_x  if self.parent.viewport.outside_game_area?(self) || self.first_collision(StoneWall)
+
+    @y += y
+    @y = @last_y  if self.parent.viewport.outside_game_area?(self) || self.first_collision(StoneWall)
+  end
+  
+  # We don't need to call super() in update().
+  # By default GameObject#update is empty since it doesn't contain any gamelogic to speak of.
+  def update
+    
+    # Move the animation forward by fetching the next frame and putting it into @image
+    # @image is drawn by default by GameObject#draw
+    @image = @animation.next
+    
+    if @x == @last_x && @y == @last_y
+      # droid stands still, use the scanning animation
+      @animation = @animations[:scan]
+    else
+      # Save the direction to use with bullets when firing
+      @direction = [@x - @last_x, @y - @last_y]
+    end
+    
+    @last_x, @last_y = @x, @y
+  end
+end
+
+class Star < GameObject
+  trait :bounding_circle, :debug => false
+  trait :collision_detection
+  
+  def setup    
+    @animation = Chingu::Animation.new(:file => "Star.png", :size => 25)
+    @image = @animation.next
+    self.color = Gosu::Color.new(0xff000000)
+    self.color.red = rand(255 - 40) + 40
+    self.color.green = rand(255 - 40) + 40
+    self.color.blue = rand(255 - 40) + 40
+    self.factor = 1
+    #self.rotation_center = :center
+    
+    #
+    # A cached bounding circle will not adapt to changes in size, but it will follow objects X / Y
+    # Same is true for "cache_bounding_box"
+    #
+    cache_bounding_circle
+  end
+  
+  def update
+    # Move the animation forward by fetching the next frame and putting it into @image
+    # @image is drawn by default by GameObject#draw
+    @image = @animation.next
+  end
+end
+
+class StoneWall < GameObject
+  trait :bounding_box, :debug => false
+  trait :collision_detection
+  
+  def setup
+    @image = Image["stone_wall.bmp"]
+    self.factor = 1
+  end
+end
+
+class Bullet < GameObject
+  traits :bounding_circle, :collision_detection, :velocity, :timer
+  
+  def setup
+    @image = Image["fire_bullet.png"]
+    self.factor = 1
+    self.velocity_x *= 2
+    self.velocity_y *= 2
+  end
+  
+  def die
+    self.velocity = [0,0]   
+    between(0,50) { self.factor += 0.3; self.alpha -= 10; }.then { destroy }
+  end
+end
+
+Game.new.show