chingu 0.7.5 → 0.7.6

data/examples/example21_sidescroller_with_edit.rb

@@ -0,0 +1,298 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require File.join(File.dirname($0), "..", "lib", "chingu")
+include Gosu
+include Chingu
+
+#
+# Press 'E' when demo is running to edit the playfield!
+# 
+class Game < Chingu::Window 
+  def initialize
+    super(1000,700)
+  end
+  
+  def setup
+    Gosu::enable_undocumented_retrofication
+    switch_game_state(Example21.new)
+  end    
+end
+
+#
+# The Game
+#
+class Example21 < GameState
+  traits :viewport, :timer
+  
+  def setup
+    self.input = { :escape => :exit, :e => :edit }
+    self.viewport.game_area = [0, 0, 3000, 1000]    
+    
+    @droid = Droid.create(:x => 100, :y => 300)
+    #@droid = Droid.create(:x => 2500, :y => 1200)
+    #@droid = Droid.create(:x => 500, :y => 1500)
+    
+    load_game_objects
+    
+    # Reverse the cog wheels in relation to eachother
+    CogWheel.each_collision(CogWheel) do |cog_wheel, cog_wheel_2|
+      cog_wheel_2.angle_velocity = -cog_wheel.angle_velocity
+    end
+    
+    @saved_x, @saved_y = [100, 300]
+    every(5000) { save_player_position }
+  end
+  
+  def edit
+    push_game_state(GameStates::Edit.new(:grid => [32,32], :classes => [Tube, CogWheel, Block, Saw, Battery]))
+  end
+  
+  def restore_player_position
+    @droid.x, @droid.y = @saved_x, @saved_y
+  end
+  
+  def save_player_position
+    @saved_x, @saved_y = @droid.x, @droid.y   if @droid.velocity_y >= 0 && @droid.collidable
+  end
+
+  def update    
+    super
+    
+    visible_blocks = Block.inside_viewport
+    
+    FireBall.each_collision(visible_blocks) do |fire_ball, block|
+      fire_ball.destroy
+    end
+    
+    # Makes all saw pendle up and down between Y-coordinate 1000 - 1500
+    # TODO: Not a very flexible sollution, how about setting out circle,rects,lines in editor..
+    # .. when then can be used for this kind of stuff?
+    Saw.all.select {|saw| saw.y < 1300 || saw.y > 1550 }.each do |saw|
+      saw.velocity_y = -saw.velocity_y
+      saw.y += saw.velocity_y * saw.factor_y 
+    end
+
+    @droid.each_collision(FireBall, Saw) do |player, evil_object|
+      player.die
+    end
+      
+    @droid.each_collision(Battery) do |player, battery|
+      battery.die
+      #after(3000) { push_game_state(GameFinished) }
+    end
+  
+        
+    self.viewport.center_around(@droid)
+        
+    $window.caption = "Haunted Factory. TAB toggles 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 GameFinished < GameState
+  def setup
+    self.input
+    Text.create("MMMM... Battery ACID, YUM!")
+  end
+end
+  
+#
+# DROID
+#
+class Droid < Chingu::GameObject
+  trait :bounding_box, :scale => 0.80
+  traits :timer, :collision_detection , :timer, :velocity
+  
+  def setup
+    self.input = {  [:holding_left, :holding_a] => :holding_left, 
+                    [:holding_right, :holding_d] => :holding_right,
+                    [:up, :w] => :jump,
+                    :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 }
+    
+    @animation = @animations[:scan]
+    @speed = 3
+    
+    self.zorder = 300
+    self.factor = 3
+    self.acceleration_y = 0.5
+    self.max_velocity = 10
+    self.rotation_center = :bottom_center
+
+    update
+  end
+  
+  def die
+    self.collidable = false
+    @color = Color::RED
+    between(1,600) { self.velocity_y = 0; self.scale += 0.2; self.alpha -= 5; }.then { resurrect }
+  end
+    
+  def resurrect
+    self.alpha = 255
+    self.factor = 3
+    self.collidable = true
+    @color = Color::WHITE
+    game_state.restore_player_position
+  end
+
+  def holding_left
+    move(-@speed, 0)
+    @animation = @animations[:left]
+  end
+
+  def holding_right
+    move(@speed, 0)
+    @animation = @animations[:right]
+  end
+
+  def jump
+    return if self.velocity_y < 0
+    self.velocity_y = -10
+    @animation = @animations[:up]
+  end
+  
+  def move(x,y)
+    @x += x
+    self.each_collision(Block.inside_viewport) do |me, stone_wall|
+      me.x = previous_x
+    end
+  end
+  
+  def update    
+    @image = @animation.next
+    self.each_collision(Block.inside_viewport) do |me, stone_wall|
+      if self.velocity_y < 0
+        me.y = stone_wall.bb.bottom + me.image.height * self.factor_y
+        self.velocity_y = 0
+      else
+        me.y = stone_wall.bb.top-1
+      end
+    end
+    
+    @animation = @animations[:scan] unless moved?
+  end
+end
+
+#
+# TUBE
+#
+class Tube < GameObject
+  traits :bounding_box, :timer
+  def setup
+    @image = Image["tube.png"]
+    every(3000)  { fire }
+    cache_bounding_box
+  end
+  
+  def fire
+    return if game_state.viewport.outside?(self.bb.centerx, self.bb.bottom)
+    FireBall.create(:x => self.bb.centerx - rand(10), :y => self.bb.bottom - rand(10))
+  end
+end
+
+#
+# BATTERY
+#
+class Battery < GameObject
+  traits :timer, :effect
+  trait :bounding_box, :debug => false
+  
+  def setup
+    @image = Image["battery.png"]
+    cache_bounding_box
+  end
+  
+  def die   
+    self.collidable = false # Stops further collisions in each_collsiion() etc.
+    self.rotation_rate = 5
+    self.scale_rate = 0.005
+    self.fade_rate = -5
+    after(2000) { destroy }
+  end  
+end
+
+#
+# A FIREBALL
+#
+class FireBall < GameObject
+  traits :velocity, :collision_detection
+  trait :bounding_circle, :scale => 0.7
+  
+  def setup
+    @animation = Animation.new(:file => "fireball.png", :size => [32,32], :delay => 20)
+    @image = @animation.first
+    self.mode = :additive
+    self.factor = 3
+    self.velocity_y = 1
+    self.zorder = 200
+    self.rotation_center = :center
+  end
+  
+  def update
+    @image = @animation.next
+    @angle += 2
+  end
+end
+
+#
+# COG WHEEL
+#
+class CogWheel < GameObject
+  traits :bounding_circle, :collision_detection, :timer
+  attr_accessor :angle_velocity
+  
+  def setup    
+    @image = Image["cog_wheel.png"]
+    @angle_velocity = 1 / self.factor_x
+  end
+  
+  def update
+    self.angle += @angle_velocity
+  end
+end
+
+#
+# SAW
+#
+class Saw < GameObject
+  traits :bounding_circle, :collision_detection, :timer, :velocity
+  attr_accessor :angle_velocity
+  
+  def setup    
+    @image = Image["saw.png"]
+    @angle_velocity = 3.0 / self.factor_x.to_f
+    self.velocity_y = 1.0 / self.factor_x.to_f
+  end
+  
+  def update
+    self.angle += @angle_velocity
+  end
+end
+
+#
+# BLOCK, our basic level building block
+#
+class Block < GameObject
+  trait :bounding_box, :debug => false
+  trait :collision_detection
+  
+  def self.solid
+    all.select { |block| block.alpha == 255 }
+  end
+
+  def self.inside_viewport
+    all.select { |block| block.game_state.viewport.inside?(block) }
+  end
+
+  def setup
+    @image = Image["black_block.png"]
+  end
+end
+
+Game.new.show

data/examples/game_of_life.rb

@@ -34,8 +34,8 @@ class GameOfLife < Chingu::GameState
                   :z => :reset,
                   :n => :update_grid,
                   :space => :toggle_running,
-                  :left_arrow => :prev_pattern,
-                  :right_arrow => :next_pattern
+                  [:mouse_wheel_up,:left_arrow] => :prev_pattern,
+                  [:mouse_wheel_down,:right_arrow] => :next_pattern
                 }
 
     @pattern = :pixel
@@ -49,7 +49,7 @@ class GameOfLife < Chingu::GameState
   end  
   
   def update_pattern_info
-    @pattern_info.text = "Current pattern: #{@pattern}. Change patterns with left/right arrow keys."
+    @pattern_info.text = "Current pattern: #{@pattern}. Change patterns with mousewheel."
   end
     
   def prev_pattern

data/lib/chingu.rb

@@ -33,7 +33,7 @@ require_all "#{CHINGU_ROOT}/chingu/traits"
 require_all "#{CHINGU_ROOT}/chingu"
 
 module Chingu
-  VERSION = "0.7.5"
+  VERSION = "0.7.6"
   
   DEBUG_COLOR = Gosu::Color.new(0xFFFF0000)
   DEBUG_ZORDER = 9999

data/lib/chingu/animation.rb

@@ -66,11 +66,16 @@ module Chingu
     
     #
     # Remove transparent space from each frame so the actual sprite is touching the border of the image.
+    # This requires TexPlay
     #
     def trim
-      @frames.each do |frame|
-        # TODO!
-      end
+      #@frames.each do |frame|
+      #  y = 0
+      #  x2, y2, color = frame.line 0,y,frame.width,y, :trace => { :while_color => :alpha }
+      #  puts "final y: #{y}"
+      #  #frame.image.trace 0,0,image
+      #  #frame.splice(frame,0,0, :crop => [10, 10, 20, 20])
+      #end
     end
     
     #

data/lib/chingu/basic_game_object.rb

@@ -60,7 +60,9 @@ module Chingu
 		#	subclass.initialize_inherited_trait	if subclass.method_defined?(:initialize_inherited_trait)
 		#end
 			
-        
+    alias :game_state :parent
+    alias :game_state= :parent=
+    
     #
     # BasicGameObject initialize
     # - call .setup_trait() on all traits that implements it

data/lib/chingu/game_object.rb

@@ -32,7 +32,7 @@ module Chingu
   #
   class GameObject < Chingu::BasicGameObject
     attr_accessor :image, :x, :y, :angle, :center_x, :center_y, :factor_x, :factor_y, :color, :mode, :zorder
-    attr_reader :factor, :center#, :rotation_center
+    attr_reader :factor, :center
     
     include Chingu::Helpers::InputClient        # Adds input and input=
     include Chingu::Helpers::RotationCenter     # Adds easy and verbose modification of @center_x and @center_y
@@ -42,17 +42,17 @@ module Chingu
       
       #
       # All encapsulated Gosu::Image.draw_rot arguments can be set with hash-options at creation time
-			#
+      #
       if options[:image].is_a?(Gosu::Image)
         @image = options[:image]
       elsif options[:image].is_a? String
-				begin
-					# 1) Try loading the image the normal way
-					@image = Gosu::Image.new($window, options[:image])
-				rescue
-					# 2) Try looking up the picture using Chingus Image-cache
-					@image = Gosu::Image[options[:image]]
-				end
+        begin
+          # 1) Try loading the image the normal way
+          @image = Gosu::Image.new($window, options[:image])
+        rescue
+          # 2) Try looking up the picture using Chingus Image-cache
+          @image = Gosu::Image[options[:image]]
+        end
       end
       
       @x = options[:x] || 0
@@ -115,7 +115,19 @@ module Chingu
       value = 255 if value > 255
       @color.alpha = value
     end
-      
+
+    #
+    # Sets angle, normalize it to between 0..360
+    #
+    def angle=(value)
+      if value < 0
+        value = 360+value
+      elsif value > 360
+        value = value-360
+      end
+      @angle = value
+    end
+
 
     # Returns true if object is inside the game window, false if outside
     def inside_window?(x = @x, y = @y)
@@ -127,7 +139,7 @@ module Chingu
       not inside_window?(x,y)
     end
     
-    # Calculates the distance from self to a given objevt
+    # Calculates the distance from self to a given object
     def distance_to(object)
       distance(self.x, self.y, object.x, object.y)
     end

data/lib/chingu/game_state.rb

@@ -128,6 +128,17 @@ module Chingu
       self.class.to_s
     end
     
+    #
+    # Returns a filename-friendly string from the current class-name
+    #
+    # "Level19" -> "level19"
+    # "BigBossLevel" -> "big_boss_level"
+    #
+    def filename
+      Chingu::Inflector.underscore(self.class.to_s)
+    end
+    
+    
     def setup
       # Your game state setup logic here.
     end