how to upgrate this script to damaging

I have scripts about fps game. But I dont know how to make damaging) using UnityEngine; using System.Collections; //using UnityStandardAssets.ImageEffects;

 public enum GunStyles{
     nonautomatic,automatic
 }
 public class GunScript : MonoBehaviour {
     [Tooltip("Selects type of waepon to shoot rapidly or one bullet per click.")]
     public GunStyles currentStyle;
     [HideInInspector]
     public MouseLookScript mls;
 
     [Header("Player movement properties")]
     [Tooltip("Speed is determined via gun because not every gun has same properties or weights so you MUST set up your speeds here")]
     public int walkingSpeed = 3;
     [Tooltip("Speed is determined via gun because not every gun has same properties or weights so you MUST set up your speeds here")]
     public int runningSpeed = 5;
 
 
     [Header("Bullet properties")]
     [Tooltip("Preset value to tell with how many bullets will our waepon spawn aside.")]
     public float bulletsIHave = 20;
     [Tooltip("Preset value to tell with how much bullets will our waepon spawn inside rifle.")]
     public float bulletsInTheGun = 5;
     [Tooltip("Preset value to tell how much bullets can one magazine carry.")]
     public float amountOfBulletsPerLoad = 5;
 
     private Transform player;
     private Camera cameraComponent;
     private Transform gunPlaceHolder;
 
     private PlayerMovementScript pmS;
 
     /*
      * Collection the variables upon awake that we need.
      */
     void Awake(){
 
 
         mls = GameObject.FindGameObjectWithTag("Player").GetComponent<MouseLookScript>();
         player = mls.transform;
         mainCamera = mls.myCamera;
         secondCamera = GameObject.FindGameObjectWithTag("SecondCamera").GetComponent<Camera>();
         cameraComponent = mainCamera.GetComponent<Camera>();
         pmS = player.GetComponent<PlayerMovementScript>();
 
         bulletSpawnPlace = GameObject.FindGameObjectWithTag("BulletSpawn");
         hitMarker = transform.Find ("hitMarkerSound").GetComponent<AudioSource> ();
 
         startLook = mouseSensitvity_notAiming;
         startAim = mouseSensitvity_aiming;
         startRun = mouseSensitvity_running;
 
         rotationLastY = mls.currentYRotation;
         rotationLastX= mls.currentCameraXRotation;
 
     }
 
 
     [HideInInspector]
     public Vector3 currentGunPosition;
     [Header("Gun Positioning")]
     [Tooltip("Vector 3 position from player SETUP for NON AIMING values")]
     public Vector3 restPlacePosition;
     [Tooltip("Vector 3 position from player SETUP for AIMING values")]
     public Vector3 aimPlacePosition;
     [Tooltip("Time that takes for gun to get into aiming stance.")]
     public float gunAimTime = 0.1f;
 
     [HideInInspector]
     public bool reloading;
 
     private Vector3 gunPosVelocity;
     private float cameraZoomVelocity;
     private float secondCameraZoomVelocity;
 
     private Vector2 gunFollowTimeVelocity;
 
     /*
     Update loop calling for methods that are descriped below where they are initiated.
     */
     void Update(){
 
         Animations();
 
         GiveCameraScriptMySensitvity();
 
         PositionGun();
 
         Shooting();
         MeeleAttack();
         LockCameraWhileMelee ();
 
         Sprint(); //iff we have the gun you sprint from here, if we are gunless then its called from movement script
 
         CrossHairExpansionWhenWalking();
 
 
     }
 
     /*
     *Update loop calling for methods that are descriped below where they are initiated.
     *+
     *Calculation of weapon position when aiming or not aiming.
     */
     void FixedUpdate(){
         RotationGun ();
 
         MeeleAnimationsStates ();
 
         /*
          * Changing some values if we are aiming, like sensitity, zoom racion and position of the waepon.
          */
         //if aiming
         if(Input.GetAxis("Fire2") != 0 && !reloading && !meeleAttack){
             gunPrecision = gunPrecision_aiming;
             recoilAmount_x = recoilAmount_x_;
             recoilAmount_y = recoilAmount_y_;
             recoilAmount_z = recoilAmount_z_;
             currentGunPosition = Vector3.SmoothDamp(currentGunPosition, aimPlacePosition, ref gunPosVelocity, gunAimTime);
             cameraComponent.fieldOfView = Mathf.SmoothDamp(cameraComponent.fieldOfView, cameraZoomRatio_aiming, ref cameraZoomVelocity, gunAimTime);
             secondCamera.fieldOfView = Mathf.SmoothDamp(secondCamera.fieldOfView, secondCameraZoomRatio_aiming, ref secondCameraZoomVelocity, gunAimTime);
         }
         //if not aiming
         else{
             gunPrecision = gunPrecision_notAiming;
             recoilAmount_x = recoilAmount_x_non;
             recoilAmount_y = recoilAmount_y_non;
             recoilAmount_z = recoilAmount_z_non;
             currentGunPosition = Vector3.SmoothDamp(currentGunPosition, restPlacePosition, ref gunPosVelocity, gunAimTime);
             cameraComponent.fieldOfView = Mathf.SmoothDamp(cameraComponent.fieldOfView, cameraZoomRatio_notAiming, ref cameraZoomVelocity, gunAimTime);
             secondCamera.fieldOfView = Mathf.SmoothDamp(secondCamera.fieldOfView, secondCameraZoomRatio_notAiming, ref secondCameraZoomVelocity, gunAimTime);
         }
 
     }
 
     [Header("Sensitvity of the gun")]
     [Tooltip("Sensitvity of this gun while not aiming.")]
     public float mouseSensitvity_notAiming = 10;
     //[HideInInspector]
     [Tooltip("Sensitvity of this gun while aiming.")]
     public float mouseSensitvity_aiming = 5;
     //[HideInInspector]
     [Tooltip("Sensitvity of this gun while running.")]
     public float mouseSensitvity_running = 4;
     /*
      * Used to give our main camera different sensivity options for each gun.
      */
     void GiveCameraScriptMySensitvity(){
         mls.mouseSensitvity_notAiming = mouseSensitvity_notAiming;
         mls.mouseSensitvity_aiming = mouseSensitvity_aiming;
     }
 
     /*
      * Used to expand position of the crosshair or make it dissapear when running
      */
     void CrossHairExpansionWhenWalking(){
 
         if(player.GetComponent<Rigidbody>().velocity.magnitude > 1 && Input.GetAxis("Fire1") == 0){//ifnot shooting
 
             expandValues_crosshair += new Vector2(20, 40) * Time.deltaTime;
             if(player.GetComponent<PlayerMovementScript>().maxSpeed < runningSpeed){ //not running
                 expandValues_crosshair = new Vector2(Mathf.Clamp(expandValues_crosshair.x, 0, 10), Mathf.Clamp(expandValues_crosshair.y,0,20));
                 fadeout_value = Mathf.Lerp(fadeout_value, 1, Time.deltaTime * 2);
             }
             else{//running
                 fadeout_value = Mathf.Lerp(fadeout_value, 0, Time.deltaTime * 10);
                 expandValues_crosshair = new Vector2(Mathf.Clamp(expandValues_crosshair.x, 0, 20), Mathf.Clamp(expandValues_crosshair.y,0,40));
             }
         }
         else{//if shooting
             expandValues_crosshair = Vector2.Lerp(expandValues_crosshair, Vector2.zero, Time.deltaTime * 5);
             expandValues_crosshair = new Vector2(Mathf.Clamp(expandValues_crosshair.x, 0, 10), Mathf.Clamp(expandValues_crosshair.y,0,20));
             fadeout_value = Mathf.Lerp(fadeout_value, 1, Time.deltaTime * 2);
 
         }
 
     }
 
     /* 
      * Changes the max speed that player is allowed to go.
      * Also max speed is connected to the animator which will trigger the run animation.
      */
     void Sprint(){// Running();  so i can find it with CTRL + F
         if (Input.GetAxis ("Vertical") > 0 && Input.GetAxisRaw ("Fire2") == 0 && meeleAttack == false && Input.GetAxisRaw ("Fire1") == 0) {
             if (Input.GetKeyDown (KeyCode.LeftShift)) {
                 if (pmS.maxSpeed == walkingSpeed) {
                     pmS.maxSpeed = runningSpeed;//sets player movement peed to max
 
                 } else {
                     pmS.maxSpeed = walkingSpeed;
                 }
             }
         } else {
             pmS.maxSpeed = walkingSpeed;
         }
 
     }
 
     [HideInInspector]
     public bool meeleAttack;
     [HideInInspector]
     public bool aiming;
     /*
      * Checking if meeleAttack is already running.
      * If we are not reloading we can trigger the MeeleAttack animation from the IENumerator.
      */
     void MeeleAnimationsStates(){
         if (handsAnimator) {
             meeleAttack = handsAnimator.GetCurrentAnimatorStateInfo (0).IsName (meeleAnimationName);
             aiming = handsAnimator.GetCurrentAnimatorStateInfo (0).IsName (aimingAnimationName);    
         }
     }
     /*
     * User inputs meele attack with Q in keyboard start the coroutine for animation and damage attack.
     */
     void MeeleAttack(){    
 
         if(Input.GetKeyDown(KeyCode.Q) && !meeleAttack){            
             StartCoroutine("AnimationMeeleAttack");
         }
     }
     /*
     * Sets meele animation to play.
     */
     IEnumerator AnimationMeeleAttack(){
         handsAnimator.SetBool("meeleAttack",true);
         //yield return new WaitForEndOfFrame();
         yield return new WaitForSeconds(0.1f);
         handsAnimator.SetBool("meeleAttack",false);
     }
 
     private float startLook, startAim, startRun;
     /*
     * Setting the mouse sensitvity lower when meele attack and waits till it ends.
     */
     void LockCameraWhileMelee(){
         if (meeleAttack) {
             mouseSensitvity_notAiming = 2;
             mouseSensitvity_aiming = 1.6f;
             mouseSensitvity_running = 1;
         } else {
             mouseSensitvity_notAiming = startLook;
             mouseSensitvity_aiming = startAim;
             mouseSensitvity_running = startRun;
         }
     }
 
 
     private Vector3 velV;
     [HideInInspector]
     public Transform mainCamera;
     private Camera secondCamera;
     /*
      * Calculatin the weapon position accordingly to the player position and rotation.
      * After calculation the recoil amount are decreased to 0.
      */
     void PositionGun(){
         transform.position = Vector3.SmoothDamp(transform.position,
             mainCamera.transform.position  - 
             (mainCamera.transform.right * (currentGunPosition.x + currentRecoilXPos)) + 
             (mainCamera.transform.up * (currentGunPosition.y+ currentRecoilYPos)) + 
             (mainCamera.transform.forward * (currentGunPosition.z + currentRecoilZPos)),ref velV, 0);
 
 
 
         pmS.cameraPosition = new Vector3(currentRecoilXPos,currentRecoilYPos, 0);
 
         currentRecoilZPos = Mathf.SmoothDamp(currentRecoilZPos, 0, ref velocity_z_recoil, recoilOverTime_z);
         currentRecoilXPos = Mathf.SmoothDamp(currentRecoilXPos, 0, ref velocity_x_recoil, recoilOverTime_x);
         currentRecoilYPos = Mathf.SmoothDamp(currentRecoilYPos, 0, ref velocity_y_recoil, recoilOverTime_y);
 
     }
 
 
     [Header("Rotation")]
     private Vector2 velocityGunRotate;
     private float gunWeightX,gunWeightY;
     [Tooltip("The time waepon will lag behind the camera view best set to '0'.")]
     public float rotationLagTime = 0f;
     private float rotationLastY;
     private float rotationDeltaY;
     private float angularVelocityY;
     private float rotationLastX;
     private float rotationDeltaX;
     private float angularVelocityX;
     [Tooltip("Value of forward rotation multiplier.")]
     public Vector2 forwardRotationAmount = Vector2.one;
     /*
     * Rotatin the weapon according to mouse look rotation.
     * Calculating the forawrd rotation like in Call Of Duty weapon weight
     */
     void RotationGun(){
 
         rotationDeltaY = mls.currentYRotation - rotationLastY;
         rotationDeltaX = mls.currentCameraXRotation - rotationLastX;
 
         rotationLastY= mls.currentYRotation;
         rotationLastX= mls.currentCameraXRotation;
 
         angularVelocityY = Mathf.Lerp (angularVelocityY, rotationDeltaY, Time.deltaTime * 5);
         angularVelocityX = Mathf.Lerp (angularVelocityX, rotationDeltaX, Time.deltaTime * 5);
 
         gunWeightX = Mathf.SmoothDamp (gunWeightX, mls.currentCameraXRotation, ref velocityGunRotate.x, rotationLagTime);
         gunWeightY = Mathf.SmoothDamp (gunWeightY, mls.currentYRotation, ref velocityGunRotate.y, rotationLagTime);
 
         transform.rotation = Quaternion.Euler (gunWeightX + (angularVelocityX*forwardRotationAmount.x), gunWeightY + (angularVelocityY*forwardRotationAmount.y), 0);
     }
 
     private float currentRecoilZPos;
     private float currentRecoilXPos;
     private float currentRecoilYPos;
     /*
      * Called from ShootMethod();, upon shooting the recoil amount will increase.
      */
     public void RecoilMath(){
         currentRecoilZPos -= recoilAmount_z;
         currentRecoilXPos -= (Random.value - 0.5f) * recoilAmount_x;
         currentRecoilYPos -= (Random.value - 0.5f) * recoilAmount_y;
         mls.wantedCameraXRotation -= Mathf.Abs(currentRecoilYPos * gunPrecision);
         mls.wantedYRotation -= (currentRecoilXPos * gunPrecision);         
 
         expandValues_crosshair += new Vector2(6,12);
 
     }
 
     [Header("Shooting setup - MUSTDO")]
     [HideInInspector] public GameObject bulletSpawnPlace;
     [Tooltip("Bullet prefab that this waepon will shoot.")]
     public GameObject bullet;
     [Tooltip("Rounds per second if weapon is set to automatic rafal.")]
     public float roundsPerSecond;
     private float waitTillNextFire;
     /*
      * Checking if the gun is automatic or nonautomatic and accordingly runs the ShootMethod();.
      */
     void Shooting(){
 
         if (!meeleAttack) {
             if (currentStyle == GunStyles.nonautomatic) {
                 if (Input.GetButtonDown ("Fire1")) {
                     ShootMethod ();
                 }
             }
             if (currentStyle == GunStyles.automatic) {
                 if (Input.GetButton ("Fire1")) {
                     ShootMethod ();
                 }
             }
         }
         waitTillNextFire -= roundsPerSecond * Time.deltaTime;
     }
 
 
     [HideInInspector]    public float recoilAmount_z = 0.5f;
     [HideInInspector]    public float recoilAmount_x = 0.5f;
     [HideInInspector]    public float recoilAmount_y = 0.5f;
     [Header("Recoil Not Aiming")]
     [Tooltip("Recoil amount on that AXIS while NOT aiming")]
     public float recoilAmount_z_non = 0.5f;
     [Tooltip("Recoil amount on that AXIS while NOT aiming")]
     public float recoilAmount_x_non = 0.5f;
     [Tooltip("Recoil amount on that AXIS while NOT aiming")]
     public float recoilAmount_y_non = 0.5f;
     [Header("Recoil Aiming")]
     [Tooltip("Recoil amount on that AXIS while aiming")]
     public float recoilAmount_z_ = 0.5f;
     [Tooltip("Recoil amount on that AXIS while aiming")]
     public float recoilAmount_x_ = 0.5f;
     [Tooltip("Recoil amount on that AXIS while aiming")]
     public float recoilAmount_y_ = 0.5f;
     [HideInInspector]public float velocity_z_recoil,velocity_x_recoil,velocity_y_recoil;
     [Header("")]
     [Tooltip("The time that takes weapon to get back on its original axis after recoil.(The smaller number the faster it gets back to original position)")]
     public float recoilOverTime_z = 0.5f;
     [Tooltip("The time that takes weapon to get back on its original axis after recoil.(The smaller number the faster it gets back to original position)")]
     public float recoilOverTime_x = 0.5f;
     [Tooltip("The time that takes weapon to get back on its original axis after recoil.(The smaller number the faster it gets back to original position)")]
     public float recoilOverTime_y = 0.5f;
 
     [Header("Gun Precision")]
     [Tooltip("Gun rate precision when player is not aiming. THis is calculated with recoil.")]
     public float gunPrecision_notAiming = 200.0f;
     [Tooltip("Gun rate precision when player is aiming. THis is calculated with recoil.")]
     public float gunPrecision_aiming = 100.0f;
     [Tooltip("FOV of first camera when NOT aiming(ONLY SECOND CAMERA RENDERS WEAPONS")]
     public float cameraZoomRatio_notAiming = 60;
     [Tooltip("FOV of first camera when aiming(ONLY SECOND CAMERA RENDERS WEAPONS")]
     public float cameraZoomRatio_aiming = 40;
     [Tooltip("FOV of second camera when NOT aiming(ONLY SECOND CAMERA RENDERS WEAPONS")]
     public float secondCameraZoomRatio_notAiming = 60;
     [Tooltip("FOV of second camera when aiming(ONLY SECOND CAMERA RENDERS WEAPONS")]
     public float secondCameraZoomRatio_aiming = 40;
     [HideInInspector]
     public float gunPrecision;
 
     [Tooltip("Audios for shootingSound, and reloading.")]
     public AudioSource shoot_sound_source, reloadSound_source;
     [Tooltip("Sound that plays after successful attack bullet hit.")]
     public static AudioSource hitMarker;
 
     /*
     * Sounds that is called upon hitting the target.
     */
     public static void HitMarkerSound(){
         hitMarker.Play();
     }
 
     [Tooltip("Array of muzzel flashes, randmly one will appear after each bullet.")]
     public GameObject[] muzzelFlash;
     [Tooltip("Place on the gun where muzzel flash will appear.")]
     public GameObject muzzelSpawn;
     private GameObject holdFlash;
     private GameObject holdSmoke;
     /*
      * Called from Shooting();
      * Creates bullets and muzzle flashes and calls for Recoil.
      */
     private void ShootMethod(){
         if(waitTillNextFire <= 0 && !reloading && pmS.maxSpeed < 5){
 
             if(bulletsInTheGun > 0){
 
                 int randomNumberForMuzzelFlash = Random.Range(0,5);
                 if (bullet)
                     Instantiate (bullet, bulletSpawnPlace.transform.position, bulletSpawnPlace.transform.rotation);
                 else
                     print ("Missing the bullet prefab");
                 holdFlash = Instantiate(muzzelFlash[randomNumberForMuzzelFlash], muzzelSpawn.transform.position /*- muzzelPosition*/, muzzelSpawn.transform.rotation * Quaternion.Euler(0,0,90) ) as GameObject;
                 holdFlash.transform.parent = muzzelSpawn.transform;
                 if (shoot_sound_source)
                     shoot_sound_source.Play ();
                 else
                     print ("Missing 'Shoot Sound Source'.");
 
                 RecoilMath();
 
                 waitTillNextFire = 1;
                 bulletsInTheGun -= 1;
             }
                 
             else{
                 //if(!aiming)
                 StartCoroutine("Reload_Animation");
                 //if(emptyClip_sound_source)
                 //    emptyClip_sound_source.Play();
             }
 
         }
 
     }
 
 
 
     /*
     * Reloading, setting the reloading to animator,
     * Waiting for 2 seconds and then seeting the reloaded clip.
     */
     [Header("reload time after anima")]
     [Tooltip("Time that passes after reloading. Depends on your reload animation length, because reloading can be interrupted via meele attack or running. So any action before this finishes will interrupt reloading.")]
     public float reloadChangeBulletsTime;
     IEnumerator Reload_Animation(){
         if(bulletsIHave > 0 && bulletsInTheGun < amountOfBulletsPerLoad && !reloading/* && !aiming*/){
 
             if (reloadSound_source.isPlaying == false && reloadSound_source != null) {
                 if (reloadSound_source)
                     reloadSound_source.Play ();
                 else
                     print ("'Reload Sound Source' missing.");
             }
         
 
             handsAnimator.SetBool("reloading",true);
             yield return new WaitForSeconds(0.5f);
             handsAnimator.SetBool("reloading",false);
 
 
 
             yield return new WaitForSeconds (reloadChangeBulletsTime - 0.5f);//minus ovo vrijeme cekanja na yield
             if (meeleAttack == false && pmS.maxSpeed != runningSpeed) {
                 //print ("tu sam");
                 if (player.GetComponent<PlayerMovementScript> ()._freakingZombiesSound)
                     player.GetComponent<PlayerMovementScript> ()._freakingZombiesSound.Play ();
                 else
                     print ("Missing Freaking Zombies Sound");
                 
                 if (bulletsIHave - amountOfBulletsPerLoad >= 0) {
                     bulletsIHave -= amountOfBulletsPerLoad - bulletsInTheGun;
                     bulletsInTheGun = amountOfBulletsPerLoad;
                 } else if (bulletsIHave - amountOfBulletsPerLoad < 0) {
                     float valueForBoth = amountOfBulletsPerLoad - bulletsInTheGun;
                     if (bulletsIHave - valueForBoth < 0) {
                         bulletsInTheGun += bulletsIHave;
                         bulletsIHave = 0;
                     } else {
                         bulletsIHave -= valueForBoth;
                         bulletsInTheGun += valueForBoth;
                     }
                 }
             } else {
                 reloadSound_source.Stop ();
 
                 print ("Reload interrupted via meele attack");
             }
 
         }
     }
 
     /*
      * Setting the number of bullets to the hud UI gameobject if there is one.
      * And drawing CrossHair from here.
      */
     [Tooltip("HUD bullets to display bullet count on screen. Will be find under name 'HUD_bullets' in scene.")]
     public TextMesh HUD_bullets;
     void OnGUI(){
         if(!HUD_bullets){
             try{
                 HUD_bullets = GameObject.Find("HUD_bullets").GetComponent<TextMesh>();
             }
             catch(System.Exception ex){
                 print("Couldnt find the HUD_Bullets ->" + ex.StackTrace.ToString());
             }
         }
         if(mls && HUD_bullets)
             HUD_bullets.text = bulletsIHave.ToString() + " - " + bulletsInTheGun.ToString();
 
         DrawCrosshair();
     }
 
     [Header("Crosshair properties")]
     public Texture horizontal_crosshair, vertical_crosshair;
     public Vector2 top_pos_crosshair, bottom_pos_crosshair, left_pos_crosshair, right_pos_crosshair;
     public Vector2 size_crosshair_vertical = new Vector2(1,1), size_crosshair_horizontal = new Vector2(1,1);
     [HideInInspector]
     public Vector2 expandValues_crosshair;
     private float fadeout_value = 1;
     /*
      * Drawing the crossHair.
      */
     void DrawCrosshair(){
         GUI.color = new Color(GUI.color.r, GUI.color.g, GUI.color.b, fadeout_value);
         if(Input.GetAxis("Fire2") == 0){//if not aiming draw
             GUI.DrawTexture(new Rect(vec2(left_pos_crosshair).x + position_x(-expandValues_crosshair.x) + Screen.width/2,Screen.height/2 + vec2(left_pos_crosshair).y, vec2(size_crosshair_horizontal).x, vec2(size_crosshair_horizontal).y), vertical_crosshair);//left
             GUI.DrawTexture(new Rect(vec2(right_pos_crosshair).x + position_x(expandValues_crosshair.x) + Screen.width/2,Screen.height/2 + vec2(right_pos_crosshair).y, vec2(size_crosshair_horizontal).x, vec2(size_crosshair_horizontal).y), vertical_crosshair);//right
 
             GUI.DrawTexture(new Rect(vec2(top_pos_crosshair).x + Screen.width/2,Screen.height/2 + vec2(top_pos_crosshair).y + position_y(-expandValues_crosshair.y), vec2(size_crosshair_vertical).x, vec2(size_crosshair_vertical).y ), horizontal_crosshair);//top
             GUI.DrawTexture(new Rect(vec2(bottom_pos_crosshair).x + Screen.width/2,Screen.height/2 +vec2(bottom_pos_crosshair).y + position_y(expandValues_crosshair.y), vec2(size_crosshair_vertical).x, vec2(size_crosshair_vertical).y), horizontal_crosshair);//bottom
         }
 
     }
 
     //#####        RETURN THE SIZE AND POSITION for GUI images ##################
     private float position_x(float var){
         return Screen.width * var / 100;
     }
     private float position_y(float var)
     {
         return Screen.height * var / 100;
     }
     private float size_x(float var)
     {
         return Screen.width * var / 100;
     }
     private float size_y(float var)
     {
         return Screen.height * var / 100;
     }
     private Vector2 vec2(Vector2 _vec2){
         return new Vector2(Screen.width * _vec2.x / 100, Screen.height * _vec2.y / 100);
     }
     //#
 
     public Animator handsAnimator;
     /*
     * Fetching if any current animation is running.
     * Setting the reload animation upon pressing R.
     */
     void Animations(){
 
         if(handsAnimator){
 
             reloading = handsAnimator.GetCurrentAnimatorStateInfo(0).IsName(reloadAnimationName);
 
             handsAnimator.SetFloat("walkSpeed",pmS.currentSpeed);
             handsAnimator.SetBool("aiming", Input.GetButton("Fire2"));
             handsAnimator.SetInteger("maxSpeed", pmS.maxSpeed);
             if(Input.GetKeyDown(KeyCode.R) && pmS.maxSpeed < 5 && !reloading && !meeleAttack/* && !aiming*/){
                 StartCoroutine("Reload_Animation");
             }
         }
 
     }
 
     [Header("Animation names")]
     public string reloadAnimationName = "Player_Reload";
     public string aimingAnimationName = "Player_AImpose";
     public string meeleAnimationName = "Character_Malee";
 }