My character moves at different speed in build and runs?

Hello my character moves at different speeds everytime i run in editor. Also its different at build too! I am using deltaTime too but i dont know what i'm missing. I searched all over the internet but it doesnt say anything else then deltaTime. Also i have issues with characterController movements too. It is very laggy in editor but fine in build.. here is my move script.

 `using System.Collections;
 using UnityEngine;
 
 public class Player : MonoBehaviour
 {
     [RequireComponent(typeof(CharacterController))]
     [RequireComponent(typeof(PlayerState))]
 
 
     [System.Serializable]
     public class MouseInput
     {
         public Vector2 Damping;
         public Vector2 Sensitivity;
         public bool LockMouse;
     }
 
     [SerializeField]
     AudioController footSteps;
 
     [SerializeField]
     float minimumMoveTreshold;
 
     [SerializeField]
     Character settings;
 
     [SerializeField]
     MouseInput MouseControl;
 
     [Header("MoveRamps")]
     [SerializeField]
     float rIdle;
 
     [SerializeField]
     float rUp;
 
     [SerializeField]
     float rDown;
 
     [SerializeField]
     float rSprint;
 
     public PlayerAim PlayerAim;
 
     InputController playerInput;
     Vector2 mouseInput;
 
     float speed = 0f;
     float targetSpeed;
     float targetRamp;
     Vector3 previousPosition;
 
 
 
 
     private PlayerShoot m_PlayerShoot;
     public PlayerShoot PlayerShoot
     {
         get
         {
             if (m_PlayerShoot == null)
                 m_PlayerShoot = GetComponent<PlayerShoot>();
             return m_PlayerShoot;
         }
     }
 
 
     private PlayerState m_PlayerState;
     public PlayerState PlayerState
     {
         get
         {
             if (m_PlayerState == null)
                 m_PlayerState = GetComponent<PlayerState>();
             return m_PlayerState;
         }
     }
 
     private CharacterController m_MoveController;
     public CharacterController MoveController
     {
         get
         {
             if (m_MoveController == null)
                 m_MoveController = GetComponent<CharacterController>();
             return m_MoveController;
         }
     }
 
 
     void Awake()
     {
         playerInput = GameManager.Instance.InputController;
         GameManager.Instance.LocalPlayer = this;
 
         if (MouseControl.LockMouse)
         {
             Cursor.visible = false;
             Cursor.lockState = CursorLockMode.Locked;
         }
     }
 
 
     void Update()
     {
         Move();
         
     }
 
     private void LateUpdate()
     {
         LookAround();
     }
 
     private void LookAround()
     {
         mouseInput.x = Mathf.Lerp(mouseInput.x, playerInput.MouseInput.x, 1f / MouseControl.Damping.x);
         mouseInput.y = Mathf.Lerp(mouseInput.y, playerInput.MouseInput.y, 1f / MouseControl.Damping.y);
         transform.Rotate(Vector3.up * mouseInput.x * MouseControl.Sensitivity.x );
         PlayerAim.SetRotation(mouseInput.y * MouseControl.Sensitivity.y);
     }
 
     int idleCounter = 0;
     int idleWait = 250;
 
     void Move()
     {
         if (Mathf.Abs(playerInput.Vertical) <= 0.1f && Mathf.Abs(playerInput.Horizontal) <= 0.1f)
         {
             playerInput.IsWalking = false;
             if (idleCounter <= idleWait)
             {
                 if (speed < 0.1f)
                 {
                     speed = 0f;
                     playerInput.IsIdle = true;
 
                 }
                 else
                 {
 
                     idleCounter += 1;
                     targetSpeed = 0f;
                     targetRamp = rIdle;
                 }
             }
         }
         else
         {
             idleCounter = 0;
             playerInput.IsIdle = false;
 
             if (!playerInput.IsCrouching && !playerInput.IsSprinting)
                 playerInput.IsWalking = true;
             else
                 playerInput.IsWalking = false;
 
             if (playerInput.IsIdle)
             {
                 targetSpeed = 0f;
                 targetRamp = rIdle;
             }
 
             if (playerInput.IsCrouching)
 
             {
                 targetSpeed = settings.CrouchSpeed;
                 if (speed > targetSpeed)
                     targetRamp = rDown;
                 else
                     targetRamp = rUp;
             }
 
             if (playerInput.IsWalking)
             {
                 targetSpeed = settings.WalkSpeed;
                 if (speed > targetSpeed)
                     targetRamp = rDown;
                 else
                     targetRamp = rUp;
             }
 
             if (playerInput.IsSprinting)
             {
                 targetSpeed = settings.SprintSpeed;
                 targetRamp = rSprint;
             }
         }
 
         speed = Mathf.Lerp(speed, targetSpeed * settings.MoveMultiply, targetRamp  * Time.deltaTime);
         print("speed   " + speed);
 
         Vector2 direction = new Vector2(playerInput.Vertical, playerInput.Horizontal);
         print(playerInput.Vertical + "  " + playerInput.Horizontal);
 
         direction = direction.normalized;
         print("normalized   "+direction);
 
         direction = direction * speed * Time.deltaTime;
         print("afterMultiply   " + direction);
 
         MoveController.SimpleMove(transform.forward * direction.x + transform.right * direction.y );
 
         if (Vector3.Distance(previousPosition, transform.position) > minimumMoveTreshold)
             footSteps.Play();
 
         previousPosition = transform.position;
 
     }
 
 
 }

And this is my camera move script.

 using System;
 using System.Collections;
 using UnityEngine;
 
 public class ThirdPersonCamera : MonoBehaviour
 {
     [System.Serializable]
     public class CameraRig
     {
         public Vector3 CameraOffset;
         public float CrouchHeight;
         public float Damping;
     }
 
 
     [SerializeField]
     CameraRig defaultCamera;
     [SerializeField]
     CameraRig aimCamera;
 
     [SerializeField]
     float yChangeSpeed;
     [SerializeField]
     float zChangeSpeed;
 
 
     Transform cameraLookTarget;
     Player localPlayer;
 
     void Awake()
     {
         GameManager.Instance.OnLocalPlayerJoined += HandleOnLocalPlayerJoined;
     }
 
     void HandleOnLocalPlayerJoined(Player player)
     {
         localPlayer = player;
         cameraLookTarget = localPlayer.transform.Find("cameraLookTarget");
 
         if (cameraLookTarget == null)
             cameraLookTarget = localPlayer.transform;
     }
     
 
     void LateUpdate()
     {
         if (localPlayer == null)
             return;
 
         CameraRig cameraRig = defaultCamera;
 
         if (localPlayer.PlayerState.WeaponState == PlayerState.EweaponState.AIMING || localPlayer.PlayerState.WeaponState == PlayerState.EweaponState.AIMEDFIRING)
             cameraRig = aimCamera;
 
 
         float targetHeight = cameraRig.CameraOffset.y + (localPlayer.PlayerState.MoveState == PlayerState.EmoveState.CROUCHING ? cameraRig.CrouchHeight: 1.2f);
 
         Vector3 targetPosition = cameraLookTarget.position +
                                  
                                  localPlayer.transform.forward * cameraRig.CameraOffset.z +
                                  localPlayer.transform.right * cameraRig.CameraOffset.x;
 
         targetPosition.y = Mathf.Lerp(transform.position.y , targetPosition.y * targetHeight, yChangeSpeed * Time.fixedDeltaTime);
         //targetPosition.z = Mathf.Lerp(targetPosition.z, localPlayer.transform.forward.z * cameraRig.CameraOffset.z, zChangeSpeed * Time.fixedDeltaTime);
 
 
         Quaternion targetRotation = Quaternion.LookRotation(cameraLookTarget.position - targetPosition, Vector3.up);
 
         //transform.position = Vector3.Lerp(transform.position, targetPosition, cameraRig.Damping * Time.fixedDeltaTime);
         transform.position = Vector3.Lerp(transform.position, targetPosition, cameraRig.Damping * Time.fixedDeltaTime);
         transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, cameraRig.Damping * Time.fixedDeltaTime);
     }
 }