root/lang/ruby/starframe/test/starframe/sprite/test_collidable.rb @ 28001

require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "helper"))
require "starframe/sprite"
require "starframe/sprite/collidable"

class TestStarFrameSpriteCollidable < Test::Unit::TestCase
  class TestCollision < StarFrame::Sprite::Collision::Base
    attr_accessor :options
    
    def initialize target, method_name, options1, options2
      super
    end
    
    def collide? other
      (global_position == other.global_position)
    end
  end
  
  class CollisionSprite < StarFrame::Sprite
    include StarFrame::Sprite::Collidable
    attr_reader :collisions
    
    @texture = StarRuby::Texture.load "texture"
    
    attr_reader :others
    init do |*args|
      @others = []
    end
    collision :test, TestCollision, :options1, :options2 do |other|
      @others << other
    end
  end
  class CollisionSpriteSub < CollisionSprite
    collision :test2, TestCollision, :options_sub do |other|
    end
  end
  class EmptyCollisionSpriteSub < CollisionSprite
    collision :test3, TestCollision, :options
  end
  
  def test_class_variables
    assert_equal 1, CollisionSprite.collisions.size
    assert_equal TestCollision,          CollisionSprite.collisions[:test][0]
    assert_equal true,                   CollisionSprite.method_defined?(CollisionSprite.collisions[:test][1])
    assert_equal [:options1, :options2], CollisionSprite.collisions[:test][2]
  end
  
  def test_class_variables_subclass
    assert_not_equal   CollisionSprite.collisions.__id__, CollisionSpriteSub.collisions.__id__
    assert_equal CollisionSprite.collisions, CollisionSpriteSub.collisions.reject{|k,v| k == :test2 } 
    
    assert_equal 2, CollisionSpriteSub.collisions.size
    assert_equal [:options_sub], CollisionSpriteSub.collisions[:test2][2]
  end
  
  def test_class_variables_empty_collision
    assert_equal true,  EmptyCollisionSpriteSub.collisions.key?(:test3)
    assert_equal false, EmptyCollisionSpriteSub.method_defined?(:_starframe_sprite_collidable__collision_test3)
    assert_nil          EmptyCollisionSpriteSub.collisions[:test3][1]
  end
  
  def test_initialize
    sprite = CollisionSprite.new(10, 10)
    assert_equal       1,             sprite.collisions.size
    assert_equal       true,          sprite.collisions.key?(:test)
    assert_instance_of TestCollision, sprite.collisions[:test]
    assert_equal       sprite,        sprite.collisions[:test].instance_variable_get(:@sprite)
  end
  
  def test_collision_reader
    sprite = CollisionSprite.new(10, 10)
    assert_not_nil                           sprite.collision(:test)
    assert_equal   sprite.collisions[:test], sprite.collision(:test)
  end
  
  
  def assert_collide sprite1, sprite2, expected, &block
    assert_equal expected, block.call(sprite1, sprite2)
  end
  def assert_collide_sprite_and_sprite expected, collide = false, &block
    sprite1 = CollisionSprite.new(10, 10)
    sprite2 = CollisionSprite.new((expected ? 10 : 11), 10)
    
    assert_collide sprite1, sprite2, expected, &block
    
    if collide
      assert_equal [sprite2], sprite1.others
      assert_equal [sprite1], sprite2.others
    else
      assert_equal [], sprite1.others
      assert_equal [], sprite2.others
    end
  end
  
  def test_collide_true
    assert_collide_sprite_and_sprite expected = true, collide = true do |sprite1, sprite2|
      sprite1.collide(:test, sprite2, :test)
    end
  end
  def test_collide_false
    assert_collide_sprite_and_sprite expected = false, collide = false do |sprite1, sprite2|
      sprite1.collide(:test, sprite2, :test)
    end
  end
  def test_collide_q_true
    assert_collide_sprite_and_sprite expected = true, collide = false do |sprite1, sprite2|
      sprite1.collide?(:test, sprite2, :test)
    end
  end
  def test_collide_q_false
    assert_collide_sprite_and_sprite expected = false, collide = false do |sprite1, sprite2|
      sprite1.collide?(:test, sprite2, :test)
    end
  end
  
  def test_collide_with_collision_true
    assert_collide_sprite_and_sprite expected = true, collide = true do |sprite1, sprite2|
      sprite1.collide(:test, sprite2.collision(:test))
    end
  end
  def test_collide_with_collision_false
    assert_collide_sprite_and_sprite expected = false, collide = false do |sprite1, sprite2|
      sprite1.collide(:test, sprite2.collision(:test))
    end
  end
  def test_collide_q_with_collision_true
    assert_collide_sprite_and_sprite expected = true, collide = false do |sprite1, sprite2|
      sprite1.collide?(:test, sprite2.collision(:test))
    end
  end
  def test_collide_q_with_collision_false
    assert_collide_sprite_and_sprite expected = false, collide = false do |sprite1, sprite2|
      sprite1.collide?(:test, sprite2.collision(:test))
    end
  end
  
  def assert_collide_collection_and_sprite collide = false, &block
    collection = StarFrame::Sprite::Collection.new
    collection << csprite1 = CollisionSprite.new(10, 10)
    collection << csprite2 = CollisionSprite.new(10, 10)
    collection << csprite3 = CollisionSprite.new(11, 10)
    sprite                 = CollisionSprite.new(10, 10)
    
    assert_collide collection, sprite, 2, &block
    
    if collide
      assert_equal [sprite],             csprite1.others
      assert_equal [sprite],             csprite2.others
      assert_equal [],                   csprite3.others
      assert_equal [csprite1, csprite2], sprite.others
    else
      assert_equal [], csprite1.others
      assert_equal [], csprite2.others
      assert_equal [], csprite3.others
      assert_equal [], sprite.others
    end
  end
  def test_collection_collide
    assert_collide_collection_and_sprite collide = true do |collection, sprite|
      collection.collide(:test, sprite, :test)
    end
  end
  def test_collection_collide_q
    assert_collide_collection_and_sprite collide = false do |collection, sprite|
      collection.collide?(:test, sprite, :test)
    end
  end
  def test_collide_with_collection
    assert_collide_collection_and_sprite collide = true do |collection, sprite|
      sprite.collide(:test, collection, :test)
    end
  end
  def test_collide_q_with_collection
    assert_collide_collection_and_sprite collide = false do |collection, sprite|
      sprite.collide?(:test, collection, :test)
    end
  end
end