root/lang/ruby/starframe/test/starframe/sprite/test_animation.rb @ 27505

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

class TestStarFrameSpriteAnimationInstance < Test::Unit::TestCase
  def setup
    @animation = StarFrame::Sprite::Animation.new nil
  end
  
  def test_instance_variables
    animation = StarFrame::Sprite::Animation.new nil
    assert_equal 0, animation.instance_variable_get(:@frame)
    assert_equal 0, animation.instance_variable_get(:@max_frame)
    assert_equal true, animation.instance_variable_get(:@loop)
    assert_equal true, animation.instance_variable_get(:@running)
  end
  
  def test_instance_variables_overwrite_options
    overwrited = Class.new(StarFrame::Sprite::Animation)
    overwrited.instance_variable_set(:@options,   {:loop => false, :start => false})
    overwrited.instance_variable_set(:@max_frame, 10)
    animation = overwrited.new nil
    assert_equal 0,  animation.instance_variable_get(:@frame)
    assert_equal 10, animation.instance_variable_get(:@max_frame)
    assert_equal false, animation.instance_variable_get(:@loop)
    assert_equal false, animation.instance_variable_get(:@running)
  end
  
  def test_instance_frame_controller_next
    @animation.instance_variable_set :@max_frame, 3
    assert_equal true,  @animation.next
    assert_equal 1, @animation.instance_variable_get(:@frame)
    assert_equal true,  @animation.next
    assert_equal 2, @animation.instance_variable_get(:@frame)
    assert_equal false, @animation.next
    assert_equal 0, @animation.instance_variable_get(:@frame)
  end
  def test_instance_frame_controller_rewind
    @animation.instance_variable_set :@frame, 1
    @animation.rewind
    assert_equal 0, @animation.instance_variable_get(:@frame)
  end
  
  def test_instance_animation_controller_update
    @animation.instance_variable_set :@max_frame, 3
    @animation.update
    assert_equal 1, @animation.instance_variable_get(:@frame)
  end
  def test_instance_animation_controller_update_with_stop
    @animation.instance_variable_set :@running, false
    @animation.instance_variable_set :@max_frame, 3
    @animation.update
    assert_equal 0, @animation.instance_variable_get(:@frame)
  end
  def test_instance_animation_controller_update_with_loop
    @animation.instance_variable_set :@max_frame, 3
    3.times{ @animation.update }
    assert_equal 0, @animation.instance_variable_get(:@frame)
    assert_equal true, @animation.instance_variable_get(:@running)
  end
  def test_instance_animation_controller_update_with_unloop
    @animation.instance_variable_set :@loop, false
    @animation.instance_variable_set :@max_frame, 3
    3.times{ @animation.update }
    assert_equal 0, @animation.instance_variable_get(:@frame)
    assert_equal false, @animation.instance_variable_get(:@running)
  end
  
  def test_instance_animation_controller_start
    @animation.instance_variable_set :@running, false
    @animation.start
    assert_equal true, @animation.instance_variable_get(:@running)
  end
  def test_instance_animation_controller_stop
    @animation.instance_variable_set :@running, true
    @animation.stop
    assert_equal false, @animation.instance_variable_get(:@running)
  end
  
  def test_instance_animation_controller_restart
    @animation.instance_variable_set :@frame, 3
    @animation.instance_variable_set :@running, false
    @animation.restart
    assert_equal 0,    @animation.instance_variable_get(:@frame)
    assert_equal true, @animation.instance_variable_get(:@running)
  end
end

class TestStarFrameSpriteAnimationPreparedInstance < Test::Unit::TestCase
  class AnimationSprite
    def initialize
      @called = []
    end
    
    attr_accessor :called
    def method_missing *args
      @called << args
    end
  end
  
  class PreparedAnimation < StarFrame::Sprite::Animation
    @animations = {
      0 => [
        [:method1, 0],
        [:method2, 10],
      ],
      1 => [
        [:method1, 1],
        [:method2, 11],
      ],
      2 => [
        [:method3, 0],
      ],
      3 => [
        [:method3, 2],
      ],
    }
    @max_frame = 4
  end
  
  def test_initialize_animations
    sprite1 = AnimationSprite.new
    animation1 = PreparedAnimation.new(sprite1)
    
    sprite2 = AnimationSprite.new
    animation2 = PreparedAnimation.new(sprite2)
    
    animation1.next
    assert_equal [[:method1, 0], [:method2, 10]], sprite1.called
    sprite1.called.clear
    
    animation1.next
    assert_equal [[:method1, 1], [:method2, 11]], sprite1.called
    sprite1.called.clear
    
    animation2.next
    assert_equal [[:method1, 0], [:method2, 10]], sprite2.called
    sprite2.called.clear
    
    animation1.next
    assert_equal [[:method3, 0]], sprite1.called
    sprite1.called.clear
    
    animation1.next
    assert_equal [[:method3, 2]], sprite1.called
    sprite1.called.clear
    
    animation1.next
    assert_equal [[:method1, 0], [:method2, 10]], sprite1.called
    sprite1.called.clear
  end
end

class TestStarFrameSpriteAnimationClassMethods < Test::Unit::TestCase
  class DefineSprite; end
  
  def test_define_method
    animation_class = Class.new(StarFrame::Sprite::Animation)
    animation_class.instance_variable_set :@sprite_class, DefineSprite
    
    before_instance_methods = DefineSprite.instance_methods
    before_method_count = StarFrame::Sprite::Animation::ClassMethods.__send__(:class_variable_get, :@@method_count)
    
    animation_class.__send__(:frame){ |c| return c }
    
    after_instance_methods = DefineSprite.instance_methods
    after_method_count = StarFrame::Sprite::Animation::ClassMethods.__send__(:class_variable_get, :@@method_count)
    method_name = "_starframe_sprite_animation_#{after_method_count}"
    
    assert_equal 1, (after_method_count-before_method_count)
    define_methods = after_instance_methods - before_instance_methods
    assert_equal [method_name], define_methods
    
    o = Object.new
    assert_equal o, DefineSprite.new.__send__(method_name, o)
  end
  
  def assertion_animations expected, max_frame, &block
    animation_class = Class.new(StarFrame::Sprite::Animation)
    animation_class.instance_variable_set :@sprite_class, DefineSprite
    
    before_method_count = StarFrame::Sprite::Animation::ClassMethods.__send__(:class_variable_get, :@@method_count)
    
    animation_class.class_eval &block
    
    counted_expected = {}
    expected.each do |frame, frame_animations|
      counted_expected[frame] = frame_animations.map do |count, c|
        [:"_starframe_sprite_animation_#{1+before_method_count+count}", c]
      end
    end
    
    assert_equal counted_expected, animation_class.animations
    assert_equal max_frame,        animation_class.max_frame
  end
  
  def test_frames
    assertion_animations({
      0 => [[0, 10]],
      1 => [[0, 20]],
    }, 2) do
      frames [10, 20] do |c|
      end
    end
  end
  def test_frames_with_interval
    assertion_animations({
      0 => [[0, 10]],
      2 => [[0, 20]],
    }, 4) do
      frames([10, 20], 2){|c|}
    end
  end
  
  def test_frames_exception
    animation_class = Class.new(StarFrame::Sprite::Animation)
    animation_class.instance_variable_set :@sprite_class, DefineSprite
    
    assert_raise(RangeError){ animation_class.class_eval{ frames(0){|c|} } }
    assert_raise(RangeError){ animation_class.class_eval{ frames(-1){|c|} } }
    assert_raise(ArgumentError){ animation_class.class_eval{ frames(1, 0){|c|} } }
    assert_raise(ArgumentError){ animation_class.class_eval{ frames(1, -1){|c|} } }
  end
  
  def test_frame
    assertion_animations({
      0 => [[0, 0]],
    }, 1) do
      frame{|c|}
    end
  end
  def test_frame_with_interval
    assertion_animations({
      0 => [[0, 0]],
    }, 2) do
      frame(2){|c|}
    end
  end
  
  def test_wait
    assertion_animations({
    }, 10) do
      wait 10
    end
  end
  
  def test_default_serial
    assertion_animations({
      0 => [[0, 1]],
      1 => [[0, 2]],
      2 => [[1, 3]],
      3 => [[1, 4]],
      4 => [[1, 5]],
    }, 5) do
      frames([1, 2]){|c|}
      frames([3, 4, 5]){|c|}
    end
  end
  
  def test_serial
    assertion_animations({
      0 => [[0, 1]],
      1 => [[0, 2]],
      2 => [[1, 3]],
      3 => [[1, 4]],
      4 => [[1, 5]],
    }, 5) do
      serial do
        frames([1, 2]){|c|}
        frames([3, 4, 5]){|c|}
      end
    end
  end
  
  def test_parallel
    assertion_animations({
      0 => [[0, 1], [1, 3]],
      1 => [[0, 2], [1, 4]],
      2 => [        [1, 5]],
    }, 3) do
      parallel do
        frames([1, 2]){|c|}
        frames([3, 4, 5]){|c|}
      end
    end
  end
end

class TestStarFrameSpriteAnimationClassMethodsTimeline < Test::Unit::TestCase
  def assert_entries_in_delta expecteds, actuals, delta
    assert_equal expecteds.size, actuals.size
    
    expecteds.zip actuals do |expected_float, actual_float|
      assert_in_delta expected_float, actual_float, delta
    end
  end
  
  def test_linear
    expecteds = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]
    actuals   = StarFrame::Sprite::Animation.__send__(:linear, 10)
    assert_entries_in_delta expecteds, actuals, 0.1
  end
  
  def test_accelerate
    expecteds = [0.0, 0.1, 0.4, 0.9, 1.6, 2.5, 3.6, 4.9, 6.4, 8.1]
    actuals   = StarFrame::Sprite::Animation.__send__(:accelerate, 10)
    assert_entries_in_delta expecteds, actuals, 0.1
  end
  
  def test_decelerate
    expecteds = [0.0, 1.9, 3.6, 5.1, 6.4, 7.5, 8.4, 9.1, 9.6, 9.9]
    actuals   = StarFrame::Sprite::Animation.__send__(:decelerate, 10)
    assert_entries_in_delta expecteds, actuals, 0.1
  end
end