chingu 0.5.5.3

data/examples/example5.rb

@@ -0,0 +1,107 @@
+require 'rubygems'
+require File.join(File.dirname($0), "..", "lib", "chingu")
+include Gosu
+
+#
+# Using Chingus game state mananger in pure Gosu.
+#
+class Game < Gosu::Window
+  attr_reader :font
+  def initialize
+    $window = super(800,600,false)
+    
+    @font = Font.new($window, default_font_name(), 20)
+    
+    # Create our game state manager
+    @manager = Chingu::GameStateManager.new
+
+    # Switch to first state
+    @manager.switch_game_state(State1)
+
+    # Insert FadeTo state between every push, pop and switch
+    @manager.transitional_game_state(Chingu::GameStates::FadeTo, :speed => 10, :game_state_manager => @manager)    
+  end
+
+  def button_down(id)
+    # This makes sure button_down(id) is called on the active game state
+    # Enables input-handling in game states, you might wanna do the same with button_up()
+    @manager.button_down(id)
+    
+    if @manager.current_game_state.class != Chingu::GameStates::FadeTo
+    
+      @manager.push_game_state(State1)  if(id==Button::Kb1)
+      @manager.push_game_state(State2)  if(id==Button::Kb2)
+      @manager.push_game_state(State3)  if(id==Button::Kb3)
+      @manager.push_game_state(Chingu::GameStates::Pause)  if(id==Button::KbP)
+      @manager.pop_game_state           if(id==Button::KbBackspace)
+    end
+    
+    exit                             if(id==Button::KbEscape)
+  end
+  
+  def update
+    # This makes sure update() is called on the active game state
+    @manager.update
+  end
+  
+  def draw
+    @font.draw("Game State Stack. 1-3 to push a game state. Backspace to pop.", 100, 200, 0)
+    @manager.game_states.each_with_index do |game_state, index|
+      @font.draw("#{index+1}) #{game_state.to_s}", 100, 220+index*20, 0)
+    end
+    
+    # This makes sure draw() is called on the active game state
+    @manager.draw
+  end
+end
+
+class State1 < Chingu::GameState
+  def setup
+    @spinner = ["|", "/", "-", "\\", "|", "/", "-", "\\"]
+    @spinner_index = 0.0
+  end
+  
+  def update
+    @spinner_index += 0.1
+    @spinner_index = 0    if @spinner_index >= @spinner.size
+  end
+  
+  def draw
+    $window.font.draw("Inside State1: #{@spinner[@spinner_index.to_i]}", 100, 100, 0)
+  end
+end
+
+class State2 < Chingu::GameState
+  def setup
+    @factor = 0.0
+    @ticks = 0.0
+  end
+  
+  def update
+    @ticks += 0.01
+    @factor = 1.5 + Math.sin(@ticks).to_f
+  end
+  
+  def draw
+    $window.font.draw("Inside State2 - factor_y: #{@factor.to_s}", 100, 100, 0, 1.0, @factor)
+  end
+end
+
+
+class State3 < Chingu::GameState   
+  def setup
+    @factor = 0.0
+    @ticks = 0.0
+  end
+  
+  def update
+    @ticks += 0.01
+    @factor = 1.5 + Math.sin(@ticks).to_f
+  end  
+  def draw
+    $window.font.draw("Inside State3 - factor_x: #{@factor.to_s}", 100, 100, 0, @factor, 1.0)
+  end
+end
+
+
+Game.new.show

data/examples/example6.rb

@@ -0,0 +1,57 @@
+require 'rubygems'
+require File.join(File.dirname($0), "..", "lib", "chingu")
+include Gosu
+
+#
+# Example of using a special GameState to fade between game states
+#
+# Using a simple game state, Chingu::GameStates::FadeTo, shipped with Chingu.
+#
+class Game < Chingu::Window
+  def initialize
+    super(640,800)
+    switch_game_state(State1)
+    self.input = {:space => :push, :return => :switch, :esc => :exit}
+    self.caption = "Example of transitional game state FadeTo when switchin between two game states"
+    transitional_game_state(Chingu::GameStates::FadeTo, :speed => 10)
+  end
+  
+  def push
+    #
+    # Since we have a transitional game state set, the bellow code in practice become:
+    #
+    # if current_game_state.is_a?(State1)
+    #   push_game_state(Chingu::GameStates::FadeTo.new(State2.new, :speed => 10))
+    # elsif current_game_state.is_a?(State2)
+    #   push_game_state(Chingu::GameStates::FadeTo.new(State1.new, :speed => 10))
+    # end    
+    #
+    if current_game_state.is_a?(State1)
+      push_game_state(State2.new)
+    elsif current_game_state.is_a?(State2)
+      push_game_state(State1.new)
+    end
+  end
+  
+  def switch
+    if current_game_state.is_a?(State1)
+      switch_game_state(State2.new)
+    elsif current_game_state.is_a?(State2)
+      switch_game_state(State1.new)
+    end
+  end
+end
+
+class State1 < Chingu::GameState
+  def draw
+    Image["ruby.png"].draw(0,0,0)
+  end
+end
+
+class State2 < Chingu::GameState 
+  def draw
+    Image["video_games.png"].draw(0,0,0)
+  end
+end
+
+Game.new.show

data/examples/example7.rb

@@ -0,0 +1,133 @@
+require 'rubygems'
+require File.join(File.dirname($0), "..", "lib", "chingu")
+include Gosu
+include Chingu
+
+#
+# GFXHelpers example - demonstrating Chingus GFX
+#
+class Game < Chingu::Window
+  def initialize
+    super(640,400)
+    self.input = {:space => :next_effect, :esc => :exit}
+    self.caption = "Example of Chingus GFX Helpers"
+    
+    push_game_state(Fill)
+    push_game_state(FillRect)
+    push_game_state(FillGradient)
+    push_game_state(FillGradientRect)
+    push_game_state(Particles)
+  end
+  
+  def next_effect
+    pop_game_state
+  end
+end
+
+
+class Fill < Chingu::GameState 
+  def setup
+    @white = Color.new(255,255,255,255)
+  end
+  def draw
+    $window.caption = "fill (space to continue)"
+    fill(@white)
+  end
+end
+
+class FillRect < Chingu::GameState 
+  def setup
+    @white = Color.new(255,255,255,255)
+  end
+  def draw
+    $window.caption = "fill_rect (space to continue)"
+    fill_rect([10,10,100,100], @white)
+  end
+end
+
+class FillGradient < Chingu::GameState 
+  def setup
+    @pinkish = Color.new(0xFFCE17B6)
+    @blueish = Color.new(0xFF6DA9FF)
+  end
+  
+  def draw
+    $window.caption = "fill_gradient (space to continue)"
+    fill_gradient(:from => @pinkish, :to => @blueish, :orientation => :vertical)
+  end
+end
+
+class FillGradientRect < Chingu::GameState 
+  def setup
+    @color1 = Color.new(0xFFFFEA02)
+    @color2 = Color.new(0xFF078B20)
+  end
+  
+  def draw
+    $window.caption = "fill_gradient with :rect-option (space to continue)"
+    fill_gradient(:from => @color1, :to => @color2, :rect => [100,100,200,200], :orientation => :horizontal)
+  end
+end
+
+class Particles < Chingu::GameState
+  def setup
+    @color1 = Color.new(0xFFFFEA02)
+    @color2 = Color.new(0xFF078B20)
+    @blue_laserish = Color.new(0xFF86EFFF)
+    @red = Color.new(0xFFFF0000)
+    @white = Color.new(0xFFFFFFFF)
+    @yellow = Color.new(0xFFF9F120)
+    
+    # Thanks jsb in #gosu of Encave-fame for fireball.png :)
+    @fireball_animation = Chingu::Animation.new(:file => media_path("fireball.png"), :width => 32, :height => 32)
+    @ground_y = $window.height * 0.95
+  end
+  
+  def update
+    #
+    # Fire 1. Dies quickly (big :fade). Small in size (small :zoom)
+    #
+    Chingu::Particle.create( :x => 100, 
+                          :y => @ground_y, 
+                          :animation => @fireball_animation,
+                          :zooming => +0.05, 
+                          :fading => -10, 
+                          :rotating => +1,
+                          :mode => :default
+                        )
+
+    #
+    # Fire 2. Higher flame, :fade only -4. Wide Flame with bigger :zoom.
+    #
+    Chingu::Particle.create( :x => 300, 
+                          :y => @ground_y, 
+                          :animation => @fireball_animation, 
+                          :zooming => +0.2, 
+                          :fading => -4, 
+                          :rotating => +3,
+                          :mode => :default
+                        )
+    #
+    # Fire 3. Blue plasma with smooth particle.png and color-overlay.
+    #
+    Chingu::Particle.create( :x => 500, 
+                          :y => @ground_y,
+                          :image => "particle.png", 
+                          :color => @blue_laserish,
+                          :mode => :additive
+                        )
+
+    Particle.all.each { |particle| particle.y -= 5; particle.x += 2 - rand(4) }
+    game_objects.destroy_if { |object| object.outside_window? || object.color.alpha == 0 }
+    super
+  end
+  
+  def draw
+    $window.caption = "particle example (space to continue) [particles#: #{game_objects.size} - framerate: #{$window.fps}]"
+    fill_gradient(:from => Color.new(255,0,0,0), :to => Color.new(255,60,60,80), :rect => [0,0,$window.width,@ground_y])
+    fill_gradient(:from => Color.new(255,100,100,100), :to => Color.new(255,50,50,50), :rect => [0,@ground_y,$window.width,$window.height-@ground_y])
+    super
+  end
+end
+
+Game.new.show

data/examples/example8.rb

@@ -0,0 +1,109 @@
+require 'rubygems'
+require File.join(File.dirname($0), "..", "lib", "chingu")
+include Gosu
+include Chingu
+
+#
+# Demonstrating domponents "velocity" and "effect"
+#
+class Game < Chingu::Window
+  def initialize
+    super(640,400)
+    self.input = {:esc => :exit}
+    self.caption = "Example of game object traits 'velocity' and 'effect'"
+    push_game_state(Particles)
+    puts RUBY_VERSION
+  end
+  
+  def next_effect; pop_game_state; end
+end
+
+class Plasma < Chingu::GameObject
+  has_traits :velocity, :effect
+  
+  def initialize(options)
+    super    
+    @image = Image["particle.png"]
+    @mode = :additive
+    
+    # initialize with a rightwards velocity with some damping to look more realistic
+    @velocity_x = options[:velocity_x] || 10
+    @acceleration_x = -0.1
+    
+    # Simulate gravity
+    @acceleration_y = 0.4
+  end  
+end
+
+class Particles < Chingu::GameState
+  def setup
+    @color1 = Color.new(0xFFFFEA02)
+    @color2 = Color.new(0xFF078B20)    
+    
+    #
+    # +1 fps
+    #
+    #@ground_y = $window.height * 0.95
+    @ground_y = ($window.height * 0.95).to_i
+  end
+  
+  def update
+    
+    #
+    # old velocity.rb 350 particles, 49 fps
+    # first optimization: 490 particles, 47 fps (350 @ 60)
+    # optimized GameObject if/elsif: 490 particles, 50 fps
+    #
+    Plasma.create(:x => 0, :y => 0 + rand(5), :color => Color.new(0xFF86EFFF), :velocity_x => 10)
+    Plasma.create(:x => 0, :y => 50 + rand(5), :color => Color.new(0xFF86EFFF), :velocity_x => 14)
+    Plasma.create(:x => 0, :y => 100 + rand(5), :color => Color.new(0xFF86EFFF), :velocity_x => 7)
+    Plasma.create(:x => 0, :y => 200 + rand(5), :color => Color.new(0xFF86EFFF), :velocity_x => 6)
+        
+    Plasma.all.each do |particle|
+      #
+      # +1 fps
+      #
+      # particle.x += 1 - rand(2)
+      # -just removed, not replaced-
+            
+      #
+      # If particle hits the ground:
+      #
+      if particle.y >= @ground_y
+        
+        # 1) "Bounce" it up particle by reversing velocity_y with damping
+        slower = particle.velocity_y/3
+        particle.velocity_y = -(slower + rand(slower))
+        
+        # 2) "Bounce" it randomly to left and right
+        if rand(2) == 0
+          particle.velocity_x = particle.velocity_y/2 + rand(2)     # Randomr.randomr / 50
+          particle.acceleration_x = -0.02
+        else
+          particle.velocity_x = -particle.velocity_y/2 - rand(2)    # Randomr.randomr / 50
+          particle.acceleration_x = 0.02
+        end
+        
+        # 3) Start fading the alphachannel
+        particle.fading = -3
+      end
+    end
+    
+    #
+    # +4 fps
+    #
+    #self.game_objects.reject! { |object| object.outside_window? || object.color.alpha == 0 }
+    self.game_objects.destroy_if { |object| object.color.alpha == 0 }
+    
+    super
+  end
+  
+  def draw
+    $window.caption = "particle example (esc to quit) [particles#: #{game_objects.size} - framerate: #{$window.fps}]"
+    fill_gradient(:from => Color.new(255,0,0,0), :to => Color.new(255,60,60,80), :rect => [0,0,$window.width,@ground_y])
+    fill_gradient(:from => Color.new(255,100,100,100), :to => Color.new(255,50,50,50), :rect => [0,@ground_y,$window.width,$window.height-@ground_y])
+    super
+  end
+end
+
+Game.new.show

data/examples/example9.rb

@@ -0,0 +1,106 @@
+require 'rubygems'
+require File.join(File.dirname($0), "..", "lib", "chingu")
+include Gosu
+include Chingu
+
+#
+# Demonstrating domponents "velocity" and "effect"
+#
+class Game < Chingu::Window
+  def initialize
+    super(800,800)
+    self.input = {:esc => :exit}
+    self.caption = "Example of game object traits 'velocity' and 'effect'"
+    push_game_state(ParticleState)
+  end
+  
+  def next_effect; pop_game_state; end
+end
+
+class FireCube < Chingu::GameObject
+  has_trait :velocity
+  has_trait :effect
+  has_trait :collision_detection
+  #
+  # TODO:
+  # has_trait :collision_detection, :type => :bounding_box
+  # has_trait :collision_detection, :type => :radius
+  #
+  
+  attr_accessor :color, :radius
+  
+  def initialize(options)
+    super
+    @mode = :additive
+    
+    # initialize with a rightwards velocity with some damping to look more realistic
+    @velocity_x = options[:velocity_x] || 1 + rand(2)
+    @velocity_y = options[:velocity_y] || 1 + rand(2)
+    
+    @bounding_box = Rect.new([@x, @y, 10, 10])
+    @radius = 6
+    
+    @blue = Color.new(255,100,255,255)
+    @red = Color.new(255,255,10,10)
+    @color = @blue
+  end
+  
+  def draw
+    $window.fill_rect(@bounding_box, @color)
+  end
+  
+  def update
+    @color = @blue
+  end
+  
+  def collides?(object2)
+    radius_collision?(object2)
+  end
+    
+  def die!
+    @color = @red
+  end
+  
+end
+
+class ParticleState < Chingu::GameState
+  def setup    
+    self.input = { :space => :new_fire_cube }
+    100.times { new_fire_cube }
+  end
+  
+  def new_fire_cube
+    FireCube.create(:x => rand($window.width), :y => rand($window.height))
+  end
+  
+  def update
+    super
+    
+    FireCube.all.each do |particle|
+      if particle.x < 0 || particle.x > $window.width
+        particle.velocity_x = -particle.velocity_x
+      end
+      
+      if particle.y < 0 || particle.y > $window.height
+        particle.velocity_y = -particle.velocity_y
+      end
+    end
+    
+    #
+    # GameObject.each_collsion / each_radius_collision wont collide an object with itself
+    #
+    FireCube.each_radius_collision(FireCube) do |cube1, cube2|
+      cube1.die!
+      cube2.die!
+    end
+      
+    game_objects.destroy_if { |object| object.color.alpha == 0 }
+  end
+  
+  def draw
+    $window.caption = "radius based iterative collision detection. Particles#: #{game_objects.size}, Collisionchecks each gameloop: ~#{game_objects.size**2} - FPS: #{$window.fps}"
+    super
+  end
+end
+
+Game.new.show