Index: lang/ruby/starframe/test/starframe/sprite/test_collision.rb
===================================================================
--- lang/ruby/starframe/test/starframe/sprite/test_collision.rb (revision 27314)
+++ lang/ruby/starframe/test/starframe/sprite/test_collision.rb (revision 27463)
@@ -3,50 +3,13 @@
 
 class StarFrame::Sprite::Collision
-  attr_accessor :target, :method_name, :options
-  class Builder
-    attr_accessor :target, :name, :method_name, :collision, :options
-  end
+  attr_accessor :sprite, :method_name
 end
 
 class TestStarFrameSpriteCollision < Test::Unit::TestCase
-  class CollisionObject
+  class CollidaleObject
     attr_accessor :other
     def collide other
       @other = other
     end
-  end
-  
-  # Collision::Builder#initialize
-  def test_builder_initialize
-    collision_builder = StarFrame::Sprite::Collision::Builder.new(CollisionObject, :collision, TrueCollision, :options)
-    assert_equal CollisionObject, collision_builder.target
-    assert_equal :collision,      collision_builder.name
-    assert_nil                    collision_builder.method_name
-    assert_equal TrueCollision,   collision_builder.collision
-    assert_equal [:options],      collision_builder.options
-  end
-  def test_builder_initialize_with_block
-    collision_builder = StarFrame::Sprite::Collision::Builder.new(CollisionObject, :collision, TrueCollision, :options){ |other| }
-    assert_equal CollisionObject,                                   collision_builder.target
-    assert_equal :collision,                                        collision_builder.name
-    assert_equal :_starframe_sprite_collision__collision_collision, collision_builder.method_name
-    assert_equal TrueCollision,                                     collision_builder.collision
-    assert_equal [:options],                                        collision_builder.options
-    
-    collision_object = CollisionObject.new
-    assert_respond_to collision_object, :_starframe_sprite_collision__collision_collision
-  end
-  
-  # Collision::Builder#build
-  def test_builder_build
-    collision_builder = StarFrame::Sprite::Collision::Builder.new(CollisionObject, :collision, TrueCollision, :options){ |other| }
-    collision_object = CollisionObject.new
-    
-    collision = collision_builder.build(collision_object)
-    assert_instance_of TrueCollision, collision
-    
-    assert_equal collision_object,                                  collision.target
-    assert_equal :_starframe_sprite_collision__collision_collision, collision.method_name
-    assert_equal [:options],                                        collision.options
   end
   
@@ -82,5 +45,5 @@
     end
   end
-  class TestCollision < StarFrame::Sprite::Collision
+  class ReflectCollision < StarFrame::Sprite::Collision
     # 相手に依存された場合trueを、されていない場合falseを返す
     def collide? other
@@ -89,25 +52,32 @@
   end
   
+  def test_initialize
+    sprite = CollidaleObject.new
+    collision = StarFrame::Sprite::Collision.new(sprite, :collide)
+    assert_equal sprite,   collision.sprite
+    assert_equal :collide, collision.method_name
+  end
+  
   # Collision#collide?
-  def test_collides
-    object = CollisionObject.new
-    test_collision  = TestCollision.new  object, :test
-    none_collision  = NoneCollision.new  object, :none
-    true_collision  = TrueCollision.new  object, :true
-    false_collision = FalseCollision.new object, :false
+  def test_collide_q
+    sprite = CollidaleObject.new
+    none_collision  = NoneCollision.new    sprite, :none
+    true_collision  = TrueCollision.new    sprite, :true
+    false_collision = FalseCollision.new   sprite, :false
+    test_collision  = ReflectCollision.new sprite, :reflect
     [
-      [test_collision,  test_collision,  nil,   nil],
-      [test_collision,  none_collision,  nil,   true],
-      [test_collision,  true_collision,  nil,   true],
-      [test_collision,  false_collision, nil,   true],
-      
       [none_collision,  none_collision,  nil,   nil],
       [none_collision,  true_collision,  nil,   nil],
       [none_collision,  false_collision, nil,   nil],
+      [none_collision,  test_collision,  true,  nil],
       
       [true_collision,  true_collision,  true,  true],
       [true_collision,  false_collision, true,  true],
+      [true_collision,  test_collision,  true,  nil],
       
       [false_collision, false_collision, false, false],
+      [false_collision, test_collision,  true,  nil],
+      
+      [test_collision,  test_collision,  nil,   nil],
     ].each do |collition1, collition2, result_1to2, result_2to1 |
       assert_equal result_1to2, collition1.collide?(collition2), "#{collition1} -> #{collition2}"
@@ -116,63 +86,66 @@
   end
   
-  def test_collide_true
-    object1 = CollisionObject.new
-    object2 = CollisionObject.new
+  def test_collide
+    sprite1 = CollidaleObject.new
+    sprite2 = CollidaleObject.new
     
-    collision1 = TrueCollision.new object1, :collide
-    collision2 = TrueCollision.new object2, :collide
+    collision1 = TrueCollision.new sprite1, :collide
+    collision2 = TrueCollision.new sprite2, :collide
     
     assert_equal true, collision1.collide(collision2)
-    assert_equal object2, object1.other
-    assert_equal object1, object2.other
+    assert_equal sprite2, sprite1.other
+    assert_equal sprite1, sprite2.other
   end
   def test_collide_false
-    object1 = CollisionObject.new
-    object2 = CollisionObject.new
+    sprite1 = CollidaleObject.new
+    sprite2 = CollidaleObject.new
     
-    collision1 = FalseCollision.new object1, :collide
-    collision2 = FalseCollision.new object2, :collide
+    collision1 = FalseCollision.new sprite1, :collide
+    collision2 = FalseCollision.new sprite2, :collide
     
     assert_equal false, collision1.collide(collision2)
-    assert_nil object1.other
-    assert_nil object2.other
+    assert_nil sprite1.other
+    assert_nil sprite2.other
   end
   def test_collide_nil
-    object1 = CollisionObject.new
-    object2 = CollisionObject.new
+    sprite1 = CollidaleObject.new
+    sprite2 = CollidaleObject.new
     
-    collision1 = TrueCollision.new object1, :collide
-    collision2 = TrueCollision.new object2, nil
+    collision1 = TrueCollision.new sprite1, :collide
+    collision2 = TrueCollision.new sprite2, nil
     
     assert_equal true, collision1.collide(collision2)
-    assert_equal object2, object1.other
-    assert_nil            object2.other
+    assert_equal sprite2, sprite1.other
+    assert_nil            sprite2.other
   end
   
   # Collision#position
   def test_position
-    object1 = CollisionObject.new
-    class << object1
+    sprite = CollidaleObject.new
+    class << sprite
       attr_accessor :x, :y
     end
-    object1.x = 1
-    object1.y = 2
+    sprite.x, sprite.y = 0, 0
     
-    collision1 = TrueCollision.new object1, nil
-    class << collision1
-      attr_accessor :x, :y
-      public :position
+    collision = TrueCollision.new sprite, nil
+    class << collision
+      public :global_position
     end
-    collision1.x = 1
-    collision1.y = 2
+    assert_equal [0, 0], collision.position
     
-    x, y = collision1.position
+    assert_equal [0, 0], collision.global_position
     
-    assert_equal 2, x
-    assert_equal 4, y
+    collision.position = 1, 2
+    assert_equal [1, 2], collision.global_position
+    
+    sprite.x, sprite.y = 1, 2
+    assert_equal [2, 4], collision.global_position
+    
+    collision.position = 3, 4
+    assert_equal [4, 6], collision.global_position
   end
   
   # Collision class methods
-  def test_dot_in_rect
+  def test_class_static_dot_in_rect
     -1.step(1, 0.1) do |x|
       -1.step(1, 0.1) do |y|
@@ -183,5 +156,5 @@
   end
   
-  def test_dot_in_circle
+  def test_class_dot_in_circle
     -1.step(1, 0.1) do |x|
       -1.step(1, 0.1) do |y|