Help with Spine to Unity and controller script

Antemation

Hi there.

Ive been testing Spine a while now and love how it works inside Spine. Unsure on how it works in Unity. We made some tests and demos in cocos. But that was our coder who implemented it.
Im the AD/Artist with poor scripting skills and Im pushing for us to use Spine together with unity in our next 2 games. But I need to be able to back it up by showing the rest of our crew that it actually works like we want.

I just imported a character into unity. Pretty straight forward. But now I want to test it a bit more so I want to connect my character and its walk, run, jump and some other standard animations, to a controller so I can run around using the keyboard and see how it looks "live".

Does anyone have a good tutorial showing how to control animations from spine in unity? Or even better, if someone have the code for it and would be willing to paste it here and give a short explanation on how to implement it.

PS. might be the wrong place to post this so feel free to redirect me.

Søren

Pharan is the resident Unity guru when it comes to Spine, so it's likely he can give you some tips. But here's a good thread on the same subject that might point you in the same direction
viewtopic.php?f=11&t=1950&p=10442&hilit=unity+controller#p10442
I hope it helps!

Antemation

Thanks. It helped somewhat🙂
So, I used the 2d controller in the linked thread. I now got it getting my animations like run, idle and jump. But the example you refered to uses the animator. That would be great but the animator cant use the spine animations right? So I have put the setanimations inside the FixedUpdate. Even me, with no code skills realize that this isnt the best idea. While holding the key down it restarts the animation each loop in the Fixedupdate.

So jumping works, This only checks for a keydown and then plays the jump animation as long as you are moving in y direction(If I understood the script correctly)
but moving right and left only shows the first frame.

Does anybody have a simple sollution to check if the animation already is playing and then NOT set it again until another animation is played? Or if that is a stupdi sollution, maybe someone have a better sollution?

Here is the update and fixed update part of the code I pirate coded: (By piratecoding I mean, I have basically no coding skills but I uses someone elses code and manipulate it until it works at least for testing some stuff out. hehe)

void Update()
   {
      // a minor bit of trickery here. FixedUpdate sets _up to false so to ensure we never miss any jump presses we leave _up
      // set to true if it was true the previous frame
      _up = _up || Input.GetKeyDown( KeyCode.UpArrow );
      _right = Input.GetKey( KeyCode.RightArrow );
      _left = Input.GetKey( KeyCode.LeftArrow );
   }


   void FixedUpdate()
   {
      // grab our current _velocity to use as a base for all calculations
      _velocity = _controller.velocity;
      

  if( _controller.isGrounded )
     _velocity.y = 0;
  
  if( _right )
  {
     normalizedHorizontalSpeed = 1;
     if( transform.localScale.x < 0f )
        transform.localScale = new Vector3( -transform.localScale.x, transform.localScale.y, transform.localScale.z );


     if( _controller.isGrounded )
        skeletonAnimation.state.SetAnimation(0, "run", true);
  }
  else if( _left )
  {
     normalizedHorizontalSpeed = -1;
     if( transform.localScale.x > 0f )
        transform.localScale = new Vector3( -transform.localScale.x, transform.localScale.y, transform.localScale.z );
     
     if( _controller.isGrounded )
        skeletonAnimation.state.SetAnimation(0, "run", true);
  }
  else
  {
     normalizedHorizontalSpeed = 0;
     
     if( _controller.isGrounded )
        skeletonAnimation.state.AddAnimation(0, "idle", true, 0);
  }
  
  
  // we can only jump whilst grounded
  if( _controller.isGrounded && _up )
  {
     _velocity.y = Mathf.Sqrt( 2f * jumpHeight * -gravity );
     skeletonAnimation.state.SetAnimation(0, "jump", true);
  }
  
  
  // apply horizontal speed smoothing it
  var smoothedMovementFactor = _controller.isGrounded ? groundDamping : inAirDamping; // how fast do we change direction?
  _velocity.x = Mathf.Lerp( _velocity.x, normalizedHorizontalSpeed * runSpeed, Time.fixedDeltaTime * smoothedMovementFactor );
  
  // apply gravity before moving
  _velocity.y += gravity * Time.fixedDeltaTime;

  _controller.move( _velocity * Time.fixedDeltaTime );

  // reset input
  _up = false;

   }

Pharan

Hey. Sorry, I didn't catch this.

Can you post the whole class and not just these methods?
Does your character only run, jump and do idle?

Maybe I can help you out.

Antemation

Below is the whole class. Another class called charactercontroller2d is handeling all the raycastiting and collision calculations.
So I kind of solved the problem by setting the flag '_playanim'. So when moving the character a check for _playanim is made before doing a new SetAnimation. But its not a good sollution because I use 'normalizedHorizontalSpeed = 0;' to set it to false again. This means I get the same problem on the idle animation which is played when speed is 0. I solved that by using AddAnimation but then when you stop, any animation that was playing needs to end by itself before the idle can start.

Now it acctually works good enough for me to test some graphics and animations but it would be great to get some pointers on how you ACTUALLY should do this. there are probably many like me, who are good at the art side but suck on the code side, that would benifit if they had som easy code they could use to test things out. So, Pharan, I really appreciate that you have taken the time trying to help me out, even though I basically dont know black from white when it comes to coding.

using UnityEngine;
using System.Collections;
using Spine;
using System;


public class PhysicsPlayerTester : MonoBehaviour
{
   // movement config
   public float gravity = -25f;
   public float runSpeed = 8f;
   public float groundDamping = 20f; // how fast do we change direction? higher means faster
   public float inAirDamping = 5f;
   public float jumpHeight = 3f;

   [HideInInspector]
   private float normalizedHorizontalSpeed = 0;

   private CharacterController2D _controller;
   private RaycastHit2D _lastControllerColliderHit;
   private Vector3 _velocity;
   SkeletonAnimation skeletonAnimation;
   private bool _playanim;


   // input
   private bool _right;
   private bool _left;
   private bool _up;
   private bool activeanim;




   void Awake()
   {
      skeletonAnimation = GetComponent<SkeletonAnimation>();
      skeletonAnimation.skeleton.FlipX = true;
      _controller = GetComponent<CharacterController2D>();

  // listen to some events for illustration purposes
  _controller.onControllerCollidedEvent += onControllerCollider;
  _controller.onTriggerEnterEvent += onTriggerEnterEvent;
  _controller.onTriggerExitEvent += onTriggerExitEvent;
   }


   #region Event Listeners

   void onControllerCollider( RaycastHit2D hit )
   {
      // logs any collider hits if uncommented. it gets noisy so it is commented out for the demo
      //Debug.Log( "flags: " + _controller.collisionState + ", hit.normal: " + hit.normal );
   }


   void onTriggerEnterEvent( Collider2D col )
   {
      Debug.Log( "onTriggerEnterEvent: " + col.gameObject.name );
   }


   void onTriggerExitEvent( Collider2D col )
   {
      Debug.Log( "onTriggerExitEvent: " + col.gameObject.name );
   }

   #endregion


   // the Update loop only gathers input. Actual movement is handled in FixedUpdate because we are using the Physics system for movement
   void Update()
   {
      // a minor bit of trickery here. FixedUpdate sets _up to false so to ensure we never miss any jump presses we leave _up
      // set to true if it was true the previous frame
      _up = _up || Input.GetKeyDown( KeyCode.UpArrow );
      _right = Input.GetKey( KeyCode.RightArrow );
      _left = Input.GetKey( KeyCode.LeftArrow );
   }


   void FixedUpdate()
   {
      // grab our current _velocity to use as a base for all calculations
      _velocity = _controller.velocity;
      

  if( _controller.isGrounded )
     _velocity.y = 0;
  
  if( _right )
  {
     normalizedHorizontalSpeed = 1;
     if( transform.localScale.x < 0f )
        transform.localScale = new Vector3( -transform.localScale.x, transform.localScale.y, transform.localScale.z );

     if ( !_playanim )
        if( _controller.isGrounded )
        skeletonAnimation.state.SetAnimation(0, "run", true);
        _playanim = true;
  }
  else if( _left )
  {
     normalizedHorizontalSpeed = -1;
     if( transform.localScale.x > 0f )
        transform.localScale = new Vector3( -transform.localScale.x, transform.localScale.y, transform.localScale.z );

     if ( !_playanim )
        if( _controller.isGrounded )
           skeletonAnimation.state.SetAnimation(0, "run", true);
     _playanim = true;

  }
  else
  {
     normalizedHorizontalSpeed = 0;
     
     if( _controller.isGrounded )
        skeletonAnimation.state.AddAnimation(0, "idle", true, 0);
        _playanim = false;
  }
  
  
  // we can only jump whilst grounded
  if( _controller.isGrounded && _up )
  {
     _velocity.y = Mathf.Sqrt( 2f * jumpHeight * -gravity );
     skeletonAnimation.state.SetAnimation(0, "jump", true);
  }
  
  
  // apply horizontal speed smoothing it
  var smoothedMovementFactor = _controller.isGrounded ? groundDamping : inAirDamping; // how fast do we change direction?
  _velocity.x = Mathf.Lerp( _velocity.x, normalizedHorizontalSpeed * runSpeed, Time.fixedDeltaTime * smoothedMovementFactor );
  
  // apply gravity before moving
  _velocity.y += gravity * Time.fixedDeltaTime;

  _controller.move( _velocity * Time.fixedDeltaTime );

  // reset input
  _up = false;

   }

}

Pharan

try this:

using UnityEngine;
using System.Collections;

// This implementation hints at an MVC pattern but stuffs all sorts of logic dirtily into one file.
// The rigidbody logic is also cheated and doesn't represent how you would code a platformer character's actual body physics logic.

public class SampleSpineCode : MonoBehaviour {
   // These default values are based on a 1:1 pixel to world unit ratio.
   // To make these work with 100:1 ratio, divide these values by 100.
   // INSPECTOR ASSIGNED VALUES
   public float runSpeed = 1200f;
   public float gravity = 5000f;
   public float groundLevel = 0f;
   public float jumpStrength = 1800f;

   // Cached references
   Spine.AnimationState state;
   Spine.Skeleton skeleton;
   Transform tt;

   // Fake rigidbody
   Vector3 v;

   // Character state
   bool isRunning;
   bool isFalling;
   float intendedDirection;

   // Dirty flags for view logic
   bool modelChanged;
   bool directionChanged;

   #region MonoBehaviour Lifecycle
   void Awake() {
      tt = transform;
   }

   void Start() {
      var skeletonAnimation = GetComponent<SkeletonAnimation>();

  // Things get initialized and instantiated in Awake, so make sure you access things like .state or .skeleton in Start
  state = skeletonAnimation.state;
  skeleton = skeletonAnimation.skeleton;
   }

   void Update() {
      ParseInput();
      UpdateAnimation();
   }
   #endregion

   #region INPUT
   void ParseInput() {
      float horizontalAxis = Input.GetAxis("Horizontal");
      bool pressedJump = Input.GetButtonDown("Jump");

  if(!isFalling) {      
     if(pressedJump) {
        Jump();
     } 
  }

  TryMoveHorizontal (horizontalAxis);
   }
   #endregion

   #region CHARACTER ACTIONS
   void Jump() {
      v.y = jumpStrength;
      isFalling = true;
      modelChanged = true;
   }

   void TryMoveHorizontal(float direction) {
      if(intendedDirection != direction && direction != 0f) {
         directionChanged = true;
         intendedDirection = direction;
      }

  bool willRun = (direction != 0f);

  if(!isFalling) {            // If on the ground
     if(willRun != isRunning) {   // Started or stopped running
         modelChanged = true;
     }
  }

  isRunning = willRun;
  v.x = runSpeed * direction;
   }
   #endregion

   #region VIEW LOGIC
   void UpdateAnimation() {
      if(modelChanged) {
         if(isFalling) {
            state.SetAnimation(0, "jump", false);
         } else {
            if(isRunning) {
               state.SetAnimation(0, "run", true);
            } else {
               state.SetAnimation(0, "idle", true);
            }
         }

     modelChanged = false;
  }

  if(directionChanged) {
     skeleton.flipX = intendedDirection < 0f;
     directionChanged = false;
  }
   }
   #endregion

   #region FAKE PHYSICS
   void FixedUpdate() {
      float fdt = Time.fixedDeltaTime;
      Vector3 currentPosition = tt.localPosition;

  // Apply gravity.
  if(isFalling)
     v.y -= gravity * fdt;

  // Apply velocity.
  currentPosition += v * fdt;

  // Check if landed on the fake ground.
  if(currentPosition.y < groundLevel) {
     currentPosition.y = groundLevel;
     v.y = 0f;
     isFalling = false;
     modelChanged = true;
  }

  // Apply new position.
  tt.localPosition = currentPosition;

   }
   #endregion
   

}

Save this code as a C# script named "SampleSpineCode.cs" and attach it to your GameObject that has the SkeletonAnimation. No other extra components needed. No controller. No rigidbody. No colliders. But this is just for the example.

Note that this is still NOT how you should do it in an actual game. Programming for a game inevitably involves coming up with architecture, meaning deciding which things should do what.
And one thing you usually don't want to do is have one script do everything (like this script does here). Sometimes, concerns can't be compartmentalized as cleanly as you want but the more you're able to, the more complex features you'll also be able to handle without going nuts trying to fix bugs or even just trying to get things to work.

Coding a platformer character can also get rather involved depending on what you want it to feature. It deserves a certain amount of attention that you'd normally deal with it separately from (but with an awareness of) the animation system. This is especially if you want things like controllable gravity, passable platforms, ground and air friction, the ability to receive external forces.

Unity's official tutorials don't teach this in depth. They'll tell you to use their pre-built stuff which works well with their other pre-built stuff, which is okay for some things and to get things running quickly, but not when you want something specific. Otherwise though, their beginner and intermediate scripting tutorials seem pretty good if you want to learn how to program, maybe not how to decide architecture stuff. It just hints that you'd want to.

Antemation

Thanks for that script Pharan!
And you are right of course. I spent last night watching the tutorials. Even though Im not going to code anything heavy it is very good to get a better understanding of the basics.

Tried out your script. Its really good for testing pure movements so I will definatly use it for that. But I also want it to be able to get around in a level while producing graphics for platforms, BGs, lights and that sort of thing so the physicspart is a bit important. But maybe I can implement the physics and the collision script with your script?

I kind of solved the problem I was having with the old script. Not a good sollution but it works for now at least. I make 2 key checks. One with 'Input.GetKeyDown( KeyCode.RightArrow );' that starts the animation and one with '_right = Input.GetKey( KeyCode.RightArrow );' that controls the movement. this way Im not activating the animation each loop but still keep the movement.

Its kind of buggy. Ones in a while it misses to play the animation.

In any case, your script was very useful and I will study it more later today. I hope other code-impaired graphics guys find it useful too🙂