Camera not going back to its original position

Unity Engine
1

Here’s the script, it doesn’t work if I set wasShooting to false when I’m not shooting anymore

using UnityEngine;
using System.Collections;

/// MouseLook rotates the transform based on the mouse delta.
/// Minimum and Maximum values can be used to constrain the possible rotation

/// To make an FPS style character:
/// - Create a capsule.
/// - Add the MouseLook script to the capsule.
///   -> Set the mouse look to use LookX. (You want to only turn character but not tilt it)
/// - Add FPSInputController script to the capsule
///   -> A CharacterMotor and a CharacterController component will be automatically added.

/// - Create a camera. Make the camera a child of the capsule. Reset it's transform.
/// - Add a MouseLook script to the camera.
///   -> Set the mouse look to use LookY. (You want the camera to tilt up and down like a head. The character already turns.)
[AddComponentMenu("Camera-Control/Mouse Look")]
public class MouseLook : MonoBehaviour {

    public enum RotationAxes { MouseXAndY = 0, MouseX = 1, MouseY = 2 }
    public RotationAxes axes = RotationAxes.MouseXAndY;
    public float sensitivityX = 15F;
    public float sensitivityY = 15F;

    public float minimumX = -360F;
    public float maximumX = 360F;

    public float minimumY = -60F;
    public float maximumY = 60F;

    bool wasShooting = false;
    public GameObject camera;
    float oldRotation;
    float time = 0;

    float rotationY = 0F;

    void Update ()
    {
        if(!wasShooting)
        {
            oldRotation = rotationY;
        }
        if(Input.GetKey(KeyCode.Mouse0))
        {
            wasShooting = true;
            rotationY += 10.0f * Time.deltaTime;
        }
        else
            if(!Input.GetKey(KeyCode.Mouse0) && wasShooting)
            {
                rotationY = oldRotation;
                wasShooting = false; //here it doesn't work
            }
        if(Input.GetKey(KeyCode.Mouse1))
        {
            sensitivityX = 5.0f;
            sensitivityY = 5.0f;
        }
        else
        {
            sensitivityX = 15f;
            sensitivityY = 15f;
        }
        if (axes == RotationAxes.MouseXAndY)
        {
            float rotationX = transform.localEulerAngles.y + Input.GetAxis("Mouse X") * sensitivityX;
           
            rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
            rotationY = Mathf.Clamp (rotationY, minimumY, maximumY);
           
            transform.localEulerAngles = new Vector3(-rotationY, rotationX, 0);
        }
        else if (axes == RotationAxes.MouseX)
        {
            transform.Rotate(0, Input.GetAxis("Mouse X") * sensitivityX, 0);
        }
        else
        {
            rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
            rotationY = Mathf.Clamp (rotationY, minimumY, maximumY);
           
            transform.localEulerAngles = new Vector3(-rotationY, transform.localEulerAngles.y, 0);
        }
    }
   
    void Start ()
    {
        // Make the rigid body not change rotation
        if (GetComponent<Rigidbody>())
            GetComponent<Rigidbody>().freezeRotation = true;
    }
}
2

What does “was shooting” do?

3

Resets the camera rotation when I stop shooting so it doesn’t keep doing it.

4

The only way I can be of any help is if you had skype, but be warned I am relatively new to Coding C# but I know Java, C++ and LUA.

Skype mccrleader

5

I’m confused. I tried the script and it’s working. What did you want to do? are you saying wasShooting never returns false?

6

I’m stupid and I forgot to add the old version of the script.
Instead of rotationY = oldRotation I want to use rotationY = Mathf.Lerp(rotationY, oldRotation, 20.0f * Time.deltaTime); but it never works, the camera doesn’t got back to its rotation when I’m not shooting.

Updated code

using UnityEngine;
using System.Collections;
/// MouseLook rotates the transform based on the mouse delta.
/// Minimum and Maximum values can be used to constrain the possible rotation
/// To make an FPS style character:
/// - Create a capsule.
/// - Add the MouseLook script to the capsule.
///   -> Set the mouse look to use LookX. (You want to only turn character but not tilt it)
/// - Add FPSInputController script to the capsule
///   -> A CharacterMotor and a CharacterController component will be automatically added.
/// - Create a camera. Make the camera a child of the capsule. Reset it's transform.
/// - Add a MouseLook script to the camera.
///   -> Set the mouse look to use LookY. (You want the camera to tilt up and down like a head. The character already turns.)
[AddComponentMenu("Camera-Control/Mouse Look")]
public class MouseLook : MonoBehaviour {
    public enum RotationAxes { MouseXAndY = 0, MouseX = 1, MouseY = 2 }
    public RotationAxes axes = RotationAxes.MouseXAndY;
    public float sensitivityX = 15F;
    public float sensitivityY = 15F;
    public float minimumX = -360F;
    public float maximumX = 360F;
    public float minimumY = -60F;
    public float maximumY = 60F;
    bool wasShooting = false;
    public GameObject camera;
    float oldRotation;
    float time = 0;
    float rotationY = 0F;
    void Update ()
    {
        if(!wasShooting)
        {
            oldRotation = rotationY;
        }
        if(Input.GetKey(KeyCode.Mouse0))
        {
            wasShooting = true;
            rotationY += 10.0f * Time.deltaTime;
        }
        else
            if(!Input.GetKey(KeyCode.Mouse0) && wasShooting)
            {
                rotationY = Mathf.Lerp(rotationY, oldRotation, 20.0f * Time.deltaTime); //here it doesn't work
                wasShooting = false;
            }
        if(Input.GetKey(KeyCode.Mouse1))
        {
            sensitivityX = 5.0f;
            sensitivityY = 5.0f;
        }
        else
        {
            sensitivityX = 15f;
            sensitivityY = 15f;
        }
        if (axes == RotationAxes.MouseXAndY)
        {
            float rotationX = transform.localEulerAngles.y + Input.GetAxis("Mouse X") * sensitivityX;
          
            rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
            rotationY = Mathf.Clamp (rotationY, minimumY, maximumY);
          
            transform.localEulerAngles = new Vector3(-rotationY, rotationX, 0);
        }
        else if (axes == RotationAxes.MouseX)
        {
            transform.Rotate(0, Input.GetAxis("Mouse X") * sensitivityX, 0);
        }
        else
        {
            rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
            rotationY = Mathf.Clamp (rotationY, minimumY, maximumY);
          
            transform.localEulerAngles = new Vector3(-rotationY, transform.localEulerAngles.y, 0);
        }
    }
  
    void Start ()
    {
        // Make the rigid body not change rotation
        if (GetComponent<Rigidbody>())
            GetComponent<Rigidbody>().freezeRotation = true;
    }
}
7

That’s not how you use Lerp. The last argument is supposed to be between 0 and 1 and represents the “percentage” between each of the first 2 values to use. It doesn’t work because you’re using 20 * deltaTime which will always be a small number and therefore always be close to whatever your first argument is.

You can either reset rotationY to be the current rotation or add 20 * deltaTime to a new variable each frame as your third argument.

8

It still doesn’t work :confused:

9

You could always Lerp it back in a IEnumertor, those are always nice to Lerp things in.

10

Same thing >.<

11

You’re going to have to be more specific than that.

12

Ok I checked out your script.

This should work:

using UnityEngine;
using System.Collections;
/// MouseLook rotates the transform based on the mouse delta.
/// Minimum and Maximum values can be used to constrain the possible rotation
/// To make an FPS style character:
/// - Create a capsule.
/// - Add the MouseLook script to the capsule.
///   -> Set the mouse look to use LookX. (You want to only turn character but not tilt it)
/// - Add FPSInputController script to the capsule
///   -> A CharacterMotor and a CharacterController component will be automatically added.
/// - Create a camera. Make the camera a child of the capsule. Reset it's transform.
/// - Add a MouseLook script to the camera.
///   -> Set the mouse look to use LookY. (You want the camera to tilt up and down like a head. The character already turns.)
[AddComponentMenu("Camera-Control/Mouse Look")]
public class MouseLook : MonoBehaviour {
    public enum RotationAxes { MouseXAndY = 0, MouseX = 1, MouseY = 2 }
    public RotationAxes axes = RotationAxes.MouseXAndY;
    public float sensitivityX = 15F;
    public float sensitivityY = 15F;
    public float minimumX = -360F;
    public float maximumX = 360F;
    public float minimumY = -60F;
    public float maximumY = 60F;
    bool wasShooting = false;
    public GameObject camera;
    float oldRotation;
    float time = 0;
    float rotationY = 0F;
    void Update ()
    {
        if(!wasShooting)
        {
            oldRotation = rotationY;
        }
        if(Input.GetKey(KeyCode.Mouse0))
        {
            wasShooting = true;
            rotationY += 10.0f * Time.deltaTime;
        }
        else
            if(!Input.GetKey(KeyCode.Mouse0) && wasShooting)
        {
            rotationY = Mathf.Lerp(rotationY, oldRotation, Time.deltaTime * 5.0f); //here it doesn't work
        }
        if(Input.GetKey(KeyCode.Mouse1))
        {
            sensitivityX = 5.0f;
            sensitivityY = 5.0f;
        }
        else
        {
            sensitivityX = 15f;
            sensitivityY = 15f;
        }
        if (axes == RotationAxes.MouseXAndY)
        {
            float rotationX = transform.localEulerAngles.y + Input.GetAxis("Mouse X") * sensitivityX;
           
            rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
            rotationY = Mathf.Clamp (rotationY, minimumY, maximumY);
           
            transform.localEulerAngles = new Vector3(-rotationY, rotationX, 0);
        }
        else if (axes == RotationAxes.MouseX)
        {
            transform.Rotate(0, Input.GetAxis("Mouse X") * sensitivityX, 0);
        }
        else
        {
            rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
            rotationY = Mathf.Clamp (rotationY, minimumY, maximumY);
           
            transform.localEulerAngles = new Vector3(-rotationY, transform.localEulerAngles.y, 0);
        }
    }
   
    void Start ()
    {
        // Make the rigid body not change rotation
        if (GetComponent<Rigidbody>())
            GetComponent<Rigidbody>().freezeRotation = true;
    }
}

you also might want to spend some time cleaning it up, its quite hard to read

13

It works now but due to wasShooting being always true after the mouse button is pressed when I move the camera it goes back to its rotation even if I stopped shooting.

14

You could do a check to see if old rotation == rotationY like this:

if(Mathf.Approximately(rotationY, oldRotation))
            wasShooting = false;
15

It’s too slow with that :frowning:

It worked fine in another project and in both projects other than this script nothing else touched the camera…

16

Yeah because float’s are never really the same. Just write a approximately function that takes a tolerance and returns true like this:

bool IsApproximately (float a, float b, float tolerance) {
    return Mathf.Abs(a - b) < tolerance;
}

Then do a test with it:

if(IsApproximately(rotationY, oldRotation, 0.1f))
    wasShooting = false;
17

play around with the tolerance value to see what works for you.

18

Mathf already has an Approximately method. http://docs.unity3d.com/ScriptReference/Mathf.Approximately.html

19

Yup, If you look above, I showed him an example using MathF, my own version just has a tolerance value

20

I should learn to read.

1 Like