ippa-chingu 0.4.2 → 0.4.4

data/chingu.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{chingu}
-  s.version = "0.4.2"
+  s.version = "0.4.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["ippa"]
-  s.date = %q{2009-08-20}
+  s.date = %q{2009-08-21}
   s.description = %q{Game framework built on top of the OpenGL accelerated game lib Gosu.  It adds simple yet powerfull game states, prettier inputhandling, deploymentsafe asset-handling, a basic re-usable game object and automation of common task.}
   s.email = ["ippa@rubylicio.us"]
   s.extra_rdoc_files = ["History.txt", "Manifest.txt"]

data/examples/example2.rb

@@ -31,7 +31,7 @@ class Game < Chingu::Window
   #
   def draw
     # Raw Gosu Image.draw(x,y,zorder)-call
-    Image["background1.png"].draw(0, 0, 0)
+    Image["background1.png"].draw(0, 0, 0)    
     super
   end
 
@@ -43,8 +43,8 @@ class Game < Chingu::Window
   def update
     
     ### Your own gamelogic here
-    
     super
+    self.caption = "FPS: #{self.fps} milliseconds_since_last_tick: #{self.milliseconds_since_last_tick}"
   end
   
 end

data/examples/example5.rb

@@ -15,19 +15,23 @@ class Game < Gosu::Window
     # Create our game state manager and start out with State1
     @manager = Chingu::GameStateManager.new
     @manager.switch_game_state(State1)
+    
+    # Insert FadeTo state between every push, pop and switch
+    # @manager.transitional_game_state(Chingu::GameStates::FadeTo, :speed => 10)
   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)
+
     @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)
-    close                             if(id==Button::KbEscape)
-    
-    # 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)
-  end      
+    exit                             if(id==Button::KbEscape)
+  end
   
   def update
     # This makes sure update() is called on the active game state
@@ -61,7 +65,7 @@ class State1 < Chingu::GameState
   end
 end
 
-class State2 < Chingu::GameState 
+class State2 < Chingu::GameState
   def setup
     @factor = 0.0
     @ticks = 0.0
@@ -69,7 +73,7 @@ class State2 < Chingu::GameState
   
   def update(dt)
     @ticks += 0.01
-    @factor = 1.5 + Math.sin(@ticks)
+    @factor = 1.5 + Math.sin(@ticks).to_f
   end
   
   def draw
@@ -86,7 +90,7 @@ class State3 < Chingu::GameState
   
   def update(dt)
     @ticks += 0.01
-    @factor = 1.5 + Math.sin(@ticks)
+    @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)

data/examples/example6.rb

@@ -5,21 +5,44 @@ 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 => :next_game_state, :esc => :exit}
-    self.caption = "Example of fading game state to switch between 2 other game states"
+    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 next_game_state
-    push_game_state(FadeTo.new(State2.new)) if current_game_state.is_a?(State1)
-    push_game_state(FadeTo.new(State1.new)) if current_game_state.is_a?(State2)
+  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  
+class State1 < Chingu::GameState
   def draw
     Image["ruby.png"].draw(0,0,0)
   end
@@ -31,40 +54,43 @@ class State2 < Chingu::GameState
   end
 end
 
+Game.new.show
 
-class FadeTo < Chingu::GameState
-  def initialize(game_state)
-    @new_game_state = game_state
-  end
-  
-  def setup
-    @color = Gosu::Color.new(0,0,0,0)
-    @alpha = 0.0
-    @fading_in = false
-  end
-  
-  def update(dt)
-    @alpha += (@fading_in ? -2 : 2)
-    if  @alpha >= 255
-      @fading_in = true 
-    else
-      @color.alpha = @alpha.to_i
-    end
-  end
-  
-  def draw
-    previous_game_state.draw  if @fading_in == false
-    @new_game_state.draw      if @fading_in == true
-    
-    $window.draw_quad(  0,0,@color,
-                        $window.width,0,@color,
-                        $window.width,$window.height,@color,
-                        0,$window.height,@color,999)
-                        
-    if @fading_in == true && @alpha == 0
-      switch_game_state(@new_game_state)
-    end
-  end  
-end
-
-Game.new.show
+#
+# The has now become premade game state shippet with Chingu.
+# See chingu\game_states\fade_to.rb
+#
+#class FadeTo < Chingu::GameState
+#  def initialize(game_state)
+#    @new_game_state = game_state
+#  end
+#  
+#  def setup
+#    @color = Gosu::Color.new(0,0,0,0)
+#    @alpha = 0.0
+#    @fading_in = false
+#  end
+#  
+#  def update(dt)
+#    @alpha += (@fading_in ? -2 : 2)
+#    if  @alpha >= 255
+#      @fading_in = true 
+#    else
+#      @color.alpha = @alpha.to_i
+#    end
+#  end
+#  
+#  def draw
+#    previous_game_state.draw  if @fading_in == false
+#    @new_game_state.draw      if @fading_in == true
+#    
+#    $window.draw_quad(  0,0,@color,
+#                        $window.width,0,@color,
+#                        $window.width,$window.height,@color,
+#                        0,$window.height,@color,999)
+#                        
+#    if @fading_in == true && @alpha == 0
+#      switch_game_state(@new_game_state)
+#    end
+#  end  
+#end

data/lib/chingu.rb

@@ -25,6 +25,13 @@ require 'set'
       require File.join(root,"chingu",lib)
     end
 
+%w{ pause
+    fade_to
+		}.each do |lib|
+      root ||= File.dirname(File.expand_path(__FILE__))
+      require File.join(root,"chingu","game_states",lib)
+    end
+
 module Chingu
-  VERSION = "0.4.1"
+  VERSION = "0.4.3"
 end

data/lib/chingu/game_object.rb

@@ -94,8 +94,10 @@ module Chingu
       # A GameObject can either belong to a GameState or our mainwindow ($window)
       # .. or live in limbo with manual updates
       #
-      @parent = $window.game_state_manager.inside_state || $window
-      @parent.add_game_object(self)  if @parent
+      if $window && $window.respond_to?(:game_state_manager)
+        @parent = $window.game_state_manager.inside_state || $window
+        @parent.add_game_object(self) if @parent
+      end
     end
     
     #

data/lib/chingu/game_state.rb

@@ -34,10 +34,11 @@ module Chingu
     include Chingu::InputClient
     
     attr_reader :options                # so jlnr can access his :level-number
-    attr_reader :game_objects
+    attr_accessor :game_state_manager
     
     def initialize(options = {})
       @options = options
+      ## @game_state_manager = options[:game_state_manager] || $window.game_state_manager
       @game_objects = Set.new
       @input_clients = Set.new          # Set is like a unique Array with Hash lookupspeed
       
@@ -47,6 +48,11 @@ module Chingu
       end
     end
     
+    def game_objects
+      return [] unless defined?(@game_objects)
+      return @game_objects
+    end
+    
     #
     # An unique identifier for the GameState-class, 
     # Used in game state manager to keep track of created states.

data/lib/chingu/game_state_manager.rb

@@ -25,6 +25,9 @@ module Chingu
     def initialize
       @inside_state = nil
       @game_states = []
+      @transitional_game_state = nil
+      @transitional_game_state_options = {}
+      @previous_game_state = nil
     end
     
     #
@@ -42,29 +45,66 @@ module Chingu
       @game_states.reverse
     end
     
+    #
+    # Sets a game state to be called between the old and the new game state 
+    # whenever a game state is switched,pushed or popped.
+    #
+    # The transitional game state is responsible for switching to the "new game state".
+    # It should do so with ":transitional => false" not to create an infinite loop.
+    # 
+    # The new game state is the first argument to the transitional game states initialize().
+    #
+    # Example:
+    #   transitional_game_state(FadeIn)
+    #   push_game_state(Level2)
+    #
+    # would in practice become:
+    # 
+    #   push_game_state(FadeIn.new(Level2))
+    #
+    # This would be the case for every game state change until the transitional game state is removed:
+    #   transitional_game_state(nil)  # or false
+    #
+    # Very useful for fading effect between scenes.
+    #
+    def transitional_game_state(game_state, options = {})
+      @transitional_game_state = game_state
+      @transitional_game_state_options = options
+    end
+    
     #
     # Switch to a given game state, _replacing_ the current active one.
     # By default setup() is called on the game state  we're switching _to_.
     # .. and finalize() is called on the game state we're switching _from_.
     #
     def switch_game_state(state, options = {})
-      options = {:setup => true, :finalize => true}.merge(options)
+      options = {:setup => true, :finalize => true, :transitional => true}.merge(options)
 
       new_state = game_state_instance(state)
       
       if new_state
+        # Make sure the game state knows about the manager
+        new_state.game_state_manager = self
+        
+        
         # Give the soon-to-be-disabled state a chance to clean up by calling finalize() on it.
+        @previous_game_state = current_game_state
         current_game_state.finalize   if current_game_state.respond_to?(:finalize) && options[:finalize]
         
         # Call setup
         new_state.setup               if new_state.respond_to?(:setup) && options[:setup]
         
-        
-        if current_game_state.nil?
-          @game_states << new_state
+        if @transitional_game_state && options[:transitional]
+          # If we have a transitional, switch to that instead, with new_state as first argument
+          transitional_game_state = @transitional_game_state.new(new_state, @transitional_game_state_options)
+          self.switch_game_state(transitional_game_state, :transitional => false)
         else
-          # Replace last (active) state with new one
-          @game_states[-1] = new_state
+          if current_game_state.nil?
+            @game_states << new_state
+          else
+            # Replace last (active) state with new one
+            @game_states[-1] = new_state
+          end
         end
       end
     end
@@ -76,19 +116,29 @@ module Chingu
     # .. and finalize() is called on the game state we're leaving.
     #
     def push_game_state(state, options = {})
-      options = {:setup => true, :finalize => true}.merge(options)
+      options = {:setup => true, :finalize => true, :transitional => true}.merge(options)
 
       new_state = game_state_instance(state)
-      
+            
       if new_state
-        # Give the soon-to-be-disabled state a chance to clean up by calling finalize() on it.
-        current_game_state.finalize   if current_game_state.respond_to?(:finalize) && options[:finalize]
-        
         # Call setup
         new_state.setup               if new_state.respond_to?(:setup) && options[:setup]
         
-        # Push new state on top of stack and therefore making it active
-        @game_states.push(new_state)
+        # Make sure the game state knows about the manager
+        new_state.game_state_manager = self
+        
+        # Give the soon-to-be-disabled state a chance to clean up by calling finalize() on it.
+        @previous_game_state = current_game_state
+        current_game_state.finalize   if current_game_state.respond_to?(:finalize) && options[:finalize]
+        
+        if @transitional_game_state && options[:transitional]
+          # If we have a transitional, push that instead, with new_state as first argument
+          transitional_game_state = @transitional_game_state.new(new_state, @transitional_game_state_options)
+          self.push_game_state(transitional_game_state, :transitional => false)
+        else
+          # Push new state on top of stack and therefore making it active
+          @game_states.push(new_state)
+        end
       end
     end
     alias :push :push_game_state
@@ -99,20 +149,27 @@ module Chingu
     # .. and finalize() is called on the game state we're leaving.
     #
     def pop_game_state(options = {})
-      options = {:setup => true, :finalize => true}.merge(options)
+      options = {:setup => true, :finalize => true, :transitional => true}.merge(options)
       
       #
       # Give the soon-to-be-disabled state a chance to clean up by calling finalize() on it.
       #
+      @previous_game_state = current_game_state
       current_game_state.finalize    if current_game_state.respond_to?(:finalize) && options[:finalize]
-      
+
       #
       # Activate the game state "bellow" current one with a simple Array.pop
       #
       @game_states.pop
-
+        
       # Call setup on the new current state
       current_game_state.setup       if current_game_state.respond_to?(:setup) && options[:setup]
+      
+      if @transitional_game_state && options[:transitional]
+        # If we have a transitional, push that instead, with new_state as first argument
+        transitional_game_state = @transitional_game_state.new(current_game_state, @transitional_game_state_options)
+        self.switch_game_state(transitional_game_state, :transitional => false)
+      end
     end
     alias :pop :pop_game_state
 
@@ -120,7 +177,8 @@ module Chingu
     # Returns the previous game state. Shortcut: "previous"
     #
     def previous_game_state
-      @game_states[@game_states.index(current_game_state)-1]
+      ##@game_states[@game_states.index(current_game_state)-1]
+      @previous_game_state
     end
     alias :previous previous_game_state
     

data/lib/chingu/helpers.rb

@@ -85,13 +85,7 @@ module Chingu
   #
   # push_game_state accepts either a class inherited from GameState or an object-instance from such a class.
   #
-  # push_game_state(Intro):
-  # game state mananger will create a new Intro-object first time called and cache it.
-  #
-  # push_game_state(Intro.new):
-  # The first line ends up calling "new" to Intro before activating the newly created game state.
-  # Each time 'push_game_state(Intro.new)' is called a new Intro-object will be created.
-  # Usefull for stuff like: push_game_state(Level.new(:level_nr => 11))
+  # It will make call new() on a class, and just push an object.
   #
   module GameStateHelpers
     def push_game_state(state, options = {})
@@ -106,6 +100,10 @@ module Chingu
       $window.game_state_manager.switch_game_state(state, options)
     end
 
+    def transitional_game_state(state, options = {})
+      $window.game_state_manager.transitional_game_state(state, options)      
+    end
+
     def current_game_state
       $window.game_state_manager.current_game_state
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ippa-chingu
 version: !ruby/object:Gem::Version 
-  version: 0.4.2
+  version: 0.4.4
 platform: ruby
 authors: 
 - ippa
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-20 00:00:00 -07:00
+date: 2009-08-21 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency