2D Rotation Lerp Back To 0 Degrees, Please Help

Basically, the gun rotates back the almost-360-degree way because it's lerping the angle positively only. What you need to do is check where the player is aiming and then pick the closest direction to rotate back to 0 degrees.

If the player is aiming in quadrants 1 or 2, then you can lerp back to 0 the way you already are.

If the player is aiming in quadrants 3 or 4, then you want to rotate the other way (just multiply Time.deltaTime by -6f instead of 6f).

A simple way to check which quadrant the the player is aiming in is to subtract the x and y coordinates of the touch point from the x and y coordinates of the player's location. The signs of the results will indicate the quadrant:

• Both positive: 1

• Negative x, positive y: 2

• Both negative: 3

• Positive x, negative y: 4

As a side note, this code always makes angle zero, so it's a bit redundant:

  if (angle > 0){
      angle = 0;
  }
  
  if (angle < 0){
      angle = 0;
  }

You could just replace it with:

 angle = 0;

Right now it looks like you lerp back towards zero whether or not you are detecting any touches. It seems to me like you should add some logic to check and only lerp towards zero when the user isn't touching the screen.

Okay, so here's an implementation that differs slightly from the description above by using Transform.RotateAround() to achieve the rotation and the cross product to calculate which direction to rotate.

 #pragma strict
 
 public var mainCamera : Camera;
 
 public var playerTransform : Transform;
 
 //The default position relative to the player
 public var defaultPosition : Vector3;
 
 public var rotationSpeed : float;
 public var threshold : float;
 
 private var mouse_pos : Vector3;
 private var object_pos : Vector3;
 private var angle : float;
 
 private var dir : int;
 
 private var xVector : Vector3 = Vector3(1.0f, 0.0f, 0.0f);
 private var zVector : Vector3 = Vector3(0.0f, 0.0f, 1.0f);
 
 function Update()
 {
     Rotate();
 }
 
 function Rotate()
 {
     //Calculate the position of the rotating object relative to the player
     object_pos = transform.position;
     object_pos.x = object_pos.x - playerTransform.position.x;
     object_pos.y = object_pos.y - playerTransform.position.y;
     object_pos.z = 0.0f;
 
     if (Input.GetMouseButton(0))
     {
         //Calculate the position of the mouse cursor relative to the player
         mouse_pos = Input.mousePosition;
         mouse_pos = mainCamera.ScreenToWorldPoint(mouse_pos);
         mouse_pos.x = mouse_pos.x - playerTransform.position.x;
         mouse_pos.y = mouse_pos.y - playerTransform.position.y;
         mouse_pos.z = 0.0f;
         
         //Calculate the rotation direction and perform the rotation
         dir = CalculateRotationDirection(object_pos, mouse_pos);
         transform.RotateAround(playerTransform.position, zVector, Time.deltaTime * rotationSpeed * dir);
     }
     else
     {
         //Calculate the rotation direction and rotate towards the default position
         dir = CalculateRotationDirection(object_pos, xVector);
         if (dir != 0)
         {
             transform.RotateAround(playerTransform.position, zVector, Time.deltaTime * rotationSpeed * dir);
         }
         else
         {
             transform.position = playerTransform.position + defaultPosition;
         }
     }
 }
 
 function CalculateRotationDirection(currentPoint : Vector3, targetPoint : Vector3)
 {    
     //Initialize some vectors
     var currentVector : Vector3 = Vector3.zero;
     var targetVector : Vector3 = Vector3.zero;
     
     //Handle scenarios where the cross product is equal to zero.
     if (Vector3.Angle(currentPoint, targetPoint) < threshold && Vector3.Angle(currentPoint, targetPoint) > -threshold)
     {
         return 0;
     }
     else if (Vector3.Angle(currentPoint, targetPoint) == 180)
     {
         return 1;
     }
     
     //Calculate the cross product - this tells us the relation between the vectors
     var cross = Vector3.Cross(currentPoint, targetPoint);
     
     //Return the direction multiplier based on the cross product
     if (cross.z > 0.0f)
     {
         return 1;
     }
     else
     {
         return -1;
     }
 }

This should now work using sprites in 2D with an arbitrary player position.

Hope this help!