Rotation causes stuttery behavoir

[Slurgelman]

Hello,

My playable character seems to stutter every time it rotates back to normal.

Here’s a video that shows the issue(the playtest is at 0:25):

Stutter when rotating

Here’s the main part of my code that I think causes the issue:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerControllerDebug : MonoBehaviour
{
    private bool isSpacePressed = false;
    private bool isRightPressed = false;
    private bool isLeftPressed = false;
    private bool isUpPressed = false;
    private bool grounded = false;
    private bool canUsePotShot = true;
    private bool jumpsAvailable = true;
    private bool rotateToNormalRotation;
    private bool potShotRecoiling;
    private bool usePotShot;
    private bool freezePosition;
    private bool freezePositionNeedsAdjusting;
    private int potShooterOffset = 90;
    private int maxJumps = 1;
    private int jumpCount = 0;
    private float maxChargeTime = 0.6f;
    private float chargeTime = 0;
    public float potShotSpeed;
    private float potShotRecoil = 0.2f;
    private float normalGravityScale;
    public float jumpHeight = 5;
    private Vector2 recoilVelocity;
    private Animator animator;
    private Vector3 difference;
    private Vector3 emptyVector3 = Vector3.zero;
    private SpriteRenderer potSpriteRenderer;
    public GameObject potShotProjectile;
    private Rigidbody2D rb;

    private void Start()
    {
        animator = GetComponent<Animator>();
        potSpriteRenderer = transform.Find("Pot").gameObject.GetComponent<SpriteRenderer>();
        rb = GetComponent<Rigidbody2D>();
        normalGravityScale = rb.gravityScale;
    }
    private void Update()
    {
        Jump();
        PotShooter();
        if (rotateToNormalRotation)
        {
            transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.Euler(0f, 0f, 0f), 5f * Time.deltaTime);
            //transform.rotation = Quaternion.Euler(0f, 0f, 0f);     debug to let it rotate back to normal instantly
            if (transform.rotation == Quaternion.Euler(0f, 0f, 0f))
            {
                rotateToNormalRotation = false; ;
            }
        }
    }
    private void Jump()
    {
        if (Input.GetKeyDown("space") && jumpsAvailable)
        {
            isSpacePressed = true;
            animator.Play("Wilbur_Jump", -1, 0.0f);
            if (grounded == false)
            {
                jumpCount++;
            }
        }
        isRightPressed = Input.GetKey("d");
        isLeftPressed = Input.GetKey("a");
        isUpPressed = Input.GetKey("w");
    }
    private void PotShooter()
    {
        if (Input.GetMouseButton(0) && grounded == false && canUsePotShot)
        {
            animator.Play("Wilbur_Pot_Shot_In");
            freezePosition = true;
            difference = Camera.main.ScreenToWorldPoint(Input.mousePosition) - transform.position;
            float rotZ = Mathf.Atan2(difference.y, difference.x) * Mathf.Rad2Deg;
            transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.Euler(0f, 0f, rotZ + potShooterOffset), 4f * Time.deltaTime);
            potSpriteRenderer.color = new Color(1.0f, 0.63f, 0.63f);
            chargeTime += Time.deltaTime;
            potShotSpeed = chargeTime * 5;
            if (chargeTime > maxChargeTime)
            {
                usePotShot = true;
            }
        }
        if ((Input.GetMouseButtonUp(0) || usePotShot) && grounded == false && canUsePotShot)
        {
            animator.Play("Wilbur_Pot_Shot_Out");
            Instantiate(potShotProjectile, transform.Find("Pot").position, transform.Find("Pot").rotation);
            float angle = Mathf.Atan2(difference.y, difference.x);
            recoilVelocity = new Vector2(-Mathf.Cos(angle) * Mathf.Rad2Deg * potShotRecoil, -Mathf.Sin(angle) * Mathf.Rad2Deg * potShotRecoil);
            potShotRecoiling = true;
            canUsePotShot = false;
            freezePosition = false;
            freezePositionNeedsAdjusting = true;
            rotateToNormalRotation = true;
            potSpriteRenderer.color = Color.white;
            usePotShot = false;
            chargeTime = 0;
        }
    }
    private void FixedUpdate()
    {
        if (isSpacePressed)
        {
            JumpDicider();
            isSpacePressed = false;
        }

        if (freezePosition)
        {
            rb.velocity = emptyVector3;
            rb.gravityScale = 0;
        }
        else if (freezePosition == false && freezePositionNeedsAdjusting)
        {
            rb.gravityScale = normalGravityScale;
            freezePositionNeedsAdjusting = false;
        }

        if (potShotRecoiling)
        {
            rb.velocity = recoilVelocity;
            potShotRecoiling = false;
        }

        if (jumpCount == maxJumps)
        {
            jumpsAvailable = false;
        }
        else
        {
            jumpsAvailable = true;
        }
    }
    private void JumpDicider()
    {
        if (isRightPressed == false && isLeftPressed == false && isUpPressed == false)
        {
            rb.velocity = new Vector2(rb.velocity.x, jumpHeight);
        }
        else if (isRightPressed && isLeftPressed == false && isUpPressed == false)
        {
            rb.velocity = new Vector2(jumpHeight, jumpHeight / 1.8f);
        }
        else if (isRightPressed == false && isLeftPressed && isUpPressed == false)
        {
            rb.velocity = new Vector2(-jumpHeight, jumpHeight / 1.8f);
        }
        else if (isRightPressed == false && isLeftPressed == false && isUpPressed)
        {
            rb.velocity = new Vector2(rb.velocity.x, (jumpHeight + (jumpHeight / 3)));
        }
        else if (isRightPressed && isLeftPressed && isUpPressed)
        {
            rb.velocity = new Vector2(rb.velocity.x, (jumpHeight + (jumpHeight / 3)));
        }
        else if (isRightPressed && isLeftPressed == false && isUpPressed)
        {
            rb.velocity = new Vector2(jumpHeight / 1.8f, (jumpHeight + (jumpHeight / 3) / 1.8f));
        }
        else if (isRightPressed == false && isLeftPressed && isUpPressed)
        {
            rb.velocity = new Vector2(-jumpHeight / 1.8f, (jumpHeight + (jumpHeight / 3) / 1.8f));
        }
    }
    private void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.gameObject.CompareTag("World"))
        {
            grounded = true;
            canUsePotShot = true;
            jumpCount = 0;
        }
    }
    private void OnTriggerExit2D(Collider2D collision)
    {
        if (collision.gameObject.CompareTag("World"))
        {
            grounded = false;
        }
    }
}

The weird thing is that it only happens when it tries to rotate back to normal and not when it is rotating towards my mouse. I’ve tried to rotate it back to normal instantly(line 50 on the shorter version, line 86 on the longer one) and it is not having any issues if I do that, but I’m really trying to make the transition look smooth.

There are a couple of variables that are used in other scripts, so not every variable in this script is used in this script.

Does anyone know what’s causing the stutter and/or how to fix it? I would really appreciate any kind of help.

I know the script is pretty long to be asking a question about it, but I am not experienced enough with coding to know what people need to be able to answer my question. Also I am sorry if I made any grammer/spelling errors or if anything isn’t proper, English is not my main language.

Here’s the full script just in case it’s necessary:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    private bool isSpacePressed = false;
    private bool isRightPressed = false;
    private bool isLeftPressed = false;
    private bool isUpPressed = false;
    private bool isDownPressed = false;
    private bool canFastfall = false;
    private bool headbutting = false;
    private bool directionLock = false;
    private bool canUsePotShot = true;
    private bool usePotShot = false;
    private bool jumpsAvailable = true;
    private bool grounded = false;
    private bool facingLeft = false;
    private bool facingRight = true;
    private bool rotateToNormalRotation = false;
    private bool shouldAnimationReset = true;
    private bool potShotRecoiling = false;
    private bool freezePosition;
    private bool freezePositionNeedsAdjusting;
    private int jumpCount = 0;
    private int maxJumps = 2;
    public int health = 3;
    public float jumpHeight = 5;
    private float fastfallSpeed = 2f;
    private float knockback;
    private float stunTime;
    private float potShooterOffset = 90;
    private float maxChargeTime = 0.6f;
    private float chargeTime = 0;
    private float potShotRecoil = 0.2f;
    public float potShotSpeed;
    private float normalGravityScale;
    private Vector2 recoilVelocity;
    private Vector3 emptyVector3 = Vector3.zero;
    private Vector3 difference;
    private Rigidbody2D rb;
    private Animator animator;
    private PlayerController playerController;
    private GameObject[] bodyparts;
    private SpriteRenderer[] srBodyparts;
    private BoxCollider2D boxCollider2D;
    private EffectsScript effectsScript;
    public GameObject potShotProjectile;
    private SpriteRenderer potSpriteRenderer;

    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        animator = GetComponent<Animator>();
        playerController = GetComponent<PlayerController>();
        effectsScript = GameObject.FindGameObjectWithTag("Effects").GetComponent<EffectsScript>();
        bodyparts = GameObject.FindGameObjectsWithTag("Player Bodypart");
        potSpriteRenderer = transform.Find("Pot").gameObject.GetComponent<SpriteRenderer>();
        srBodyparts = new SpriteRenderer[bodyparts.Length];
        for(int i = 0; i < bodyparts.Length; i++)
        {
            srBodyparts[i] = bodyparts[i].GetComponent<SpriteRenderer>();
        }
        rb.interpolation = RigidbodyInterpolation2D.Interpolate;
        maxJumps--;
        boxCollider2D = gameObject.GetComponent<BoxCollider2D>();
        normalGravityScale = rb.gravityScale;
        //Application.targetFrameRate = 60;
    }

    private void Update()
    {
        Jump();
        PotShooter();
        Headbutt();
        Fastfall();
        DirectionAdjuster();
        if(animator.GetCurrentAnimatorStateInfo(0).IsName("Wilbur_Idle") == false && shouldAnimationReset)
        {
            StartCoroutine(AnimationResetter());
        }
        if (rotateToNormalRotation)
        {
            transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.Euler(0f, 0f, 0f), 5f * Time.deltaTime);
            //transform.rotation = Quaternion.Euler(0f, 0f, 0f);
            if(transform.rotation == Quaternion.Euler(0f, 0f, 0f))
            {
                rotateToNormalRotation = false; ;
            }
        }
    }
    private void Jump()
    {
        if (Input.GetKeyDown("space") && jumpsAvailable)
        {
            isSpacePressed = true;
            animator.Play("Wilbur_Jump", -1, 0.0f);
            if (grounded == false)
            {
                jumpCount++;
            }
        }
        isRightPressed = Input.GetKey("d");
        isLeftPressed = Input.GetKey("a");
        isUpPressed = Input.GetKey("w");
    }
    private void PotShooter()
    {
        if (Input.GetMouseButton(0) && grounded == false && canUsePotShot)
        {
            animator.Play("Wilbur_Pot_Shot_In");
            freezePosition = true;
            difference = Camera.main.ScreenToWorldPoint(Input.mousePosition) - transform.position;
            float rotZ = Mathf.Atan2(difference.y, difference.x) * Mathf.Rad2Deg;
            transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.Euler(0f, 0f, rotZ + potShooterOffset), 4f * Time.deltaTime);
            potSpriteRenderer.color = new Color(1.0f, 0.63f, 0.63f);
            chargeTime += Time.deltaTime;
            potShotSpeed = chargeTime * 5;
            if(chargeTime > maxChargeTime)
            {
                usePotShot = true;
            }
            directionLock = true;
        }
        if((Input.GetMouseButtonUp(0) || usePotShot) && grounded == false && canUsePotShot)
        {
            animator.Play("Wilbur_Pot_Shot_Out");
            Instantiate(potShotProjectile, transform.Find("Pot").position, transform.Find("Pot").rotation);
            float angle = Mathf.Atan2(difference.y, difference.x);
            recoilVelocity = new Vector2(-Mathf.Cos(angle) * Mathf.Rad2Deg * potShotRecoil, -Mathf.Sin(angle) * Mathf.Rad2Deg * potShotRecoil);
            potShotRecoiling = true;
            canUsePotShot = false;
            freezePosition = false;
            freezePositionNeedsAdjusting = true;
            rotateToNormalRotation = true;
            potSpriteRenderer.color = Color.white;
            usePotShot = false;
            chargeTime = 0;
            directionLock = false;
        }
    }
    private void Headbutt()
    {
        if (Input.GetMouseButtonDown(0) && grounded && headbutting == false)
        {
            StartCoroutine(HeadbuttRoutine());
        }
    }
    private void Fastfall()
    {
        isDownPressed = Input.GetKeyDown("s");
        if (isDownPressed && grounded == false && canFastfall && rb.velocity.y > -fastfallSpeed)
        {
            rb.velocity = new Vector2(rb.velocity.x, -fastfallSpeed);
            canFastfall = false;
        }
    }
    private void DirectionAdjuster()
    {
        if (isLeftPressed && directionLock == false)
        {
            facingLeft = true;
        }
        if (isRightPressed && directionLock == false)
        {
            facingRight = true;
        }
        if (facingLeft)
        {
            transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
            for(int i = 0; i < effectsScript.isFlipped.Length; i++)
            {
                effectsScript.isFlipped[i] = true;
            }
            boxCollider2D.offset = new Vector2(Mathf.Abs(boxCollider2D.offset.x), boxCollider2D.offset.y);
            facingLeft = false;
        }
        if (facingRight)
        {
            transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
            for (int i = 0; i < effectsScript.isFlipped.Length; i++)
            {
                effectsScript.isFlipped[i] = false;
            }
            boxCollider2D.offset = new Vector2(-Mathf.Abs(boxCollider2D.offset.x), boxCollider2D.offset.y);
            facingRight = false;
        }
    }
    void FixedUpdate()
    {
        if (isSpacePressed)
        {
            JumpDicider();
            isSpacePressed = false;
        }

        if (freezePosition)
        {
            rb.velocity = emptyVector3;
            rb.gravityScale = 0;
        }
        else if(freezePosition == false && freezePositionNeedsAdjusting)
        {
            rb.gravityScale = normalGravityScale;
            freezePositionNeedsAdjusting = false;
        }


        if (potShotRecoiling)
        {
            rb.velocity = recoilVelocity;
            potShotRecoiling = false;
        }

        if (jumpCount == maxJumps)
        {
            jumpsAvailable = false;
        }
        else
        {
            jumpsAvailable = true;
        }
    }
    private void JumpDicider()
    {
        if (isRightPressed == false && isLeftPressed == false && isUpPressed == false)
        {
            rb.velocity = new Vector2(rb.velocity.x, jumpHeight);
        }
        else if (isRightPressed && isLeftPressed == false && isUpPressed == false)
        {
            rb.velocity = new Vector2(jumpHeight, jumpHeight / 1.8f);
        }
        else if (isRightPressed == false && isLeftPressed && isUpPressed == false)
        {
            rb.velocity = new Vector2(-jumpHeight, jumpHeight / 1.8f);
        }
        else if (isRightPressed == false && isLeftPressed == false && isUpPressed)
        {
            rb.velocity = new Vector2(rb.velocity.x, (jumpHeight + (jumpHeight / 3)));
        }
        else if (isRightPressed && isLeftPressed && isUpPressed)
        {
            rb.velocity = new Vector2(rb.velocity.x, (jumpHeight + (jumpHeight / 3)));
        }
        else if (isRightPressed && isLeftPressed == false && isUpPressed)
        {
            rb.velocity = new Vector2(jumpHeight / 1.8f, (jumpHeight + (jumpHeight / 3) / 1.8f));
        }
        else if (isRightPressed == false && isLeftPressed && isUpPressed)
        {
            rb.velocity = new Vector2(-jumpHeight / 1.8f, (jumpHeight + (jumpHeight / 3) / 1.8f));
        }
    }
    private void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.gameObject.CompareTag("World"))
        {
            grounded = true;
            if(transform.rotation != Quaternion.Euler(0f, 0f, 0f))
            {
                transform.rotation = Quaternion.Euler(0f, 0f, 0f);
            }
            canUsePotShot = true;
            rb.velocity = new Vector2(0, rb.velocity.y);
            jumpCount = 0;
            effectsScript.spawn[0] = true;
        }
    }
    private void OnTriggerExit2D(Collider2D collision)
    {
        if (collision.gameObject.CompareTag("World"))
        {
            grounded = false;
            canFastfall = true;
        }
    }
    private void OnCollisionEnter2D(Collision2D collision)
    {
        if (collision.gameObject.CompareTag("Enemy"))
        {
            health -= collision.gameObject.GetComponent<EnemyScript>().damage;
            knockback = collision.gameObject.GetComponent<EnemyScript>().knockback;
            stunTime = Mathf.Abs(knockback / 20);
            StartCoroutine(Knockback());
        }
       
    }
    IEnumerator Knockback()
    {
        rb.velocity = new Vector2(knockback, Mathf.Abs(knockback / 2));
        playerController.enabled = false;
        for(int i = 0; i < srBodyparts.Length; i++)
        {
            srBodyparts[i].color = new Color(0.97f, 0.49f, 0.49f, 1);
        }
        yield return new WaitForSeconds(stunTime);
        for (int i = 0; i < srBodyparts.Length; i++)
        {
            srBodyparts[i].color = Color.white;
        }
        playerController.enabled = true;
    }
    IEnumerator HeadbuttRoutine()
    {
        headbutting = true;
        directionLock = true;
        animator.Play("Wilbur_Headbutt");
        yield return new WaitForSeconds(7 / 60f);
        effectsScript.spawn[1] = true;
        yield return new WaitForSeconds(14 / 60f);
        directionLock = false;
        headbutting = false;
    }
    IEnumerator AnimationResetter()
    {
        shouldAnimationReset = false;
        float currentAnimation = animator.GetCurrentAnimatorStateInfo(0).fullPathHash;
        float animationTime = animator.GetCurrentAnimatorStateInfo(0).length;
        yield return new WaitForSeconds(animationTime);
        if(currentAnimation == animator.GetCurrentAnimatorStateInfo(0).fullPathHash) animator.Play("Wilbur_Idle");
        shouldAnimationReset = true;
    }
}

[Kurt-Dekker]

You have a lot of huge blocks of duplicated logic, but I’d start looking at lines 79 and 93: you probably do not want to set the rotation when difference is below a certain magnitude, for example less than 0.1 or so.

There may also be physics interaction going on, as you are not using the physics properly to rotate: you are bypassing it by going straight to the transform. In a nutshell:

With Physics (or Physics2D), never manipulate the Transform directly. If you manipulate the Transform directly, you are bypassing the physics system and you can reasonably expect glitching and missed collisions and other physics mayhem.

Always use the .MovePosition() and .MoveRotation() methods on the Rigidbody (or Rigidbody2D) instance in order to move or rotate things. Doing this keeps the physics system informed about what is going on.

Collisions in high speed without unity physic / rigidbody

You say you're not using 2D physics but you're using queries therefore obviously colliders. This IS using 2D physics therefore you need to use it correctly so here are some basic rules: Don't ever modify the Transform if using 2D physics components If you want a 2D Collider to move then add a Rigidbody2D and use its API to move it; many ways to do this. Rigidbody2D don't make it "unresponsive". If you want explicit control then set the body-type to Kinematic; it's what it's for. When you qu…

OnCollisionEnter2D not being called

That’s not related to body-type. You should never drive via the Transform. The main thing to understand here is that the Rigidbody2D role is to write to the Transform after the physics simulation, not the other way around. It acts as a proxy to the Transform because you want physics behaviour. Does “it work” if you write to the Transform and force the Rigidbody2D to read from the Transform? Yes! It works like that because otherwise it’d be reported as a bug and so we’re forced to “support” it.…

If that’s not it, here’s how to actually find out what your code is doing:

What is often happening in these cases is one of the following:

• the code you think is executing is not actually executing at all
• the code is executing far EARLIER or LATER than you think
• the code is executing far LESS OFTEN than you think
• the code is executing far MORE OFTEN than you think
• the code is executing on another GameObject than you think it is
• you’re getting an error or warning and you haven’t noticed it in the console window

To help gain more insight into your problem, I recommend liberally sprinkling Debug.Log() statements through your code to display information in realtime.

Doing this should help you answer these types of questions:

• is this code even running? which parts are running? how often does it run? what order does it run in?
• what are the values of the variables involved? Are they initialized? Are the values reasonable?
• are you meeting ALL the requirements to receive callbacks such as triggers / colliders (review the documentation)

Knowing this information will help you reason about the behavior you are seeing.

You can also supply a second argument to Debug.Log() and when you click the message, it will highlight the object in scene, such as Debug.Log("Problem!",this);

If your problem would benefit from in-scene or in-game visualization, Debug.DrawRay() or Debug.DrawLine() can help you visualize things like rays (used in raycasting) or distances.

You can also call Debug.Break() to pause the Editor when certain interesting pieces of code run, and then study the scene manually, looking for all the parts, where they are, what scripts are on them, etc.

You can also call GameObject.CreatePrimitive() to emplace debug-marker-ish objects in the scene at runtime.

You could also just display various important quantities in UI Text elements to watch them change as you play the game.

If you are running a mobile device you can also view the console output. Google for how on your particular mobile target, such as this answer or iOS: How To - Capturing Device Logs on iOS or this answer for Android: How To - Capturing Device Logs on Android

Another useful approach is to temporarily strip out everything besides what is necessary to prove your issue. This can simplify and isolate compounding effects of other items in your scene or prefab.

Here’s an example of putting in a laser-focused Debug.Log() and how that can save you a TON of time wallowing around speculating what might be going wrong:

Coroutine missing hint and error

This is so unnecessary. Use the beauty and power of instantly and immediately putting a Debug.Log() statement into the very start of the coroutine, right at the top. Do this always at the very first sign of trouble or question in your mind. The instant you did this you would see “Oh man, this code is simply not getting run!” And you could LASER-FOCUS 100% your efforts on studying what you expect to run it, eg., the call location, and isolate why it is not running. You would look at literall…

You must find a way to get the information you need in order to reason about what the problem is.

[Slurgelman]

Thanks a lot for your amazing in-depth reply Kurt-Dekker,

Using rb.rotation = Quaternion.Slerp(transform.rotation, Quaternion.Euler(0f, 0f, rotZ + potShooterOffset), 4f * Time.fixedDeltaTime).eulerAngles.z; and

if (rotateToNormalRotation)
        {
            rb.rotation = Quaternion.Slerp(transform.rotation, Quaternion.Euler(0f, 0f, 0f), 5f * Time.fixedDeltaTime).eulerAngles.z;
            if (rb.rotation == 0)
            {
                rotateToNormalRotation = false;
            }
        }

then putting them in FixedUpdate() instead of using transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.Euler(0f, 0f, rotZ + potShooterOffset), 4f * Time.deltaTime); and

if (rotateToNormalRotation)
        {
            transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.Euler(0f, 0f, 0f), 5f * Time.deltaTime);
            if (transform.rotation == Quaternion.Euler(0f, 0f, 0f))
            {
                rotateToNormalRotation = false;
            }
        }

in Update() seemed to have fixed the stutter.