Unity C# - Is playing/Is completed?

Jekht

Hi,

I looked through the documentation, and I saw there was an "Is completed?" method. However I can't seem to get it to work. Unity comes up with an error:

Assets/AnimateGibbSkeleton.cs(134,30): error CS1061: Type Spine.AnimationState' does not contain a definition forIsComplete' and no extension method IsComplete' of typeSpine.AnimationState' could be found (are you missing a using directive or an assembly reference?)

Can anyone kindly give me an example snippet of C# code for detecting Is Playing (of a specific animation) and Is Completed (also of a specific animation) ? Or point me in the right direction?

Right now playing anims works using the below, so not sure why the IsComplete method doesn't work.

sk.state.SetAnimation(0, "swordcrouchf", false);
sk.state.AddAnimation(0, "swordrisingf", false, 0);

Thanks,
J

Jekht

Nate

Sorry, the documentation is slightly out of date of the runtimes. I'll be updating it once skinning is done for the runtimes:
https://trello.com/c/3qoEbhDJ/62-update ... t-runtimes

AnimationState no longer has an IsComplete method because it now supports multiple tracks, that is it can apply multiple animations on top of each other (eg shooting while running/walking/swimming). To check if a track is playing an animation, use GetCurrent(trackNumber). If it returns null, nothing is playing on that track. When a non-looping animation reaches its end time, it is removed from the track. If another animation is queued to be played after it, that animation is the current for that track.

GetCurrent(trackNumber) returns a TrackEntry (when not null) which has an Animation property you can use to see what animation is playing. You also get a TrackEntry when you call SetAnimation or AddAnimation which you can use to customize playback.

jpoag

Instead of directly checking to see if the animation isComplete, you can now Listen for an Event {Start.End,Complete, "Event"}
For reference:
https://github.com/EsotericSoftware/spi ... onState.cs

Here's an example that Spine-Unity uses to capture an event (probably 'footstep') from SpineBoy:
https://github.com/EsotericSoftware/spi ... pineboy.cs

From what I can tell, the 'Complete' event fires at the end of every animation loop if the animation is looping, otherwise an 'End' event is fired. There's also a 'Start' Event, so if you want to latch the state, listen for 'Start' and 'End' and store your boolean. (Or just run your finalizer code in the 'End' event)

Spine now uses multitracking, so you could play more than one animation and the results are blended. The event has the track ID, so if you are playing an animation on Track 0, and a brief 'pose' animation on track 1, track 1 could finish first and fire the 'End' event. So be sure to pay attention to which track is firing which event.

<redundant>
If you still want the 'IsComplete' functionality, you would need to loop through 'sk.state.GetCurrent(i)' where i = {0, max track id} and check for NULL on all possible tracks. I'm not seeing where SpineUnity/C# poses a limit on the number of tracks, but since the programmer is the one playing the tracks, I would assume they are responsible for knowing what the 'max track id' is.
</redundant>

Jekht

Hi Nate,

Thanks for the quick reply. Unfortunately I don't really understand the application of this to track which specific anims are playing and whether they have then finished. I've looked through the reference you posted jpoag, but even on the example project the events only appear to be fired initially, and then doesn't seem to specify anims in use. I hate to ask, but if anyone can post an example snippet, it might help me understand.

I've tried using

public void Event (Spine.AnimationState state, int trackIndex, Spine.Event e) {
      Debug.Log(trackIndex + " " + state.GetCurrent(trackIndex) + ": event " + e + ", " + e.Int);
   }

but nothing appears in the debug log when changing anims. I'm clearly firing pretty blindly here as my coding skills are somewhat lacking, even if I'm trying to learn.

Thanks again for all the responses so far. 🙂

Pharan

The application is: Instead of checking every Update to see which animation is playing and checking if it's done or not, the Complete event lets your script know when the animation completes.
If you want to keep track of the latest animation you played, you can design your script to have a variable that keeps track of either the Spine.Animation or the Spine.TrackEntry.
There are really many ways to get to what you want but the question may be why you need to check the currently playing animation and why you need to check if it's completed.

How familiar are you with C# events or callback functions in general?
Did you subscribe to AnimationState.Event at any point with this event handler method?

It would look something like:
skeletonAnimation.state.Event += this.Event;

jpoag

In C# (and unity I suppose) there are 4 event types that you can subscribe to {Event, Start, End, Complete}, check out lines 45-53 in this file:
https://github.com/EsotericSoftware/spi ... onState.cs

Those 'delegates' are fired when their corresponding event is fired. The SpineBoy example I linked to only subscribes to the 'Event' event, which are "user" events defined in the editor. I think the most recent update of SpineBoy includes a 'footstep' event. [[Eg. you would register a listener for the footstep and play a footstep sound (or spawn a splash particle effect on wet ground)]]

Like what Pharan said with his code snippet above, you would need to register your handler (when setting up the Animation).

public class YourClass{

public void MyStartListener(AnimationState state, int trackIndex){
Debug.Log(trackIndex + " " + state.GetCurrent(trackIndex) + ": start ");
}

public void MyEndListener(AnimationState state, int trackIndex){
Debug.Log(trackIndex + " " + state.GetCurrent(trackIndex) + ": end");
}

public void MyLoopListener(AnimationState state, int trackIndex, int loopCount){
Debug.Log(trackIndex + " " + state.GetCurrent(trackIndex) + ": complete [" + loopCount + " loops]");
}

}

And during setup (or even when firing off the animation) you register for these events:

sk.state.Start += myClass.MyStartListener; // this.MyStartListener
sk.state.End += myClass.MyEndListener; // this.MyEndListener
sk.state.Complete += myClass.MyLoopListener; // this.MyLoopListener

Sometimes it's easier to start with a working example (like the SpineBoy example) and make modifications to that in order to get your head wrapped around how things work. Then, once you've grasped enough knowledge you can transfer to your work code.

Pharan

@jpoag:
I don't think you can do an = assignment on event types outside of the class owning them. It's kind of a safety feature so you can't accidentally unregister/unsubscribe other things that were bound to that event. (Events and plain delegate types can have multiple things registered to it.)

You could do a += or a -= though.

Yours is a thorough example otherwise.

jpoag

Updated, thanks Pharan. Been a while since I've worked in C#.

Jekht

Thanks for all the great tips jpoag and Pharan. Really useful. I was already subscribing to the events, but it seems like a muppet I wasn't subscribing to any specific events.

Since I posted on Monday, we've since looked into this more thoroughly and all the advice here was great. Initially we set up a separate class to track the states when needed, however we have some issues with tracking events on anims that are inside of a queue of other anims. I'll post an update once we get a bit further with it and share what code we have for anyone who wishes to reuse.