Help with managing your character with the camera

When the game character model starts to twitch when driving. Through trial and error, it turned out that the case in camera script. How to fix t$$anonymous$$s problem ?? Help!!!

[System.Serializable]

         public class CameraController : MonoBehaviour
         {
             // =================================    
             // Nested classes and structures.
             // =================================

             // ...

             public struct ClipPlanePoints
             {
                 public Vector3 UpperLeft;
                 public Vector3 UpperRight;
                 public Vector3 LowerLeft;
                 public Vector3 LowerRight;
             }

             // =================================    
             // Variables.
             // =================================

             // ...

             new Camera camera;

             // Transforms.

             [Header("Transforms")]

             public Transform target;
             public Transform offset;

             // Position.

             [Header("Position")]

             public float followTargetSpeed = 8.0f;

             // Rotation.

             [Header("Rotation")]

             Vector2 mouseInput;

             public float mouseRotateAmount = 5.0f;
             public float mouseRotateSpeed = 5.0f;

             public float rotateZSpeed = 1.0f;
             public float resetZRotationSpeed = 5.0f;

             public Vector2 lookUpDownRange = new Vector2(-80.0f, 80.0f);

             // Zoom.

             [Header("Zoom")]

             public float zoomDistance = 4.0f;

             public float mouseZoomAmount = 1.0f;
             public float mouseZoomSpeed = 5.0f;

             public float mouseZoomMin = 1.0f;
             public float mouseZoomMax = 5.0f;

             // ...

             [Header("Occlusion Zoom")]

             public float occlusionZoomSpeed = 8.0f;
             public float occlusionZoomOffset = 0.0f;

             public float occlusionRaycastDownDistance = 0.5f;

             public AnimationCurve occlisionRaycastDownCurve =
                 new AnimationCurve(new Keyframe(0.0f, 1.0f), new Keyframe(1.0f, 0.0f));

             // Offset framing.

             [Header("Offset (Framing)")]

             public float offsetFramingAmount = 2.0f;
             public float offsetFramingSpeed = 1.0f;

             public float minPlayerSpeedForOffsetFraming = 1.0f;
             public float minMouseMoveForOffsetFraming = 1.0f;

             Vector3 offsetStartPosition;

             Vector3 offsetPositionTarget;
             Vector3 offsetMouseFramePosition;

             // Stored locally as euler because Quaternions take shortest
             // path around for rotation. By using euler, I don't run into 
             // the problem of spinning the camera too quickly and causing 
             // a sudden snap because the rotation exceeded 180 degrees.

             Vector3 rotationEuler;
             Vector3 targetRotationEuler;

             // Player.

             Player player;

             // =================================    
             // Functions.
             // =================================

             // ...

             void Awake()
             {

             }

             // ...

             void Start()
             {
                 lockMouse();

                 camera = Camera.main;
                 player = FindObjectOfType<Player>();

                 zoomDistance = Vector3.Distance(camera.transform.position, target.position);

                 offsetStartPosition = offset.localPosition;
                 offsetPositionTarget = offsetStartPosition;
             }

             // ...

             void lockMouse()
             {
                 Cursor.visible = false;
                 Cursor.lockState = CursorLockMode.Locked;
             }
             void unlockMouse()
             {
                 Cursor.visible = true;
                 Cursor.lockState = CursorLockMode.None;
             }

             // ...

             void FixedUpdate()
             {

             }

             // ...

             void Update()
             {
                 // Input.

                 mouseInput.x = Input.GetAxis("Mouse X");
                 mouseInput.y = Input.GetAxis("Mouse Y");

                 if (Input.GetMouseButtonDown(0))
                 {
                     lockMouse();
                 }
                 else if (Input.GetKeyDown(KeyCode.Escape))
                 {
                     unlockMouse();
                 }
             }

             // ...

             void LateUpdate()
             {                    
                 // Follow position.

                 transform.position = Damping.dampVector3(transform.position, target.position, followTargetSpeed, Time.deltaTime);

                 if (Cursor.lockState == CursorLockMode.Locked)
                 {
                     // Rotation.
                     // Can't get it to smooth when rotating, so I just set the physica time step to 0.01f (half of default).

                     targetRotationEuler.y += mouseInput.x * mouseRotateAmount;
                     targetRotationEuler.x += -mouseInput.y * mouseRotateAmount;

                     targetRotationEuler.x = Mathf.Clamp(targetRotationEuler.x, lookUpDownRange.x, lookUpDownRange.y);

                     targetRotationEuler.z += mouseInput.x * rotateZSpeed;

                     rotationEuler = Damping.dampVector3(rotationEuler, targetRotationEuler, mouseRotateSpeed, Time.deltaTime);

                     transform.eulerAngles = rotationEuler;

                     //transform.rotation *= Quaternion.AngleAxis(mouseRotateSpeed * Time.deltaTime, Vector3.up);

                     // Offset framing.

                     float playerSpeed = player.rb.velocity.magnitude;

                     if (playerSpeed < minPlayerSpeedForOffsetFraming)
                     {
                         offsetMouseFramePosition = offsetStartPosition;
                     }
                     else
                     {
                         if (mouseInput.x > minMouseMoveForOffsetFraming)
                         {
                             offsetMouseFramePosition.x = -offsetFramingAmount;
                         }
                         else if (mouseInput.x < -minMouseMoveForOffsetFraming)
                         {
                             offsetMouseFramePosition.x = offsetFramingAmount;
                         }

                         if (mouseInput.y > minMouseMoveForOffsetFraming)
                         {
                             offsetMouseFramePosition.y = -offsetFramingAmount;
                         }
                         else if (mouseInput.y < -minMouseMoveForOffsetFraming)
                         {
                             offsetMouseFramePosition.y = offsetFramingAmount;
                         }
                     }

                     offsetPositionTarget = Damping.dampVector3(offsetPositionTarget, offsetMouseFramePosition, offsetFramingSpeed, Time.deltaTime);

                     // Balance out rotation around Z back to 0.0f.

                     targetRotationEuler.z = Damping.dampFloat(targetRotationEuler.z, 0.0f, resetZRotationSpeed, Time.deltaTime);

                     // Zoom.

                     // Scrolling happens as 0.1f increments. x10.0f to make it 1.0f.

                     float scroll = Input.GetAxis("Mouse ScrollWheel") * 10.0f;

                     zoomDistance -= scroll * mouseZoomAmount;
                     zoomDistance = Mathf.Clamp(zoomDistance, mouseZoomMin, mouseZoomMax);

                     // Player occlusion check and zoom.

                     RaycastHit $$anonymous$$tInfo;

                     checkIfPlayerOccluded(out $$anonymous$$tInfo);
                     //float nearestDistance = checkCameraPoints(out $$anonymous$$tInfo);

                     Vector3 finalOffsetPositionTarget;

                     RaycastHit $$anonymous$$tInfo2;

                     Transform cameraTransform = camera.transform;

                     Vector3 directionToTarget = (target.position - cameraTransform.position).normalized;
                     Vector3 end = target.position - (directionToTarget * (zoomDistance + occlusionZoomOffset));

                     Physics.Raycast(end, Vector3.down, out $$anonymous$$tInfo2, occlusionRaycastDownDistance);
                     Debug.DrawLine(end, end + (Vector3.down * occlusionRaycastDownDistance), Color.w$$anonymous$$te);

                     if ($$anonymous$$tInfo.collider)
                     {
                         //finalOffsetPositionTarget = offsetPositionTarget.normalized * nearestDistance;
                         finalOffsetPositionTarget = offsetPositionTarget.normalized * $$anonymous$$tInfo.distance;
                     }
                     //if ($$anonymous$$tInfo2.collider)
                     //{                            
                     //    float curveResult = 1.0f - occlisionRaycastDownCurve.Evaluate($$anonymous$$tInfo2.distance / occlusionRaycastDownDistance);
                     //    finalOffsetPositionTarget = (offsetPositionTarget.normalized * zoomDistance) * curveResult;
                     //}
                     //else if ($$anonymous$$tInfo.collider)
                     //{
                     //    finalOffsetPositionTarget = Vector3.zero;
                     //}
                     else
                     {
                         finalOffsetPositionTarget = offsetPositionTarget.normalized * zoomDistance;
                     }

                     offset.localPosition = Damping.dampVector3(offset.localPosition, finalOffsetPositionTarget, mouseZoomSpeed, Time.deltaTime);
                 }
             }

             // ...

             void checkIfPlayerOccluded(out RaycastHit $$anonymous$$tInfo)
             {
                 if (!camera)
                 {
                     camera = Camera.main;
                 }

                 Transform cameraTransform = camera.transform;

                 Vector3 directionToTarget = (target.position - cameraTransform.position).normalized;

                 Vector3 start = target.position;
                 Vector3 end = Application.isPlaying ?

                     (target.position - (directionToTarget * (zoomDistance + occlusionZoomOffset))) :
                     (offset.position + (-directionToTarget * occlusionZoomOffset));

                 Physics.Linecast(start, end, out $$anonymous$$tInfo);

                 if (!Application.isPlaying)
                 {
                     Gizmos.color =
                         $$anonymous$$tInfo.collider ? Color.red : Color.green;

                     Gizmos.DrawLine(start, end);
                 }
                 else
                 {
                     Debug.DrawLine(start, end, $$anonymous$$tInfo.collider ? Color.red : Color.green);
                 }
             }

             // ...

             void OnDrawGizmos()
             {
                 RaycastHit $$anonymous$$tInfo;

                 checkIfPlayerOccluded(out $$anonymous$$tInfo);
                 //checkCameraPoints(out $$anonymous$$tInfo);
             }

             // =================================    
             // End functions.
             // =================================

         }

         // =================================    
         // End namespace.
         // =================================

     }

 }

}