The Animation of Nevermore, Part II
Hey there, cool folks! Today we’re going to make the second and last (for now) post on animation for our game. As we mentioned previously, we’ll be discussing our experiences, problems, solutions and tools we explored in the animation process for Nevermore.
The previous post (That you can read right here) is filled with experiences, tools and, most of all, problems that we bumped into during the beginning of the process. Today, however, we’ll be talking solutions! Continuing our little recap, our last experiments before arriving at a proper solution were with Spriter Pro, which unfortunately did leave a lot to be desired in many very important aspects for this project.
So, without further ado, let’s present our solution! It has a name, and it’s called Anima2D.
Anima2D is a 2D animation plugin for Unity, developed by the very nice folks over at Mandarina Games, and it’s being sold on Unity’s Asset Store for a very accessible price. It has several animation features that are quite similar to some available on Spriter Pro, such as the creation of bone hierarchies and an IK system (and we’re talking about one that really does work, here!). It also has some other really useful features such as Sprite Meshes (that we will be talking about later on).
Besides all that, it has a huge advantage for us that proved vital in helping us successfully create animations for our game. Being a Unity plugin, it uses Unity’s own animation interface, which we’re already largely used to due to prior experiences on other projects that used sprite animations with no bones. In other words, the animation is created directly in-engine, without need for external softwares.
Another huge advantage that the plugin provides us is the fact that we don’t have to worry about the in-betweens for the animations that couldn’t be properly imported into Unity when working with an external software. The in-betweens are treated directly with Unity’s animation curves, eliminating one of the biggest issued we had while using Spriter Pro.
With Anima2D, the process of creating a character’s skeleton also happens in a very intuitive manner. You just need to assemble the character as you normally would in your scene, adjusting the structure of the sprites and rendering order for each part, followed by the addition of their respective bones. The parenting between bones and sprites is made directly through Unity’s own object hierarchy, you only need to drag a child object into its intended parent.
After creating the skeleton and defining hierarchies, we have a 2D character ready to be animated. However, as we mentioned previously, the plugin also features a very powerful tool for creating more complex and smooth animations: The Sprite Mesh.
Unity’s standard method for handling sprites is by generating rectangular polygonal planes containing images, with the possibility of turning them into multi-vertex meshes in order to reduce overdraw. Anima2D’s Sprite Mesh system not only does allow for the creation of more optimized meshes with reduced polygon counts, but it also allows them to be deformed in order to generate distortion animations.
In other words, it’s possible to add a bone chain to this sprite and configure the influence of said bones on each vertex of a mesh, allowing us to generate distortions in said image.
Where were they used?
For the time being, we have three characters with animations implemented in our game. One of our main characters, and two enemies. We used this feature on all of them.
On this character, we used this feature to create hair animations, generating smoother hair movement, allowing for a richer follow through effect.
On our first enemy, we used a sprite mesh for the appendage on its head, also allowing for a better follow through effect.
This enemy from Little Red Riding Hood’s tale was completely created and animated using Sprite Meshes. The main body and head combined, along with each of the character’s limbs and tail were used as parts, all distorted using bones. Due to the complexity of the character’s shapes and articulations, keeping them from detaching themselves during the animation process would’ve been a significantly bigger challenge with regular sliced animations.
Well, that’s it, folks! That wraps up this first series of animation posts. We hope you guys liked it, and hopefully this information will provide useful insight to other developers trying to implement more complex 2D animations for games made with Unity.