void Handle_YunMuAnimating(tk2dSpriteAnimator sprite, tk2dSpriteAnimationClip clip, int frameNum)
 {
     tk2dSprite mspr  = sprite.GetComponent<tk2dSprite>( );
     Color c = mspr.color;
     c.a = mYunMuCurrentAlpha;
     mspr.color = c;
 }

 void AnimationEventDelegate(tk2dAnimatedSprite sprite, tk2dSpriteAnimationClip clip, tk2dSpriteAnimationFrame frame, int frameNum)
 {
     Fsm.EventData.IntData = frame.eventInt;
     Fsm.EventData.StringData = frame.eventInfo;
     Fsm.EventData.FloatData = frame.eventFloat;
     Fsm.Event(animationTriggerEvent);
 }

 public void ClipDeleted(tk2dSpriteAnimationClip clip, int param)
 {
     clip.Clear();
     selectedClip = null;
     FilterClips();
     Repaint();
 }

 // done breathing fire, just walk again
 void FireCompleteDelegate(tk2dSpriteAnimator sprite, tk2dSpriteAnimationClip clip)
 {
     if(clip.name.Equals("Fire"))
     {
         anim.Play("Walk");
     }
 }

        // Check the AnimOperator class for the different supported operator types.
        // This sample simply deletes the frames after the currently selected clip.
        public override bool OnFrameGroupInspectorGUI(tk2dSpriteAnimationClip selectedClip, 
					List<ClipEditor.FrameGroup> frameGroups, 
					TimelineEditor.State state )
        {
            // WrapMode.Single is a special case - you are only allowed to have one frame in a "Single" clip.
            // If you don't handle this, tk2d will truncate the list when it is Committed.
            if (selectedClip.wrapMode == tk2dSpriteAnimationClip.WrapMode.Single)
                return false;

            // Keep track of changes.
            // In a lot of cases, a simple bool will suffice. This is used later to
            // tell the system that something has changed.
            bool changed = false;
            GUILayout.BeginHorizontal();
            if (GUILayout.Button("Ins <-", EditorStyles.miniButton))
            {
                frameGroups.Insert(state.selectedFrame,
                    AnimOperatorUtil.NewFrameGroup(frameGroups, state.selectedFrame));
                // Make sure state is valid after performing your operation.
                // For instance, if the selected frame is deleted, ensure it isn't selected any more.
                state.selectedFrame++;
                changed = true;
            }
            if (GUILayout.Button("Ins ->", EditorStyles.miniButton))
            {
                frameGroups.Insert(state.selectedFrame + 1,
                    AnimOperatorUtil.NewFrameGroup(frameGroups, state.selectedFrame));
                changed = true;
            }
            GUILayout.EndHorizontal();

            // Tell the caller what has changed
            operations = changed ? AnimEditOperations.ClipContentChanged : AnimEditOperations.None;
            return changed;
        }

 void Handle_FishAniStop(tk2dSpriteAnimator sprAni, tk2dSpriteAnimationClip aniClip)
 {
     if (mFish != null && mFish.Attackable)
     {
         mFish.AniSprite.PlayFrom(mOriginClip,0F);
     }
 }

    void FlameOnDelegate(tk2dSpriteAnimator animator, tk2dSpriteAnimationClip clip, int frameNumber)
    {
        if(clip.GetFrame(frameNumber).eventInfo.Equals("FlameOn"))
        {
            string fireTag = fireHitObject.tag;

            if (fireTag.Equals("Throwable"))
            {
                Vector3 position = fireHitObject.transform.position;
                position.z = charcoalParticleEffect.transform.position.z;

                // KILL THE PEASANTS
                Destroy(fireHitObject);

                // BURNINATE THE PEASANTS (particle effects)
                ParticleSystem localCharcoal = GameObject.Instantiate(charcoalParticleEffect, position, charcoalParticleEffect.transform.rotation) as ParticleSystem;
                localCharcoal.Play();
            }
            else if (fireTag.Equals("Player"))
            {
                // TODO: tell player to get bumped
            }
        }

        if(clip.GetFrame(frameNumber).eventInfo.Equals("DragonFootStep"))
        {
            AudioSource.PlayClipAtPoint(footSteps[Random.Range( 0, footSteps.Count )], transform.position);
        }
    }

    public void Play(int id)
    {
        clipId = id;
        if (id >= 0 && anim && id < anim.clips.Length)
        {
            currentClip = anim.clips[id];

            // Simply swap, no animation is played
            if (currentClip.wrapMode == tk2dSpriteAnimationClip.WrapMode.Single || currentClip.frames == null)
            {
                SwitchCollectionAndSprite(currentClip.frames[0].spriteCollection, currentClip.frames[0].spriteId);

                if (currentClip.frames[0].triggerEvent)
                {
                    if (animationEventDelegate != null)
                        animationEventDelegate( this, currentClip, currentClip.frames[0], 0 );
                }
                currentClip = null;
            }
            else
            {
                clipTime = 0.0f;
                previousFrame = -1;
            }
        }
        else
        {
            OnCompleteAnimation();
            currentClip = null;
        }
    }

 public void CopyFrom(tk2dSpriteAnimationClip source)
 {
     this.name = source.name;
     if (source.frames == null)
     {
         this.frames = null;
     }
     else
     {
         this.frames = new tk2dSpriteAnimationFrame[source.frames.Length];
         for (int i = 0; i < this.frames.Length; i++)
         {
             if (source.frames[i] == null)
             {
                 this.frames[i] = null;
             }
             else
             {
                 this.frames[i] = new tk2dSpriteAnimationFrame();
                 this.frames[i].CopyFrom(source.frames[i]);
             }
         }
     }
     this.fps = source.fps;
     this.loopStart = source.loopStart;
     this.wrapMode = source.wrapMode;
     if ((this.wrapMode == WrapMode.Single) && (this.frames.Length > 1))
     {
         this.frames = new tk2dSpriteAnimationFrame[] { this.frames[0] };
         Debug.LogError(string.Format("Clip: '{0}' Fixed up frames for WrapMode.Single", this.name));
     }
 }

 public tk2dSpriteAnimationClip(tk2dSpriteAnimationClip source)
 {
     this.name = "Default";
     this.frames = new tk2dSpriteAnimationFrame[0];
     this.fps = 30f;
     this.CopyFrom(source);
 }

    protected override void OnAnimationClipEnd(tk2dSpriteAnimator aAnim, tk2dSpriteAnimationClip aClip) {
        if(anim == aAnim && aClip == mClips[(int)AnimState.attack]) {
            mActActive = false;
            mFireActive = false;
        }

        base.OnAnimationClipEnd(aAnim, aClip);
    }

 // This is called once the hit animation has compelted playing
 // It returns to playing whatever animation was active before hit
 // was playing.
 void HitCompleteDelegate(tk2dSpriteAnimator sprite, tk2dSpriteAnimationClip clip)
 {
     if (walking) {
         anim.Play("walk");
     }
     else {
         anim.Play("idle");
     }
 }

    void FrameDeploymentTrigger(tk2dAnimatedSprite sprite, 
		tk2dSpriteAnimationClip clip, 
		tk2dSpriteAnimationFrame frame, 
		int frameNum)
    {
        //Debug.Log("MinigunBoxController:FrameDeploymentTrigger()");

        DeployGun();
    }

 void Awake()
 {
     mAnispr = GetComponent<tk2dSpriteAnimator>();
     if (mAnispr == null)
         return;
     mOriClip = mAnispr.DefaultClip;
     //mOriClipidx = mAnispr.DefaultClipId;
     tk2dSpriteAnimationClip aniClip = mAnispr.Library.clips[mAnispr.Library.GetClipIdByName(AniName)];
     mSpecAniLength = aniClip.frames.Length / aniClip.fps;
 }

 void HandleAnimationEvent(tk2dAnimatedSprite sprite, tk2dSpriteAnimationClip clip, tk2dSpriteAnimationFrame frame, int frameNum)
 {
     // Call FrameActionHandlers
     frame.eventInfo.Split(new []{","},System.StringSplitOptions.RemoveEmptyEntries).ToList()
         .ForEach(
             (x) => {
                 frameActions[x](x,frame.eventFloat,frame.eventInt);
             }
         );
 }

        public void Draw(int windowWidth, tk2dSpriteAnimationClip clip, List<ClipEditor.FrameGroup> frameGroups, float clipTimeMarker)
        {
            int space = clipLeftHeaderSpace;

            int requiredWidth = space + (clip.frames.Length + 1) * frameWidth;
            int clipHeightTotal = (requiredWidth > windowWidth) ? clipHeightScrollBar : clipHeight;

            clipScrollbar = GUILayout.BeginScrollView(clipScrollbar, GUILayout.Height(clipHeightTotal), GUILayout.ExpandWidth(true));
            GUILayout.BeginVertical();

            // Draw timeline axis
            GUILayout.Box("", EditorStyles.toolbar, GUILayout.ExpandWidth(true));
            Rect timelineRect = GUILayoutUtility.GetLastRect();
            DrawAxis(clip, new Rect(timelineRect.x + space, timelineRect.y, timelineRect.width - space, timelineRect.height), frameWidth);

            // Draw background and derive trigger rect
            GUILayout.Box("", tk2dEditorSkin.Anim_BG, GUILayout.ExpandWidth(true), GUILayout.Height(16));
            Rect triggerRect = GUILayoutUtility.GetLastRect();

            // Trigger helpbox
            Rect triggerHelpBox = new Rect(triggerRect.x, triggerRect.y, triggerRect.height, triggerRect.height);
            if (GUIUtility.hotControl == 0 && triggerHelpBox.Contains(Event.current.mousePosition))
                GUI.Label(new Rect(triggerHelpBox.x, triggerHelpBox.y, 150, triggerHelpBox.height), "Double click to add triggers", EditorStyles.whiteMiniLabel);
            else
                GUI.Label(triggerHelpBox, "?", EditorStyles.whiteMiniLabel);

            // Control IDs
            int triggerControlId = "tk2d.DrawClip.Triggers".GetHashCode();
            int frameGroupControlId = "tk2d.DrawClip.FrameGroups".GetHashCode();

            // Draw triggers
            DrawTriggers(triggerControlId, triggerRect, clip);

            // Draw frames
            GUILayout.BeginHorizontal();

            int framesWidth = clipLeftHeaderSpace + (clip.frames.Length + 1) * frameWidth;
            Rect frameGroupRect = GUILayoutUtility.GetRect(framesWidth, 1, GUILayout.ExpandHeight(true));
            DrawFrameGroups(frameGroupControlId, frameGroupRect, clip, frameGroups, clipTimeMarker);

            GUILayout.EndHorizontal();
            GUILayout.EndVertical();

            if (Event.current.type == EventType.ScrollWheel && (Event.current.alt || Event.current.control))
            {
                frameWidth =  Mathf.Clamp((int)(Event.current.delta.y + frameWidth), minFrameWidth, maxFrameWidth);
                Repaint();
            }

            GUILayout.EndScrollView();

            Rect scrollRect = GUILayoutUtility.GetLastRect();
            DrawFrameGroupsOverlay(frameGroupControlId, new Rect(scrollRect.x + frameGroupRect.x, scrollRect.y + frameGroupRect.y, frameGroupRect.width, frameGroupRect.height), clip, frameGroups, clipTimeMarker);
        }

 public int GetClipIdByName(tk2dSpriteAnimationClip clip)
 {
     for (int i = 0; i < this.clips.Length; i++)
     {
         if (this.clips[i] == clip)
         {
             return i;
         }
     }
     return -1;
 }

    void ThrowCompleteDelegate(tk2dSpriteAnimator sprite, tk2dSpriteAnimationClip clip)
	{
        _state = EnemyStateEnum.Walking;
		if (_state == EnemyStateEnum.Walking)
		{
			anim.Play("EnemyWalk");
		}
		else if(_state == EnemyStateEnum.Hited)
		{
			anim.Play("EnemyHited");
		}
	}

 void HitCompleteDelegate(tk2dSpriteAnimator sprite, tk2dSpriteAnimationClip clip)
 {
     _state = EnemyStateEnum.Walking;
     if (_state == EnemyStateEnum.Walking)
     {
         anim.Play("EnemyWalk");
     }
     else if (_state == EnemyStateEnum.ThrowWeapon)
     {
         anim.Play("ThrowWeapon");
     }
 }

 float CalculateClipMoveSpeed(tk2dSpriteAnimationClip clip)
 {
     int moveSum = 0;
     int numFrames = 0;
     foreach(var frame in clip.frames){
         numFrames++;
         if(frame.eventInfo.Contains("move")){
             moveSum += frame.eventInt;
         }
     }
     return moveSum/numFrames * clip.fps;
 }