chingu 0.5.5.3

data/examples/example11.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require File.join(File.dirname($0), "..", "lib", "chingu")
+include Gosu
+
+#
+# Parallax-example
+# Images from http://en.wikipedia.org/wiki/Parallax_scrolling
+#
+class Game < Chingu::Window
+  def initialize
+    super    
+    self.input = {  :holding_left => :scroll_left,
+                    :holding_right => :scroll_right,
+                    :holding_up => :scroll_up,
+                    :holding_down => :scroll_down, 
+                    :escape => :exit }
+          
+    self.caption = "Chingu::Parallax example. Scroll with left/right arrows."
+    
+    @parallax = Chingu::Parallax.create(:x => 0, :y => 0, :center_x => 0, :center_y => 0)
+    
+    #
+    # If no :zorder is given to @parallax.add_background it defaults to first added -> lowest zorder
+    # Everywhere the :image argument is used, theese 2 values are the Same:
+    # 1) Image["foo.png"]  2) "foo.png"
+    #
+    # TODO: scrolling to left borks outm, fix. + get rid of center_x / center_y args in a clean way.
+    @parallax << {:image => "paralaxx2", :damping => 100, :center => 0)
+    @parallax << {:image => "parallax-scroll-example-layer-1.png", :damping => 10, :center => 0)
+    @parallax << {:image => "paralaxx2.png", :damping => 5, :center => 0)
+  end
+  
+  def scroll_left
+    @parallax.x -= 2
+  end
+  
+  def scroll_right
+    @parallax.x += 2
+  end  
+  
+  def scroll_up
+    @parallax.y -= 2
+  end
+  
+  def scroll_down
+    @parallax.y += 2
+  end  
+  
+end
+
+Game.new.show

data/examples/example12.rb

@@ -0,0 +1,67 @@
+require 'rubygems'
+require File.join(File.dirname($0), "..", "lib", "chingu")
+include Gosu
+include Chingu
+
+class Game < Chingu::Window
+  def initialize
+    super(640,400)
+    self.input = {:esc => :exit}
+    self.caption = "Example of Chingus :timer trait (arrows,space,return sets timers that affects @x,@y & @color)"
+    
+    Cube.create(:x => 200, :y => 200)
+  end
+end
+
+class Cube < GameObject
+  has_trait :timer
+  
+  def initialize(options)
+    super
+    @white = Color.new(0xFFFFFFFF)
+    @red = Color.new(0xFFFF0000)
+    @blue = Color.new(0xFF0000FF)
+    self.input = {  :left => :left, :right => :right, :up => :up, :down => :down, 
+                    :space => :shake1, :return => :shake2 }
+  end
+  
+  def left
+    during(500) { @x -= 1 }
+  end
+  
+  def right
+    during(500) { @x += 1 }
+  end
+  
+  def up
+    @color = @red
+    during(500) { @y -= 1 }.then { @color = @white }
+  end
+
+  def down
+    @color = @blue
+    during(500) { @y += 1 }.then { @color = @white }
+  end
+
+  def shake1
+    #
+    # Nesting works too!
+    #
+    during(50) {@y -= 4}.then  { during(100) {@y += 4}.then { during(50) {@y -= 4} } }
+  end
+  
+  def shake2
+    #
+    # Does the exact same as "shake1" but using between() instead of during()
+    #
+    between(0,50) {@y -= 4}
+    between(50,150) {@y += 4}
+    between(150,200) {@y -= 4}
+  end
+  
+  def draw
+    $window.fill_rect([@x, @y, 40, 40], @color)
+  end
+end
+
+Game.new.show

data/examples/example2.rb

@@ -0,0 +1,115 @@
+require 'rubygems'
+require File.join(File.dirname($0), "..", "lib", "chingu")
+include Gosu
+
+#
+# A little more complicated example where we do our own #update and #draw code.
+# We also add another Actor - a bullet fired with space.
+#
+# Also tests out the Debug game state.
+#
+class Game < Chingu::Window
+  def initialize
+    #
+    # See http://www.libgosu.org/rdoc/classes/Gosu/Window.html#M000034 for options
+    # By default Chingu does 640 x 480 non-fullscreen.
+    #
+    super
+    
+    push_game_state(Play)
+  end
+end
+
+#
+# Our Player
+#
+class Player < Chingu::GameObject
+  def initialize(options = {})
+    super
+    @image = Image["spaceship.png"]
+  end
+  
+  def move_left;  @x -= 1; end
+  def move_right; @x += 1; end
+  def move_up;    @y -= 1; end
+  def move_down;  @y += 1; end 
+
+  def fire
+    Bullet.create(:x => @x, :y => @y)
+  end  
+end
+
+class Bullet < Chingu::GameObject
+  #
+  # If we need our own initialize, just call super and Chingu does it's thing.
+  # Here we merge in an extra argument, specifying the bullet-image.
+  #
+  def initialize(options)
+    super(options.merge(:image => Image["fire_bullet.png"]))
+  end
+
+  # Move the bullet forward
+  def update
+    @y -= 2
+  end
+  
+end
+
+class Play < Chingu::GameState
+  
+  def initialize
+    super
+    @player = Player.create(:x => 200, :y => 200)
+    @player.input = { :holding_left => :move_left, 
+                      :holding_right => :move_right, 
+                      :holding_up => :move_up, 
+                      :holding_down => :move_down, 
+                      :space => :fire,
+                      :escape => :exit,
+                      }
+    self.input = { :f1 => :debug }
+  end
+  
+  def debug
+    #puts "--------"
+    #GameObject.all.each do |game_object|
+    #  puts game_object.class
+    #end
+    #return 
+    
+    push_game_state(Chingu::GameStates::Debug)
+  end
+    
+  #
+  # If we want to add extra graphics drawn just define your own draw.
+  # Be sure to call #super for enabling Chingus autodrawing of Actors.
+  # Putting #super before or after the background-draw-call really doesn't matter since Gosu work with "zorder".
+  #
+  def draw
+    # Raw Gosu Image.draw(x,y,zorder)-call
+    Image["background1.png"].draw(0, 0, 0)    
+    super
+  end
+
+  #
+  # Gosus place for gamelogic is #update in the mainwindow
+  #
+  # A #super call here would call #update on all Chingu::Actors and check their inputs, and call the specified method.
+  # 
+  def update
+    Bullet.destroy_if { |bullet| bullet.outside_window? }
+    #Bullet.destroy_if(&:outside_window?)
+    
+    #
+    # Bullet.each_collision(Enemy) do |bullet, enemy|
+    #   enemy.collision_with(bullet)
+    #   bullet.destroy!
+    # end
+    #
+      
+    super
+    $window.caption = "FPS: #{$window.fps} - milliseconds_since_last_tick: #{$window.milliseconds_since_last_tick} - game objects# #{current_game_state.game_objects.size} Bullets# #{Bullet.size}"
+  end  
+end
+
+Game.new.show

data/examples/example3.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+require File.join(File.dirname($0), "..", "lib", "chingu")
+include Gosu
+
+#
+# Parallax-example
+# Images from http://en.wikipedia.org/wiki/Parallax_scrolling
+#
+class Game < Chingu::Window
+  def initialize
+    super    
+    self.input = {  :holding_left => :scroll_left, :holding_right => :scroll_right, :escape => :exit }
+          
+    self.caption = "Chingu::Parallax example. Scroll with left/right arrows."
+    
+    @parallax = Chingu::Parallax.create(:x => 0, :y => 0, :center_x => 0, :center_y => 0)
+    
+    #
+    # If no :zorder is given to @parallax.add_background it defaults to first added -> lowest zorder
+    # Everywhere the :image argument is used, theese 2 values are the Same:
+    # 1) Image["foo.png"]  2) "foo.png"
+    #
+    # TODO: scrolling to left borks outm, fix. + get rid of center_x / center_y args in a clean way.
+    @parallax.add_background(:image => "Parallax-scroll-example-layer-0.png", :damping => 100, :center => 0)
+    @parallax.add_background(:image => "Parallax-scroll-example-layer-1.png", :damping => 10, :center => 0)
+    @parallax.add_background(:image => "Parallax-scroll-example-layer-2.png", :damping => 5, :center => 0)
+    @parallax << {:image => "Parallax-scroll-example-layer-3.png", :damping => 1, :center => 0} # you can also add like this
+  end
+  
+  def scroll_left
+    @parallax.x -= 2
+  end
+  
+  def scroll_right
+    @parallax.x += 2
+  end  
+  
+end
+
+Game.new.show

data/examples/example4.rb

@@ -0,0 +1,175 @@
+require 'rubygems'
+require File.join(File.dirname($0), "..", "lib", "chingu")
+include Gosu
+
+#
+# Example demonstrating jumping between 4 different game states.
+#
+# push_game_state, pop_game_state, current_game_state previous_game_state are 4 helper-methods that Chingu mixes in
+# into Chingu::Window and Chingu::GameState
+#
+# Behind the scenes they work against @game_state_manager that's autocreated within Chingu::Window.
+#
+# Execution in example4 flows like this:
+#
+# 1) Core Gosu calls instancemethods draw / update in the class based on Gosu::Window
+#    In this example 'Game' since "Game < Chingu::Window" and "Chingu::Window < Gosu::Window"
+# 
+# 2) In its turn Game (Chingu::Window) calls @game_state_manager.draw / update
+#
+# 3) @game_state_manager calls draw / update on the current active game state
+#
+# 4) Each game state keeps a collection @game_objects which it calls draw / update on.
+#    Any object based on Chingu::GameObject (In this example Player and Text) automatically
+#    gets added to the correct state or or main window.
+#
+
+#
+# Our standard Chingu::Window that makes all the magic happen.
+#
+class Game < Chingu::Window
+  def initialize
+    super
+    
+    push_game_state(Intro)
+    
+    # Yes you can do crazy things like this :)
+    self.input = { :left_mouse_button => lambda{Chingu::Text.create(:text => "Woff!")}, :esc => :exit}    
+  end
+end
+
+# Our Player 
+class Player < Chingu::GameObject
+  def initialize(options = {})
+    super
+    @image = Image["spaceship.png"]
+  end
+  
+  def move_left;  @x -= 1; end
+  def move_right; @x += 1; end
+  def move_up;    @y -= 1; end
+  def move_down;  @y += 1; end 
+
+  def fire
+    #puts $window.current_parent.to_s
+    #puts $window.game_state_manager.inside_state
+    Bullet.create(:x => @x - 20, :y => @y)
+    Bullet.create(:x => @x, :y => @y) 
+    Bullet.create(:x => @x + 20, :y => @y)
+  end  
+end
+
+# The bullet the Player fires
+class Bullet < Chingu::GameObject
+  def initialize(options)
+    super
+    @image = Image["fire_bullet.png"]
+  end
+  
+  def update
+    @y -= 2
+  end
+end
+
+
+#
+# GAMESTATE #1 - INTRO
+#
+class Intro < Chingu::GameState 
+  def initialize(options = {})
+    super
+    @title = Chingu::Text.create(:text=>"Press and release F1", :x=>200, :y=>50, :size=>30)
+    self.input = { :f1 => :pressed, :released_f1 => :released, :f2 => Menu}
+  end
+  
+  def pressed
+    @title.text = "F1 pressed (F2 to continue)"
+  end
+  
+  def released
+    @title.text = "F1 released (F2 to continue)"
+  end
+end
+
+#
+# GAMESTATE #2 - MENU
+#
+class Menu < Chingu::GameState
+  def initialize(options = {})
+    super
+    @title = Chingu::Text.create(:text => "Press 'S' to Start game", :x=>100, :y=>50, :size=>30)
+    self.input = { :s => Level.new(:level => 10) }
+  end
+end
+
+#
+# GAMESTATE #3 - LEVEL (Gameplay, yay)
+#
+class Level < Chingu::GameState
+  #
+  # initialize() is called when you create the game state
+  #
+  def initialize(options = {})
+    super
+    @title = Chingu::Text.create(:text=>"Level #{options[:level].to_s}. P: pause R:restart", :x=>20, :y=>10, :size=>30)
+    @player = Player.create
+    @player.input = { :holding_left => :move_left, 
+                      :holding_right => :move_right, 
+                      :holding_up => :move_up, 
+                      :holding_down => :move_down, 
+                      :space => :fire}
+    
+    #
+    # The input-handler understands gamestates. P is pressed --> push_gamegate(Pause)
+    # You can also give it Procs/Lambdas which it will execute when key is pressed.
+    #
+    self.input = {:p => Pause, :r => lambda{ current_game_state.setup } }
+  end
+  
+  def update
+    super
+    Bullet.destroy_if {|bullet| bullet.outside_window? }
+    $window.caption = "FPS: #{$window.fps} - GameObjects: #{game_objects.size} - Bullets: #{Bullet.size}"
+  end
+  
+  #
+  # setup() is called each time you switch to the game state (and on creation time).
+  # You can skip setup by switching with push_game_state(:setup => false) or pop_game_state(:setup => false)
+  #
+  # This can be useful if you want to display some kind of box above the gameplay (pause/options/info/... box)
+  #
+  def setup
+    # Destroy all created objects of class Bullet
+    #p Bullet.size
+    #puts Bullet.all
+    Bullet.destroy_all
+    
+    # Place player in a good starting position
+    @player.x = $window.width/2
+    @player.y = $window.height - @player.image.height
+  end
+end
+
+#
+# SPECIAL GAMESTATE - Pause
+#
+# NOTICE: Chingu now comes with a predefined Chingu::GameStates::Pause that works simular to this!
+#
+class Pause < Chingu::GameState
+  def initialize(options = {})
+    super
+    @title = Chingu::Text.create(:text=>"PAUSED (press 'u' to un-pause)", :x=>100, :y=>200, :size=>20, :color => Color.new(0xFF00FF00))
+    self.input = { :u => :un_pause }
+  end
+
+  def un_pause
+    pop_game_state(:setup => false)    # Return the previous game state, dont call setup()
+  end
+  
+  def draw
+    previous_game_state.draw    # Draw prev game state onto screen (in this case our level)
+    super                       # Draw game objects in current game state, this includes Chingu::Texts
+  end  
+end
+
+Game.new.show