Should i be using rigidbody or CharacterController for Controlling the player?

Here's the script for the player movement (hopefully the summary's don't make it unbearable to read).

 /// <summary>
 /// Select the camera to follow the player
 /// </summary>
 [Header("Player Camera:")]
 [Space,Tooltip("Select the camera to follow the player.")]
 public GameObject camera;


 /// <summary>
 /// The main player object
 /// </summary>
 [Header("Player Values:")]
 [Space,Tooltip("The main player object.")]
 public GameObject PlayerObj;


 /// <summary>
 /// the players jump speed
 /// </summary>
 [Space, Tooltip("the players jump speed")]
 public float jumpSpeed = 5f;


 /// <summary>
 /// determines whether the player is currently grounded or not.
 /// </summary>
 [Tooltip("determines whether the player is currently grounded or not.")]
 public bool OnGround = true;


 /// <summary>
 /// determines how many times the player has jumped.
 /// </summary>
 [Tooltip("determines how many times the player has jumped.")]
 public int currentJump = 0;
 public const int MAX_JUMP = 1;


 /// <summary>
 /// The given movement speed for the player object
 /// </summary>
 [Space, Tooltip("The given movement speed for the player object.")]
 [Range( 1f , 20f)]
 public float movementSpeed;


 /// <summary>
 /// The given rotation speed for the player object
 /// </summary>
 [Tooltip("the given rotation speed for the player object.")]
 [Range( 1f, 20f)]
 public float RotationSpeed;


 /// <summary>
 /// This determines wether the player is currently just moving or aiming while moving.
 /// Essentially changing movement styles on the fly.
 /// </summary>
 [Tooltip("This determines whether the player is currently just moving or aiming while moving. \nEssentially changing movement styles on the fly.")]
 public bool SwitchMovement;


 /// <summary>
 /// This is the ridged body component for the player
 /// </summary>
 [Tooltip("This is the ridged body component for the player.")] //use this unless proved problematic for slopes.
 private Rigidbody rb;


 /// <summary>
 /// For debugging purposes, _Movement & _Rotation will be temporary shown on the editor for testing (Not counting the ones for 3DS.
 /// </summary>
 [SerializeField] Vector3 _Movement;
 [SerializeField] Vector3 _Rotation;


 /// <summary>
 /// The GameObject used to determine where to spawn the players bullets.
 /// </summary>
 [Header("Player Bullet Component:")]
 [Space,Tooltip("The GameObject used to determine where to spawn the players bullets.")]
 public GameObject bulletSpawnPoint;


 /// <summary>
 /// The main bullet object
 /// </summary>
 [Tooltip("The main bullet object")]
 public GameObject Bullet;


 /// <summary>
 /// Instantiated the Bullet Object.
 /// </summary>
 private Transform BulletSpawned;


 /// <summary>
 /// Determines if the player is currently firing
 /// </summary>
 [Tooltip("Determines if the player is currently firing")]
 public bool isFiring;


 /// <summary>
 /// Determines the time in between shots
 /// </summary>
 [Tooltip("Determines the time in between shots")]
 [Range( 0f, 0.2f)]
 public float timeBetweenshots; //determines time in between shots
 [HideInInspector] float shotCounter; // timer of shots


 /// <summary>
 /// is the game currently paused?
 /// </summary>
 [Tooltip("is the game currently paused?")]
 public bool isPaused;


 /// <summary>
 /// is the game currently running?
 /// </summary>
 [Tooltip("is the game currently running?")]
 public bool isGamePlay; //Remove once object pooling is possible


 void Start()
 {
     rb = GetComponent<Rigidbody> ();
     //_controller = GetComponent<CharacterController>();
     //_PausedScript = GameObject.FindObjectOfType<Paused> ();
 }


 // ------- General Movement ------- //


 void DirectionMovement()
 {
     
     float horizontalMove = Input.GetAxisRaw ("Horizontal");
     float verticalMove = Input.GetAxisRaw ("Vertical");
 
     _Movement = new Vector3 (horizontalMove,0.0f,verticalMove);
 
     if (!SwitchMovement) 
     {
         if (_Movement != Vector3.zero) 
         {
             transform.rotation = Quaternion.Slerp (a: transform.rotation, b: Quaternion.LookRotation (_Movement), t: RotationSpeed * Time.deltaTime);
         }
         rb.MovePosition (transform.position + movementSpeed * Time.deltaTime * _Movement);
     } 
     else 
     {
         rb.MovePosition (transform.position + movementSpeed * Time.deltaTime * _Movement);
     }
 }


 // ------- Aiming Control type to switch on the fly ------- //


 void AimMovement()
 {
     _Rotation = new Vector3 (x: AimHori, y: 0.0f, z: AimVert);
 
     if (_Rotation != Vector3.zero) 
     {
         SwitchMovement = true;
         transform.rotation = Quaternion.Slerp (a: transform.rotation, b: Quaternion.LookRotation (_Rotation), t: RotationSpeed * Time.deltaTime);
     } 
     else 
     {
         SwitchMovement = false;
     }
 }


 // ------- new shooting type ------- //


 void Shoot()
 {
     if (isFiring && !isPaused) 
     {
         shotCounter -= Time.deltaTime;
         if (shotCounter <= 0) 
         {
             shotCounter = timeBetweenshots;
             BulletSpawned = Instantiate (Bullet.transform, bulletSpawnPoint.transform.position, Quaternion.identity);
             BulletSpawned.rotation = bulletSpawnPoint.transform.rotation;
         }
     } 
     else if (!isFiring && !isPaused)
     {
         shotCounter = 0;
     }

     if (Input.GetButton ("Fire"))
         isFiring = true;
     else 
         isFiring = false;
 }


 void Jump()
 {
     if (Input.GetButtonDown ("Jump") &&  (OnGround || MAX_JUMP > currentJump))
     {
         rb.AddForce (Vector3.up * jumpSpeed, ForceMode.Impulse);

         OnGround = false;
         currentJump++;
     }
 }


 void OnCollisionEnter (Collision _collision)
 {
     OnGround = true;
     currentJump = 0;
 }


 // Update is called once per frame
 void FixedUpdate () 
 {
     Shoot ();
     DirectionMovement ();
     AimMovement ();
     Jump ();
 }