Orbit Camera on Survival Shooter Sample Project

Hello everyone, please, how can I implement an orbit camera using the Survival Shooter example from Unity Website? I tried using the following code:

 using UnityEngine;
 using System.Collections;
 
 public class CameraController : MonoBehaviour {
 
     [System.Serializable]
     public class PositionSettings
     {
         public Vector3 targetPosOffset = new Vector3(0, 3.4f, 0);
         public float lookSmooth = 100;
         public float distanceFromTarget = -8;
         public float zoomSmooth = 10;
         public float maxZoom = -2;
         public float minZoon = -15;
         public float xRotation;
         public float yRotation;
     }
 
     [System.Serializable]
     public class OrbitSettings
     {
         public float xRotation = -20;
         public float yRotation = -180;
         public float maxXRotation = 0;
         public float minXRotation = -85;
         public float vOrbitSmooth = 150;
         public float hOrbitSmooth = 150;
     }
 
     [System.Serializable]
     public class InputSettings
     {
         public string ORBIT_HORIZONTAL_SNAP = "OrbitHorizontalSnap";
         public string ORBIT_HORIZONTAL = "OrbitHorizontal";
         public string ORBIT_VERTICAL = "OrbitVertical";
         public string ZOOM = "Mouse ScrollWheel";
     }
 
     public PositionSettings position = new PositionSettings();
     public OrbitSettings orbit = new OrbitSettings();
     public InputSettings input = new InputSettings();
 
     public Transform target;
     Vector3 targetPos = Vector3.zero;
     Vector3 destination = Vector3.zero;
     CharacterController charController;
     float vOrbitInput, hOrbitInput, zoomInput, hOrbitSnapInput;
 
     void Start()
     {
 
         SetCameraTarget(target);
 
         targetPos = target.position + position.targetPosOffset;
         destination = Quaternion.Euler(orbit.xRotation, orbit.yRotation + target.eulerAngles.y, 0) * -Vector3.forward * position.distanceFromTarget;
         destination += targetPos;
         transform.position = destination;
     }
 
     void SetCameraTarget(Transform t)
     {
         target = t;
 
         if (target != null)
         {
             if (target.GetComponent<CharacterController>())
             {
                 charController = target.GetComponent<CharacterController>();
             }
             else
                 Debug.LogError("The camera's target needs a character controller.");
         }
         else
             Debug.LogError("Your camera needs a target.");
     }
 
     void GetInput()
     {
         vOrbitInput = Input.GetAxisRaw(input.ORBIT_VERTICAL);
         hOrbitInput = Input.GetAxisRaw(input.ORBIT_HORIZONTAL);
         hOrbitSnapInput = Input.GetAxisRaw(input.ORBIT_HORIZONTAL_SNAP);
         zoomInput = Input.GetAxisRaw(input.ZOOM);
     }
 
     void Update()
     {
         GetInput();
         OrbitTarget();
         ZoomInOnTarget();
     }
 
 
     void LateUpdate()
     {
         // moving
         MoveToTarget();
         // rotating
         LookAtTarget();
     }
 
     void MoveToTarget()
     {
         targetPos = target.position + position.targetPosOffset;
         destination = Quaternion.Euler(orbit.xRotation, orbit.yRotation + target.eulerAngles.y, 0) * -Vector3.forward * position.distanceFromTarget;
         destination += targetPos;
         transform.position = destination;
     }
 
     void LookAtTarget()
     {
         Quaternion targetRotation = Quaternion.LookRotation(targetPos - transform.position);
         transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, position.lookSmooth * Time.deltaTime);
     }
 
     void OrbitTarget()
     {
         if(hOrbitSnapInput > 0)
         {
             orbit.yRotation = -180;
         }
 
         orbit.xRotation += -vOrbitInput * orbit.vOrbitSmooth * Time.deltaTime;
         orbit.yRotation += -hOrbitInput * orbit.hOrbitSmooth * Time.deltaTime;
 
         if(orbit.xRotation > orbit.maxXRotation)
         {
             orbit.xRotation = orbit.maxXRotation;
         }
         if(orbit.xRotation < orbit.minXRotation)
         {
             orbit.xRotation = orbit.minXRotation;
         }
     }
 
     void ZoomInOnTarget()
     {
 
     }
 }

When player rotates looking at mouse cursor, the method of CameraController LookAtTarget receives the new rotation from the player resulting in a infinity loop rotation following the mouse cursor and the player rotation.

So, how can I implement Player rotation looking at mouse cursor (like Survival Shooter), without interfering in the camera orbit rotation?

Thank you in advance.