// Use this for initialization
 public void Setup()
 {
     _animations = GameObject.Find("Frameworks/OT/Animations/player").GetComponent<OTAnimation>();
     _animSprite = GetComponentInChildren<OTAnimatingSprite>();
     _STATIC = "static";
     _WALK = "walk";
     _WALKFASTER = "walkfaster";
     _MAXWALK = "maxwalk";
     _CURR = "walk";
 }

    void SetAnimationFrame(OTAnimation.Frame animationFrame)
    {
        if (spriteContainer != animationFrame.container || animationFrame.frameIndex != frameIndex)
        {
            if (passive)
            {
                spriteContainer = animationFrame.container;
                frameIndex = animationFrame.frameIndex;
            }
            else
            {
                _spriteContainer = animationFrame.container;
                _frameIndex = animationFrame.frameIndex;
            }

            if (onAnimationFrame != null)
                onAnimationFrame(this);
            if (!CallBack("onAnimationFrame", callBackParams))
                CallBack("OnAnimationFrame", callBackParams);

            isDirty = true;
        }
    }

 public static void RemoveAnimation(OTAnimation o)
 {
     if (isValid)
         instance._RemoveAnimation(o);
 }

 // Use this for initialization
 protected void Awake()
 {
     anim = GetComponent<OTAnimation>();
     sprite = GetComponent<OTAnimatingSprite>();
 }

 /// <summary>
 /// Plays a specific animation partly backward from a start frame to an end frame, starting after a delay.
 /// </summary>
 /// <param name="animation">Animation to play</param>
 /// <param name="startFrame">Animation frame number (from the back) where to start.</param>
 /// <param name="endFrame">Animation frame number (from the back) where to end.</param>
 /// <param name="delay">After this delay in seconds the animation will be started.</param>
 public void PlayBackward(OTAnimation animation, int startFrame, int endFrame, float delay)
 {
     if (animation != null)
     {
         this.animation = animation;
         this.animationFrameset = "";
         PlayBackward(startFrame, endFrame, delay);
     }
 }

 void _DestroyAnimation(OTAnimation animation)
 {
     _RemoveAnimation(animation);
     if (animation.gameObject != null)
         Destroy(animation.gameObject);
 }

 void _RegisterAnimationLookup(OTAnimation animation, string oldName)
 {
     if (animationList.Contains(animation))
     {
         if (animations.ContainsKey(oldName.ToLower()) && animations[oldName.ToLower()] == animation)
             animations.Remove(oldName.ToLower());
         if (animations.ContainsKey(animation.name.ToLower()))
             animations.Remove(animation.name.ToLower());
         animations.Add(animation.name.ToLower(), animation);
     }
 }

 void _RemoveAnimation(OTAnimation animation)
 {
     if (animationList.Contains(animation))
     {
         string lname = animation.name.ToLower();
         if (animations.ContainsKey(lname))
             animations.Remove(lname);
         if (animationList.Contains(animation))
             animationList.Remove(animation);
     }
 }

    void _RegisterAnimation(OTAnimation animation)
    {
        if (!animationList.Contains(animation))
            animationList.Add(animation);
        if (!animations.ContainsKey(animation.name.ToLower()))
            animations.Add(animation.name.ToLower(), animation);
        else
        {
            if (animations[animation.name.ToLower()] != animation)
                Debug.LogError("More than one Animation with name '" + animation.name + "'");
        }
		
		foreach (Transform child in transform)
		{
			if (child.name.ToLower() == "animations")
			{
				animation.transform.parent = child.transform;
				break;
			}
		}
				
		
    }

	void _ResetAnimation(OTAnimation animation)
	{
		animation.Reset();		
	}

 void Awake()
 {
     anim = GetComponent<OTAnimation>();
     sprite = GetComponent<OTAnimatingSprite>();
     unit = GetComponent<Unit>();
     cc = GetComponent<CharacterController>();
     ac = GetComponent<AudioControl>();
 }

 // Use this for initialization
 protected void Awake()
 {
     anim = GetComponent<OTAnimation>();
     sprite = GetComponent<OTAnimatingSprite>();
     print (	sprite.animationFrameset);
 }

 public static void RegisterAnimation(OTAnimation animation)
 {
     if (isValid)
         instance._RegisterAnimation(animation);
 }

 public static void RegisterAnimationLookup(OTAnimation animation, string oldName)
 {
     if (isValid)
         instance._RegisterAnimationLookup(animation, oldName);
 }

 /// <summary>
 /// Destroys an Orthello animation
 /// </summary>
 public static void DestroyAnimation(OTAnimation animation)
 {
     if (isValid)
         instance._DestroyAnimation(animation);
 }

 void Awake()
 {
     GlobalOptions options = GlobalOptions.Instance;
     playerTeams = options.GetPlayerTeams();
     playerCharacters = options.GetPlayerCharacters();
     // This is hardcoded to 4 players and 4 teams.
     for (int i = 0; i < 4; i++) {
         GameObject player = playerPrefabs[i];
         playerStarts[i] = GameObject.Find("Player" + (i + 1).ToString() + " Start").GetComponent<Transform>();
         teamScoreStarts[i] = GameObject.Find("TeamScore" + (i + 1).ToString() + " Start").GetComponent<Transform>();
     }
     ballStart = GameObject.Find("Ball Start").GetComponent<Transform>();
     ballAnimation = GameObject.Find("Ball Animation").GetComponent<OTAnimation>();
 }

    private void getDefaultAnim()
    {
        //Obtengo la animacion de tapar la carta

        GameObject[] anim = GameObject.FindGameObjectsWithTag("cardToBack");
        this.cardToBack = (OTAnimation)anim[0].GetComponent(typeof(OTAnimation));
    }

 // Use this for initialization
 void Start()
 {
     _character 	= GetComponent<Character>();
     _player 	= GetComponent<Player>();
     anim = animSprite.animation;//GameObject.Find("Player/spriteParent/playerSprite-1").GetComponent<OTAnimatingSprite
 }