ippa-chingu 0.4.8 → 0.5

data/examples/example6.rb

@@ -54,43 +54,4 @@ class State2 < Chingu::GameState
   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
+Game.new.show

data/examples/example7.rb

@@ -1,6 +1,7 @@
 require 'rubygems'
 require File.join(File.dirname($0), "..", "lib", "chingu")
 include Gosu
+include Chingu
 
 #
 # GFXHelpers example - demonstrating Chingus GFX
@@ -78,20 +79,20 @@ class Particles < Chingu::GameState
     @yellow = Color.new(0xFFF9F120)
     
     # Thanks jsb in #gosu of Encave-fame for fireball.png :)
-    @fireball_animation = Animation.new(:file => media_path("fireball.png"), :width => 32, :height => 32)
+    @fireball_animation = Chingu::Animation.new(:file => media_path("fireball.png"), :width => 32, :height => 32)
     @ground_y = $window.height * 0.95
   end
   
-  def update(time)
+  def update
     #
     # Fire 1. Dies quickly (big :fade). Small in size (small :zoom)
     #
     Chingu::Particle.new( :x => 100, 
                           :y => @ground_y, 
                           :animation => @fireball_animation,
-                          :zoom => +0.05, 
-                          :fade => -10, 
-                          :rotation => +1,
+                          :zooming => +0.05, 
+                          :fading => -10, 
+                          :rotating => +1,
                           :mode => :default
                         )
 
@@ -101,9 +102,9 @@ class Particles < Chingu::GameState
     Chingu::Particle.new( :x => 300, 
                           :y => @ground_y, 
                           :animation => @fireball_animation, 
-                          :zoom => +0.2, 
-                          :fade => -4, 
-                          :rotation => +3,
+                          :zooming => +0.2, 
+                          :fading => -4, 
+                          :rotating => +3,
                           :mode => :default
                         )
     #

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.new(:x => 0, :y => 0 + rand(5), :color => Color.new(0xFF86EFFF), :velocity_x => 10)
+    Plasma.new(:x => 0, :y => 50 + rand(5), :color => Color.new(0xFF86EFFF), :velocity_x => 14)
+    Plasma.new(:x => 0, :y => 100 + rand(5), :color => Color.new(0xFF86EFFF), :velocity_x => 7)
+    Plasma.new(: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.reject! { |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,83 @@
+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(Particles)
+  end
+  
+  def next_effect; pop_game_state; end
+end
+
+class FireCube < Chingu::GameObject
+  has_traits :velocity, :effect
+  
+  def initialize(options)
+    super    
+    @mode = :additive
+    
+    # initialize with a rightwards velocity with some damping to look more realistic
+    @velocity_x = options[:velocity_x] || 3 - rand(6)
+    @velocity_y = options[:velocity_y] || 3 - rand(6)
+    @rect = Rect.new([@x, @y, 20, 20])    
+  end
+  
+  def update
+    super
+    @rect.x = @x
+    @rect.y = @y    
+  end
+  
+  def draw
+    $window.fill_rect(@rect, Color.new(@color.alpha,100,255,255))
+  end
+  
+end
+
+class Particles < Chingu::GameState
+  def setup    
+    self.input = { :space => :new_fire_cube }
+    100.times { new_fire_cube }
+  end
+  
+  def new_fire_cube
+    FireCube.new(:x => rand($window.width), :y => rand($window.height))
+  end
+  
+  def update        
+    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
+    #FireCube.all.each do |particle|
+    #  FireCube.all.each do |particle2|
+    #    if particle.rect.collides_with
+    #    
+    #  end
+    #end
+      
+    self.game_objects.reject! { |object| object.color.alpha == 0 }
+    
+    super
+  end
+  
+  def draw
+    $window.caption = "particle example (esc to quit) [particles#: #{game_objects.size} - framerate: #{$window.fps}]"
+    super
+  end
+end
+
+Game.new.show

data/lib/chingu.rb

@@ -1,13 +1,27 @@
 #
 #
 #
-require 'rubygems'
+unless RUBY_VERSION =~ /1\.9/
+  require 'rubygems'
+end
 require 'gosu'
 require 'set'
 
+%w{ collision_detection
+    effect
+    velocity
+    input
+		}.each do |lib|
+      root ||= File.dirname(File.expand_path(__FILE__))
+      require File.join(root,"chingu","components",lib)
+    end
+
 %w{	helpers
     gfx_helpers
+    core_extensions
+    basic_game_object
     game_object
+    actor
     effects
     game_state_manager
     game_state
@@ -28,11 +42,12 @@ require 'set'
 
 %w{ pause
     fade_to
+    debug
 		}.each do |lib|
       root ||= File.dirname(File.expand_path(__FILE__))
       require File.join(root,"chingu","game_states",lib)
     end
 
 module Chingu
-  VERSION = "0.4.8"
+  VERSION = "0.4.9"
 end

data/lib/chingu/actor.rb

@@ -0,0 +1,15 @@
+module Chingu
+  #
+  # A game object class with most components included, nice for quick prototypes
+  #
+  class Actor < Chingu::GameObject
+    #add_component :visual, :effect, :input
+  
+    #def initialize(options = {})
+    #  super
+    #  visual_setup(options)
+    #  effect_setup(options)
+    #  input_setup(options)
+    #end
+  end
+end

data/lib/chingu/animation.rb

@@ -30,16 +30,39 @@ module Chingu
       @delay = options[:delay]
       @dt = 0
       
+      if options[:size]
+        @width = options[:size][0]
+        @height = options[:size][0]
+      end
+      
       @frame_actions = []
       @frames = Gosu::Image.load_tiles($window, @file, @width, @height, true)
       @step = 1
     end
     
     #
-    # Fetch a certain frame (a Gosu#Image), starts at 0.
+    # Returns first frame (GOSU::Image) from animation
+    #
+    def first
+      @frames.first
+    end
+
+    #
+    # Returns last frame (GOSU::Image) from animation
+    #
+    def last
+      @frames.first
+    end
+    
+    #
+    # Fetch a frame or frames:
+    #
+    #   @animation[0]       # returns first frame
+    #   @animation[0..2]    # returns a new Animation-instance with first, second and third frame
     #
     def [](index)
-      @frames[index]
+      return @frames[index]               if  index.is_a? (Fixnum)
+      return self.new_from_frames(index)  if  index.is_a? (Range)
     end
 		
     #
@@ -51,9 +74,11 @@ module Chingu
 		
     #
     # Resets the animation, re-starts it at frame 0
+    # returns itself.
     #
     def reset!
       @index = 0
+      self
     end
 		
     #

data/lib/chingu/basic_game_object.rb

@@ -0,0 +1,140 @@
+module Chingu
+  #
+  # BasicGameObject. Resonating with 1.9.1, this is our most basic class that all game objects ultimate should build on.
+  #
+  # All objects that inherits from this class will by default be automaticly be updated and drawn.
+  # It will also acts as a container for the component-system of chingu.
+  #
+  class BasicGameObject
+    attr_reader :options, :parent
+    
+    #
+    # Create class variable @components in every new class derived from GameObject
+    #
+    def self.inherited(subclass)
+      subclass.instance_variable_set("@components", Set.new)
+    end
+   
+    class << self
+      attr_accessor :components
+    end
+    
+    #
+    # adds a component to a certain game class
+    # 
+    # Executes a ruby "include" the specified module
+    # and sets up update and draw hooks.
+    #
+    def self.add_component(*components)
+      Array(components).each do |component|
+        
+        if component.is_a?(::Symbol) || component.is_a?(::String)
+          string = "Chingu::Components::#{component.to_s.downcase.capitalize}"
+          klass_or_module = eval(string)
+          
+          if klass_or_module.is_a?(Class)
+            component = klass_or_module.new(self, {})
+            @components << component
+          elsif klass_or_module.is_a?(Module)
+            include klass_or_module
+          end
+        end
+      end
+    end
+
+    
+    #
+    # BasicGameUnit initialize
+    #
+    # - caches component methods for fast calls later on
+    # - call .setup() on components that implements it
+    # - adds game object to correct game state or $window if no game state exists
+    #
+    def initialize(options = {})
+      @options = options
+      setupable_components
+      updateable_components
+      drawable_components
+      
+      @setupable_components.each { |c| c.setup(self, options) }
+      
+      #
+      # A GameObject can either belong to a GameState or our mainwindow ($window)
+      # .. or live in limbo with manual updates
+      #
+      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
+    
+    #
+    # Get all components
+    #
+    def components; self.class.components || [];  end
+    
+    def setupable_components
+      @setupable_components ||= components.select { |c| c.respond_to?(:setup) }
+    end
+    def updateable_components
+      @updateable_components ||= components.select { |c| c.respond_to?(:update) }
+    end
+    def drawable_components
+      @drawable_components ||= components.select { |c| c.respond_to?(:draw) }
+    end
+    
+    #
+    # Call .update on all components that implements it
+    #
+    def update
+      @updateable_components.each { |c| c.update(self) }
+		end
+    
+    #
+    # Call .draw on all components that implements it
+    #    
+    def draw
+      @drawable_components.each { |c| c.draw(self) }
+    end
+    
+        
+    #
+    # Fetch all objects of a current class.
+    #   Bullet.all   # => Enumerator of all objects of class Bullet
+    #
+    # NOTE: ObjectSpace doesn't play nice with jruby.
+    #
+    def self.all
+      ObjectSpace.each_object(self)
+    end
+    
+    #
+    # Destroy all instances of current class that fills a certain condition
+    #   Enemy.destroy_if(&:dead?)   # Assumes Enemy.dead? returns true/false depending on aliveness :)
+    #
+    #
+    def self.destroy_if(&block)
+      all.each do |object|
+        object.destroy! if yield(object)
+      end
+    end
+    
+    #
+    # Clear all intances of objects class:
+    #   Bullet.clear    # Removes all Bullet objects from the game
+    #
+    def self.clear
+      all.each { |object| object.destroy! }
+    end
+
+    #
+    # Removes object from the update cycle and freezes the object to prevent further modifications.
+    # If the object isn't being managed by Chingu (ie. you're doing manual update/draw calls) the object is only frozen, not removed from any updae cycle (because you are controlling that).
+    #
+    def destroy!
+      @parent.remove_game_object(self) if @parent
+      self.freeze
+    end    
+  end
+end