Help in modifying the BoneFollower script

AHAKuo

Hello there! I have a simple mechanic I'm trying to achieve. In my game, there are butterflies that follow the characters wherever they go. And I want to achieve the "following feeling" rather than having them fixed over the characters.

I could simply create a MoveTowards script and have the transfrom follow the character, but I want the butterfly to follow the bone itself. Because in some animations, the character can move away from the center.

TL;DR So, I've been trying to modify the BoneFollower script into making it use Vector2.MoveTowards. Rather than having it fixed over the bone.

How can I do that?

Here's what I attempted:

public void LateUpdate () {
   if (!valid) {
      Initialize();
      return;
   }

   #if UNITY_EDITOR
   if (!Application.isPlaying)
      skeletonTransformIsParent = Transform.ReferenceEquals(skeletonTransform, transform.parent);
   #endif

   if (bone == null) {
      if (string.IsNullOrEmpty(boneName)) return;
      bone = skeletonRenderer.skeleton.FindBone(boneName);
      if (!SetBone(boneName)) return;
   }

   Transform thisTransform = this.transform;
   if (skeletonTransformIsParent) {
      // Recommended setup: Use local transform properties if Spine GameObject is the immediate parent
      thisTransform.localPosition = new Vector3(followXYPosition ? bone.worldX : thisTransform.localPosition.x,
                                    followXYPosition ? bone.worldY : thisTransform.localPosition.y,
                                    followZPosition ? 0f : thisTransform.localPosition.z);
      if (followBoneRotation) {
         float halfRotation = Mathf.Atan2(bone.c, bone.a) * 0.5f;
         if (followLocalScale && bone.scaleX < 0) // Negate rotation from negative scaleX. Don't use negative determinant. local scaleY doesn't factor into used rotation.
            halfRotation += Mathf.PI * 0.5f;

     var q = default(Quaternion);
     q.z = Mathf.Sin(halfRotation);
     q.w = Mathf.Cos(halfRotation);
     thisTransform.localRotation = q;
  }
   } else {
      // For special cases: Use transform world properties if transform relationship is complicated
      Vector3 targetWorldPosition = skeletonTransform.TransformPoint(new Vector3(bone.worldX, bone.worldY, 0f));
      if (!followZPosition) targetWorldPosition.z = thisTransform.position.z;
      if (!followXYPosition) {
         targetWorldPosition.x = thisTransform.position.x;
         targetWorldPosition.y = thisTransform.position.y;
      }

  float boneWorldRotation = bone.WorldRotationX;

  Transform transformParent = thisTransform.parent;
  if (transformParent != null) {
     Matrix4x4 m = transformParent.localToWorldMatrix;
     if (m.m00 * m.m11 - m.m01 * m.m10 < 0) // Determinant2D is negative
        boneWorldRotation = -boneWorldRotation;
  }

  if (followBoneRotation) {
     Vector3 worldRotation = skeletonTransform.rotation.eulerAngles;
     if (followLocalScale && bone.scaleX < 0) boneWorldRotation += 180f;
     thisTransform.SetPositionAndRotation(targetWorldPosition, Quaternion.Euler(worldRotation.x, worldRotation.y, worldRotation.z + boneWorldRotation));
  } else {
     thisTransform.position = Vector2.MoveTowards(thisTransform.position, new Vector2(targetWorldPosition.x, targetWorldPosition.y), 7f )    ;
  }
   }

   Vector3 localScale = followLocalScale ? new Vector3(bone.scaleX, bone.scaleY, 1f) : new Vector3(1f, 1f, 1f);
   if (followSkeletonFlip) localScale.y *= Mathf.Sign(bone.skeleton.ScaleX * bone.skeleton.ScaleY);
   thisTransform.localScale = localScale;
}

It still doesn't work. On the parameters of the script, I only have "FollowXYPosition" set to true.

This is the line I edited in the script:

   [b]  thisTransform.position = Vector2.MoveTowards(thisTransform.position, new Vector2(targetWorldPosition.x, targetWorldPosition.y), 7f )[/b]

Can you please help? Thank you

Jamez0r

I had a very similar need for "wisps" that follow our character around. Here is what I suggest:

Instead of modifying the BoneFollower, use separate gameobjects & Unity's gameobject hierarchy to achieve what you want.

[ButterflyPrefab] The prefab gameobject. Could have your 'butterfly controller' script on it, or anything else.
[BoneFollower (locked to bone)] This would have the BoneFollower component, and would be locked to follow the bone. It doesn't have any graphics/visuals. It just provides a position for your other gameobjects.
[MoveTowards the BoneFollower] This gameobject would have a simple script that makes it follow the "BoneFollower (locked to bone)" gameobject, using Damping or however you want the MoveTowards to work.
[Add Up/Down Floating Motion] This would be an optional gameobject that you could add a script that added some up/down floating motion. Use "local position" if you do this.
[ButterflyGraphic] This would have the SkeletonAnimation or whatever graphic you're using for the butterfly.

(Note: As shown in the screenshot, the [MoveTowards] gameobject should not be a child of the [BoneFollower] gameobject, so that it doesn't inherit the [BoneFollower] position.)

(Note 2: With this configuration you would not be moving the ButterflyPrefab gameobject itself. The [BoneFollower] and [MoveTowards] gameobjects would be getting moved/positioned. So the ButterflyPrefab would stay in place wherever you spawned it.)

This setup might seem overly complicated, but it lets you handle the following motion step-by-step rather than trying to do it all in a single script. It will also make debugging the movement MUCH easier, because you can look at each individual gameobject and make sure that it is moving correctly. So if the movement doesn't look right, you can start by selecting the [BoneFollower] - is it locked on to the bone correctly? If so, select the [MoveTowards the BoneFollower], is it following correct? Is the damping too fast or too slow? Etc.

I spent probably like 6 hours making our "wisps" follow the character around and move naturally, and not look like they were 'locked on' to the character. It seems like something simple, but making natural 'random' movement through code is really hard haha. One thing I added to our wisp movement was having the wisps dart around to random places around the player, but I didn't include that in the example since it might have made it more confusing.

Let me know if it works for you, or if you have any more questions 😃

Harald

Thanks very much for the detailled answer Jamez0r! 8)

@AHAKuo Please note that you are not using the latest spine-unity unitypackage, as there have been some improvements on the BoneFollower and BoneFollowerGraphic scripts. While you might not need those improvements, but should definitely update before modifying the code.

Anyway, the solution the Jamez0r described is highly recommended as it's the better solution. This solution is also much more generic and flexible, allowing you to switch follow-targets from Spine skeleton bones to any other Transform. One of the benefits of clean design 😉.

While I'm pretty sure Jamez0r is using it already: Unity's AnimationCurve type can be very helpful to design controlled but random-looking behaviour, where pure math would make it seem smooth but mechanical (or is too much effort to write down). You could e.g. create a public AnimationCurve followerAcceleration;, draw a random looking curve and then evaluate the (endlessly repeating) curve over time to get a more organically looking speed stutter effect.