iOS forces you to use pretty animations: if you don’t tell it otherwise, it will use “ease-in\/ease-out” curves to make things feel … smoother, less jerky.<\/p>\n
Unity is made for programmers; changes you make to position, size, rotation, etc all happen instantaneously. By default, they won’t even animate, will teleport instead.<\/p>\n
So … moving from “prototype with no animation” to “prototype that won’t hurt people’s eyes, and I can share”, what are some tips and gotchas?<\/p>\n
<\/p>\n
Personal opinion, but … most of us are using it to get cheap bipedal walking animations. Which is fine, but a very small percent of the many use-cases for “animation during a game”.<\/p>\n
So, I’m ignoring it here.<\/p>\n
First off: don’t use Animation.Play( “anim-name” ) – this method is great for prototyping, but it throws-away the timing info you need later<\/p>\n
You can workaround this by putting source-code into every single one of your Animations. Yeah. That works, but .. it’s as safe and maintainable as it sounds. For very complex anims, you’ll have to do that anyway, and it’s a great solution – but for small games it’s overkill.<\/p>\n
[csharp]
\nAnimation anim = myObject.GetComponentInChildren<Animation>();
\nif( anim == null )
\n\tanim = myObject.AddComponent<Animation>();<\/p>\n
AnimationClip clip = anim.GetClip( animationName );
\nanim.clip = clip;
\n[\/csharp]<\/p>\n
Now you know how long the anim takes – it’s “clip.length”<\/p>\n
Design flaw in Unity that we’re stuck with:<\/p>\n
\nAnimations OVERWRITE the object state, instead of MODIFYING it\n<\/p><\/blockquote>\n
i.e. a jumping animation that moves up and down … will reset your character to the origin, jump them up and down, and then teleport your character back to where they were standing. World’s biggest WTF in engine-design.<\/p>\n
Official workaround:<\/p>\n
\n
- Create an empty GameObject.\n
- Parent your object within the new one.\n
- Apply the animation to the original object (the child).\n
- Re-write all your game-input, controllers, AI, etc so that it moves the new, empty, PARENT object.\n<\/ol>\n
Parametric Animation<\/h2>\n
That’s not quite enough.<\/p>\n
In a game, almost all animation is parametric. It is very rare to find something that SHOULDN’T be tweakable via simple config file, NOR influenced by the player’s or AI’s actions.<\/p>\n
Unity doesn’t directly support parametric animation; but they provide API calls and features that make it very easy to add yourself. If you know what they are…<\/p>\n
Example: Jump with variable length<\/h3>\n
First, split your animation into two parts:<\/p>\n
\n
- Parametric part (in this case: how much ground-distance does the jump cover?)\n
\n
- You implement this as an AnimationClip, following Unity’s standard process \/ official docs.<\/li>\n<\/ul>\n
- Static part (in this case: how high they jump, the curve of up and down movement (should look like acceleration: moves quickly at first, slower as it nears the peak, then fast again as it falls))\n
\n
- You implement this in code, using a co-routine. See next paragraph..<\/li>\n<\/ul>\n<\/ol>\n
First, you write it without a co-routine, to test it works:<\/p>\n
[csharp]
\npublic void PlayJump( GameObject myObject, Vector3 jumpDistance )
\n{
\n\tmyObject.transform.position = myObject.transform.position + jumpDistance;
\n}
\n[\/csharp]<\/p>\nWorks, right? Great. But it teleports you from start to finish.<\/p>\n
Then you convert it to a co-routine, causing Unity to smoothly animate it. W00t! Here, you use Unity’s provided method for smoothly moving something over time: Vector3.Lerp() (google it if you don’t know what a “lerp” is, it’s used in almost every game ever written).<\/p>\n
[csharp highlight=”3,6-17″]
\npublic void PlayJump( GameObject myObject, Vector3 jumpDistance )
\n{
\n\tStartCoroutine( CoMove( myObject, myObject.transform.position + jumpDistance );
\n}<\/p>\nprivate IEnumerator CoMove( GameObject myObject, Vector3 finalPosition )
\n{
\n\tfloat elapsedTime = 0, transitionTime = 1f \/* spend 1 seconds moving *\/;
\n\tVector3 savedOriginalPosition = myObject.transform.position;<\/p>\n\twhile( elapsedTime < transitionTime )
\n\t{
\n\tmyObject.transform.position = Vector3.Lerp( savedOriginalPosition, finalPosition, (elapsedTime\/transitionTime) );
\n\telapsedTime += Time.deltaTime;
\n\tyield return new WaitForEndOfFrame();
\n\t}
\n}
\n[\/csharp]<\/p>\nYour jump should now combine a Unity Animation and a parametric \/ controllable distance.<\/p>\n
But … you want the jump distance and jump animation to be synchronized. For that, you need the clip-length we grabbed earlier:<\/p>\n
[csharp highlight=”14, 1=22, 2=24″ language=”17-20,”]<\/p>\n
public void AnimateAndPlayJump( GameObject myObject, Vector3 jumpDistance )
\n{
\n\tAnimation anim = myObject.GetComponentInChildren<Animation>();
\n\tif( anim == null )
\n\t\tanim = myObject.AddComponent<Animation>();<\/p>\n\tAnimationClip clip = anim.GetClip( animationName );
\n\tanim.clip = clip;<\/p>\n\t\/\/ now you know how long the anim takes – it’s "clip.length"<\/p>\n
\tanim.Play(); \/\/ uses the new .clip<\/p>\n
\tPlayJump( myObject, jumpDistance, clip.length );
\n}<\/p>\npublic void PlayJump( GameObject myObject, Vector3 jumpDistance, float duration )
\n{
\n\tStartCoroutine( CoMove( myObject, myObject.transform.position + jumpDistance, duration );
\n}<\/p>\nprivate IEnumerator CoMove( GameObject myObject, Vector3 finalPosition, float duration )
\n{
\n\tfloat elapsedTime = 0;
\n\tVector3 savedOriginalPosition = myObject.transform.position;<\/p>\n\twhile( elapsedTime < duration )
\n\t{
\n\tmyObject.transform.position = Vector3.Lerp( savedOriginalPosition, finalPosition, (elapsedTime\/transitionTime) );
\n\telapsedTime += Time.deltaTime;
\n\tyield return new WaitForEndOfFrame();
\n\t}
\n}
\n[\/csharp]<\/p>\nNow it’s perfect.<\/p>\n
Then you try it in-game, and it’s about 10% slower than you intended. Easy, speed up the ani– oh, wait. Unity’s animation editor DOES NOT ALLOW you to speed up \/ slow down your animationclips. Ouch. Burn!<\/p>\n
Controlling animation speed<\/h2>\n
You can change the speed of an animation itself, but it’s a bit non-obvious how to do it. You unintuitively iterate through the AnimationStates, and set their speed to the INVERSE of the ratio of speeds. Wat? Read the code:<\/p>\n
[csharp highlight=”1,10-17,22″]
\npublic void AnimateAndPlayJump( GameObject myObject, Vector3 jumpDistance, float animationDuration = 0f )
\n{
\n\tAnimation anim = myObject.GetComponentInChildren<Animation>();
\n\tif( anim == null )
\n\t\tanim = myObject.AddComponent<Animation>();<\/p>\n\tAnimationClip clip = anim.GetClip( animationName );
\n\tanim.clip = clip;<\/p>\n\tif( animationDuration > 0f )
\n\t{
\n\t\t\/** Modify the animation-clip, for this animation only *\/
\n\t\tforeach( AnimationState s in anim )
\n\t\t{
\n\t\t\t\t\ts.speed = transitTimeSeconds\/overrideAnimationDuration;
\n\t\t}
\n\t}
\n\t\/\/ now you know how long the anim takes – it’s animationDuration<\/p>\n\tanim.Play(); \/\/ uses the new .clip<\/p>\n
\tPlayJump( myObject, jumpDistance, animationDuration > 0f ? animationDuration : clip.length );
\n}
\n[\/csharp]<\/p>\nVery nice. Fully controllable animations, integrated with gameplay. Aw, yiss!<\/p>\n
Editable curves for your Parametric animations<\/h2>\n
There’s a problem with the above: you make a beautiful jump, which arcs nicely through space, using Unity’s Curves in the animation window, but … the distance itself is constantly increasing. You can’t have the character squat, get ready, then jump – they will skid along the ground while squatting!<\/p>\n
There are many obvious code solutions; they’re mostly wrong.<\/p>\n
Instead, there’s a 1-line change + new variable (of type AnimationCurve). IF you do it this way, Unity gives you a powerful graphical editor for the PARAMETRIC part of your animation – IMHO it’s easier to use than the Animation window, which is a little tragic, but useful.<\/p>\n
[csharp highlight=”1,6-9,13″]
\nprivate IEnumerator CoMove( GameObject myObject, Vector3 finalPosition, float duration, AnimationCurve timingCurve = null )
\n{
\n\tfloat elapsedTime = 0;
\n\tVector3 savedOriginalPosition = myObject.transform.position;<\/p>\n\tif( timingCurve == null )
\n\t{
\n\t\ttimingCurve = AnimationCurve.Linear( 0, 0, 1f, 1f ); \/\/ identical to a Lerp
\n\t}<\/p>\n\twhile( elapsedTime < duration )
\n\t{
\n\tmyObject.transform.position = Vector3.Lerp( savedOriginalPosition, finalPosition, timingCurve.Evaluate( (elapsedTime\/transitionTime) ) );
\n\telapsedTime += Time.deltaTime;
\n\tyield return new WaitForEndOfFrame();
\n\t}
\n}
\n[\/csharp]<\/p>\nThis. Is. Awesome.<\/p>\n
Animation and Physics<\/h2>\n