chingu 0.7.0 → 0.7.5

data/History.txt

@@ -1,6 +1,6 @@
 === 0.6 / 2009-11-21
 More traits, better input, fixes
-See github commithistory. 
+This file is kind of deprecated -- see github commit-history instead!
 
 === 0.5.7 / 2009-10-15
 See github commithistory.

data/README.rdoc

@@ -14,7 +14,7 @@ Chingu has started to settle down, thouch core classes and naming can still chan
 == DESCRIPTION
 OpenGL accelerated 2D game framework for Ruby.
 Builds on the awesome Gosu (Ruby/C++) which provides all the core functionality.
-It adds simple yet powerful game states, prettier input handling, deployment safe asset-handling, a basic re-usable game object and automation of common task.
+It adds simple yet powerful game states, pretty input handling, deployment safe asset-handling, a basic re-usable game object and automation of common task.
 
 
 == THE STORY
@@ -33,9 +33,10 @@ Borrowing ideas from Rubygame this has now become @player.keyboard(:left => :mov
 Chingu consists of the following core classes / concepts:
 
 === Chingu::Window
-The main window, use it at you use Gosu::Window now. Calcs the framerate, takes care of states, 
-handles chingu-formated input, updates and draws BasicGameObject / GameObjects automaticly.
-Available thoughout your source as $window (Yes, that's the only global Chingu has).
+The main window, use it at you use Gosu::Window now. Calculates the framerate, takes care of states, 
+handles chingu-formated input, updates and draws BasicGameObject / GameObjects automatically.
+Available throughout your source as $window (Yes, that's the only global Chingu has).
+You can also set various global settings. For example, self.factor=3, will make all fortcomming GameObjects scale 3 times.
 
 === Chingu::GameObject
 Use this for all your in game objects. The player, the enemies, the bullets, the powerups, the loot laying around.
@@ -47,8 +48,8 @@ Has either Chingu::Window or a Chingu::GameState as "parent".
 === Chingu::BasicGameObject
 For those who think GameObject is a too little fat, there's BasicGameObject (GameObject inherits from BasicGameObject).
 BasicGameObject is just an empty frame (no x,y,image accessors or draw-logic) for you to build on.
-It _can_ be extended with Chingus trait-system though. The new() vs create() behaivor of GameObject comes from BasicGameObject.
-BasicGameObject#parent points to either $window or a game state and is automaticly set on creation time.
+It _can_ be extended with Chingus trait-system though. The new() vs create() behavior of GameObject comes from BasicGameObject.
+BasicGameObject#parent points to either $window or a game state and is automatically set on creation time.
 
 === Chingu::GameStateManager
 Keeps track of the game states. Implements a stack-based system with push_game_state and pop_game_state.
@@ -63,8 +64,8 @@ Chingu::Window --> Chingu::GameStateManager --> Chingu::GameState.
 For example, inside game state Menu you call push_game_state(Level). When Level exists, it will go back to Menu.
 
 === Traits
-Traits are extensions (or plugins if you so will) to BasicGameObjects. 
-The aim is so encapsulate common behaivor into modules for easy inclusion in your game classes.
+Traits are extensions (or plugins if you so will) to BasicGameObjects included on the class-level.
+The aim is so encapsulate common behavior into modules for easy inclusion in your game classes.
 Making a trait is easy, just an ordinary module with the methods setup_trait(), update_trait() and/or draw_trait().
 It currently has to be namespaced to Chingu::Traits for "has_traits" to work inside GameObject-classes.
 
@@ -159,9 +160,9 @@ Chingu doesn't change the fundamental concept/flow of Gosu, but it will make the
   #
   class Game < Chingu::Window
     def initialize
-      super       # This is always needed if you want to take advantage of what chingu offers
+      super       # This is always needed if you override Window#initialize
       #
-      # Player will automaticly be updated and drawn since it's a Chingu::GameObject
+      # Player will automatically be updated and drawn since it's a Chingu::GameObject
       # You'll need your own Chingu::Window#update and Chingu::Window#draw after a while, but just put #super there and Chingu can do its thing.
       #
       @player = Player.create
@@ -234,7 +235,7 @@ An example using almost all arguments would be:
   #
   # A shortcut for the above line would be
   #
-  @player = Player.new(:image => Image["player.png"], :x=>100, :y=>100, :zorder=>100, :angle=>45, :factor=>10, :center=>0)
+  @player = Player.new(:image => "player.png", :x=>100, :y=>100, :zorder=>100, :angle=>45, :factor=>10, :center=>0)
 
   #
   # I've tried doing sensible defaults:
@@ -445,8 +446,31 @@ Or Chingus shortcut:
   
 Chingus inputhandler will detect that Menu is a GameState-class, create a new instance and activate it with push_game_state().
 
+=== WorkFlow
+(This text is under development)
+
+== The setup-method
+If a setup() is available in a instance of Chingu::GameObject, Chingu::Window and Chingu::GameState it will automatically be called.
+This is the perfect spot to include various setup/init-tasks like setting colors or loading animations (if you're not using the animation-trait).
+You could also override initialize() for this purpose but it's been proven prone to errors again and again.
+Compare the 2 snippets below:
+
+  # Easy to mess up, forgetting options or super
+  def initialize(options = {})
+    super
+    @color = Color::WHITE
+  end
+  
+  # Less code, easier to get right and works in GameObject, Window and GameState
+  # Feel free to call setup() anytime, there's no magic about ut except it's autocalled once on object creation time.
+  def setup
+    @color = Color::WHITE
+  end
+  
+  
+
 === Traits
-Traits (often called behaivors) is a way of adding logic to any class inheriting from BasicGameObject / GameObject.
+Traits (sometimes called behaviors in other frameworks) is a way of adding logic to any class inheriting from BasicGameObject / GameObject.
 Chingus trait-implementation is just ordinary ruby modules with 3 special methods:
  - setup_trait 
  - update_trait 
@@ -462,6 +486,10 @@ A simple trait could be:
 module Chingu
   module Trait
     module Inspect
+    
+      #
+      # methods namespaced to ClassMethods get's extended as ... class methods!
+      #
       module ClassMethods
         def initialize_trait(options)
             # possible initialize stuff here
@@ -470,6 +498,15 @@ module Chingu
         def inspect
           "There's {self.size} active instances of class {self.to_s}"
         end
+      end
+      
+      #
+      # Namespaced outside ClassMethods get's included as normal instance-methods
+      #
+      def inspect
+        "Hello I'm an #{self.class.to_s}"
+      end
+      
     end
   end
 end
@@ -478,7 +515,8 @@ class Enemy < GameObject
   has_trait :inspect    # includes Chingu::Trait::Inspect and extends Chingu::Trait::Inspect::ClassMethods
 end
 10.times { Enemy.create }
-Enemy.inspect           # => There's 10 active instances of class Enemy
+Enemy.inspect           # => "There's 10 active instances of class Enemy"
+Enemy.all.first.inspect # => "Hello I'm a Enemy"
 
 
 Example of using traits :velocity and :timer:
@@ -527,10 +565,10 @@ There's a couple of traits included as default in Chingu:
 
 ==== Trait "timer"
 Adds timer functionality to your game object
-  during(300) { self.color = Color.new(0xFFFFFFFF) }   # forces @color to white every update for 300 ms
-  after(400) { self.destroy }                      # destroy object after 400 ms
-  between(1000,2000) { self.rotate(10) }           # starting after 1 second, call rotate(10) every update during 1 second
-  every(2000) { Sound["bleep.wav"].play }          # play bleep.wav every 2 seconds
+  during(300) { self.color = Color.new(0xFFFFFFFF) }  # forces @color to white every update for 300 ms
+  after(400) { self.destroy }                         # destroy object after 400 ms
+  between(1000,2000) { self.angle += 10 }             # starting after 1 second, modify angleevery update during 1 second
+  every(2000) { Sound["bleep.wav"].play }             # play bleep.wav every 2 seconds
   
 ==== Trait "velocity"
 Adds accessors velocity_x, velocity_y, acceleration_x, acceleration_y, max_velocity to game object.
@@ -558,10 +596,34 @@ You can also scale the calculated radius with has_trait-options:
   # :debug => true shows the actual circle in red on the screen
   has_trait :bounding_circle, :debug => true
 
+==== Trait "animation"
+Automatically load animations depending on the class-name.
+Useful when having a lot of simple classes thats mainpurpose is displaying an animation.
+Assuming the below code is included in a class FireBall.
+
+  #
+  # If a fire_ball_10x10.png/bmp exists, it will be loaded as a tileanimation.
+	# 10x10 would indicate the width and height of each tile so Chingu knows hows to cut it up into single frames.
+  # The animation will then be available in animations[:default] as an Animation-instance.
+  #
+  # If more then 1 animation exist, they'll will be loaded at the same time, for example:
+  # fire_ball_10x10_fly.png       # Will be available in animations[:fly] as an Animation-instance
+  # fire_ball_10x10_explode.png   # Will be available in animations[:explode] as an Animation-instance
+  # 
+	# The below example will set the 200ms delay between each frame on all animations loaded.
+  #
+  has_trait :automatic_assets, :delay => 200
+
 ==== Trait "effect"
 Adds accessors rotation_rate, fade_rate and scale_rate to game object.
 They modify angle, alpha and factor_x/factor_y each update. Since this is pretty easy to do yourself this trait might be up for deprecation.
-  
+
+==== (IN DEVELOPMENT) Trait "viewport"
+A game state trait. Adds accessor *viewport*. Set viewport.x and viewport.y to.
+Basically what viewport.x = 10 will do is draw all game objects 10 pixels to the left of their ordinary position.
+Since the viewport has moved 10 pixels to the right, the game objects will be seen "moving" 10 pixels to the left.
+This is great for scrolling games.
+
 ==== (IN DEVELOPMENT) Trait "collision_detection"
 Adds class and instance methods for basic collision detection.
   
@@ -638,7 +700,7 @@ Text is a class to give the use of Gosu::Font more rubyish feel and fit it bette
   @text = Chingu::Text.create("A Text", :x => 200, :y => 50, :zorder => 55, :factor_x => 2.0)
   @text.draw
 
-@text.draw is usually not needed as Text is a GameObject and therefore automaticly updated/drawn (it #create is used instead of #new)
+@text.draw is usually not needed as Text is a GameObject and therefore automatically updated/drawn (it #create is used instead of #new)
 It's not only that the second example is readable by ppl now even familiar with Gosu, @text comes with a number of changeable properties, x,y,zorder,angle,factor_x,color,mode etc. 
 Set a new x or angle or color and it will instantly update on screen.
 
@@ -656,7 +718,34 @@ GameObject.all is naming straight from rails for example. Most stuff in GameObje
 
 As far as possible, use correct rubyfied english game_objects, not gameobjects. class HighScore, not Highscore.
 
-== TODO - this list is discontinued and no longer updated
+
+== WHY?
+* Plain Gosu is very minimalistic, perfect to build some higher level logic on!
+* Deployment and asset handling should be simple
+* Managing game states/scenes (intros, menus, levels etc) should be simple
+* There are patterns in game development
+
+== OPINIONS
+* Less code is usually better
+* Hash arguments FTW. And it becomes even better in 1.9.
+* Don't separate too much from Gosus core-naming
+
+== CREDITS:
+* Jacius of Rubygame (For doing cool stuff that's well documented as re-usable). So far rect.rb and named_resource.rb is straight outta Rubygame.
+* Banister (of texplay fame) for general feedeback and help with ruby-internals and building the trait-system
+* Jduff for input / commits
+* Jlnr,Philymore,Shawn24,JamesKilton for constructive feedback/discussions
+* Ariel Pillet for codesuggestions and cleanups
+* Deps for making the first real full game with Chingu (and making it better in the process)
+* Thanks to http://github.com/tarcieri for require_all code, good stuff
+
+== REQUIREMENTS:
+* Gosu latest version
+* Ruby 1.9.1+ or 1.8.7+
+* gem 'opengl' if you want to use Image#retrofy, not needed otherwise
+* gem 'texplay' for some bonus Image-pixel operations, not needed otherwise
+
+== TODO - this list is Discontinued and no longer updated!
 * add :padding and :align => :topleft etc to class Text
 * (skip) rename Chingu::Window so 'include Chingu' and 'include Gosu' wont make Window collide
 * (done) BasicObject vs GameObject vs ScreenObject => Became BasicGameObject and GameObject
@@ -689,37 +778,9 @@ As far as possible, use correct rubyfied english game_objects, not gameobjects.
 * A more robust game state <-> game_object system to connect them together.
 * FIX example4: :p => Pause.new  would Change the "inside_game_state" to Pause and make @player belong to Pause.
 
-== WHY?
-* Plain Gosu is very minimalistic, perfect to build some higher level logic on!
-* Deployment and asset handling should be simple
-* Managing game states/scenes (intros, menus, levels etc) should be simple
-* There are patterns in game development
-
-== OPINIONS
-* Less code is usually better
-* Hash arguments FTW. And it becomes even better in 1.9.
-* Don't separate too much from Gosus core-naming
-
-== CREDITS:
-* Jacius of Rubygame (For doing cool stuff that's well documented as re-usable). So far rect.rb and named_resource.rb is straight outta Rubygame.
-* Banister (of texplay fame) for general feedeback and help with ruby-internals and building the trait-system
-* Jduff for input / commits
-* Jlnr,Philymore,Shawn24,JamesKilton for constructive feedback/discussions
-* Ariel Pillet for codesuggestions and cleanups
-* Deps for making the first real full game with Chingu (and making it better in the process)
-* Thanks to http://github.com/tarcieri for require_all code, good stuff
-
-== REQUIREMENTS:
-* Gosu latest version
-* Ruby 1.9.1+ or 1.8.7+
-* gem 'opengl' if you want to use Image#retrofy, not needed otherwise
-* gem 'texplay' for some bonus Image-pixel operations, not needed otherwise
-
-
-
 
 
   "If you program and want any longevity to your work, make a game. 
   All else recycles, but people rewrite architectures to keep games alive.", _why
   
-  
+  

data/benchmarks/game_objects_benchmark.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'benchmark'
+require File.join(File.dirname($0), "..", "lib", "chingu")
+include Gosu
+
+
+class Game < Chingu::Window
+	def initialize
+		super(600,200)
+		self.input = { :esc => :exit }
+		@iterations = 10
+	end
+	
+	def update
+		if @iterations > 0
+			create_objects
+			@iterations -= 1
+		end		
+	end
+	
+	def create_objects
+		Benchmark.bm(22) do |x|
+			x.report('create') do
+				100000.times do
+					MyGameObject.create					
+				end
+			end
+		end
+	end
+end
+
+class MyGameObject < Chingu::GameObject
+end
+
+Game.new.show
+
+
+# 100000 MyGameObject.create with add_game_objects / remove_game_objects -arrays
+#                              user     system      total        real
+#create                  0.951000   0.047000   0.998000 (  0.998057)
+#create                  1.139000   0.031000   1.170000 (  1.155066)
+#create                  1.186000   0.047000   1.233000 (  1.239071)
+#create                  1.528000   0.000000   1.528000 (  1.520087)
+#create                  1.451000   0.031000   1.482000 (  1.488085)
+#create                  1.654000   0.016000   1.670000 (  1.662095)
+#create                  1.794000   0.015000   1.809000 (  1.819104)
+#create                  1.997000   0.000000   1.997000 (  1.986114)
+#create                  1.934000   0.000000   1.934000 (  1.930110)
+#create                  2.075000   0.000000   2.075000 (  2.087119)

data/chingu.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{chingu}
-  s.version = "0.7.0"
+  s.version = "0.7.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["ippa"]
-  s.date = %q{2010-01-14}
+  s.date = %q{2010-06-13}
   s.description = %q{OpenGL accelerated 2D game framework for Ruby. Builds on Gosu (Ruby/C++) which provides all the core functionality. Chingu adds simple yet powerful game states, prettier input handling, deployment safe asset-handling, a basic re-usable game object and stackable game logic.}
   s.email = %q{ippa@rubylicio.us}
   s.extra_rdoc_files = [
@@ -28,6 +28,7 @@ Gem::Specification.new do |s|
      "benchmarks/benchmark4.rb",
      "benchmarks/benchmark5.rb",
      "benchmarks/benchmark6.rb",
+     "benchmarks/game_objects_benchmark.rb",
      "benchmarks/meta_benchmark.rb",
      "benchmarks/meta_benchmark2.rb",
      "chingu.gemspec",
@@ -39,8 +40,11 @@ Gem::Specification.new do |s|
      "examples/example15_trait_timer2.rb",
      "examples/example16_online_high_scores.rb",
      "examples/example17_gosu_tutorial.rb",
-     "examples/example18_viewport.rb",
+     "examples/example18_animation_trait.rb",
+     "examples/example19_edit_viewport.rb",
+     "examples/example19_game_objects.yml",
      "examples/example1_basics.rb",
+     "examples/example20_trait_inheritence_test.rb",
      "examples/example2_gamestate_basics.rb",
      "examples/example3_parallax.rb",
      "examples/example4_gamestates.rb",
@@ -50,6 +54,7 @@ Gem::Specification.new do |s|
      "examples/example8_traits.rb",
      "examples/example9_collision_detection.rb",
      "examples/game1.rb",
+     "examples/game_of_life.rb",
      "examples/high_score_list.yml",
      "examples/media/Parallax-scroll-example-layer-0.png",
      "examples/media/Parallax-scroll-example-layer-1.png",
@@ -61,26 +66,29 @@ Gem::Specification.new do |s|
      "examples/media/bullet.png",
      "examples/media/bullet_hit.wav",
      "examples/media/circle.png",
-     "examples/media/city1.csv",
      "examples/media/city1.png",
      "examples/media/city2.png",
      "examples/media/droid.bmp",
+     "examples/media/droid_11x15.bmp",
+     "examples/media/droid_11x15.gal",
      "examples/media/enemy_bullet.png",
      "examples/media/explosion.wav",
      "examples/media/fire_bullet.png",
      "examples/media/fireball.png",
+     "examples/media/heli.bmp",
+     "examples/media/heli.gal",
      "examples/media/laser.wav",
      "examples/media/particle.png",
-     "examples/media/plane.csv",
      "examples/media/plane.png",
      "examples/media/rect.png",
      "examples/media/ruby.png",
-     "examples/media/saucer.csv",
      "examples/media/saucer.gal",
      "examples/media/saucer.png",
      "examples/media/spaceship.png",
-     "examples/media/stickfigure.bmp",
-     "examples/media/stickfigure.png",
+     "examples/media/star_25x25_default.png",
+     "examples/media/star_25x25_explode.gal",
+     "examples/media/star_25x25_explode.png",
+     "examples/media/stone_wall.bmp",
      "examples/media/video_games.png",
      "examples/media/wood.png",
      "lib/chingu.rb",
@@ -115,6 +123,7 @@ Gem::Specification.new do |s|
      "lib/chingu/rect.rb",
      "lib/chingu/require_all.rb",
      "lib/chingu/text.rb",
+     "lib/chingu/traits/animation.rb",
      "lib/chingu/traits/bounding_box.rb",
      "lib/chingu/traits/bounding_circle.rb",
      "lib/chingu/traits/collision_detection.rb",
@@ -130,7 +139,7 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{chingu}
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{OpenGL accelerated 2D game framework for Ruby}
   s.test_files = [
     "examples/example10_traits_retrofy.rb",
@@ -141,8 +150,10 @@ Gem::Specification.new do |s|
      "examples/example15_trait_timer2.rb",
      "examples/example16_online_high_scores.rb",
      "examples/example17_gosu_tutorial.rb",
-     "examples/example18_viewport.rb",
+     "examples/example18_animation_trait.rb",
+     "examples/example19_edit_viewport.rb",
      "examples/example1_basics.rb",
+     "examples/example20_trait_inheritence_test.rb",
      "examples/example2_gamestate_basics.rb",
      "examples/example3_parallax.rb",
      "examples/example4_gamestates.rb",
@@ -151,14 +162,15 @@ Gem::Specification.new do |s|
      "examples/example7_gfx_helpers.rb",
      "examples/example8_traits.rb",
      "examples/example9_collision_detection.rb",
-     "examples/game1.rb"
+     "examples/game1.rb",
+     "examples/game_of_life.rb"
   ]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<gosu>, [">= 0.7.18"])
     else
       s.add_dependency(%q<gosu>, [">= 0.7.18"])

data/examples/example10_traits_retrofy.rb

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
 require 'rubygems'
-require 'opengl'
 require File.join(File.dirname($0), "..", "lib", "chingu")
 include Gosu
 include Chingu
@@ -14,6 +13,7 @@ class Game < Chingu::Window
     super(600,400)
     self.caption = "Testing out new module-based traits (SPACE for more spaceships)"
     self.input = { :space => :create_thing, :esc => :exit }
+		Gosu::enable_undocumented_retrofication
     create_thing(200,200)
   end
 
@@ -33,8 +33,8 @@ class Game < Chingu::Window
 end
 
 class Thing < Chingu::GameObject
-  has_trait :effect
-  has_trait :velocity
+  trait :effect
+  trait :velocity
   
   def initialize(options)
     super
@@ -49,7 +49,9 @@ class Thing < Chingu::GameObject
     #
     # The above code has been merged into chingu as @image.retrofy
     #
-    @image.retrofy
+    # @image.retrofy
+		#
+		# Use Gosu::enable_undocumented_retrofication instead!
 
 
     self.scale = 8