Survival Shooter problems

First of all, when the game is paused I can still shoot once.

Second of all, i can't quit the application.

Third, I get this null reference error so the enemies cant run after me.

Fourth of all. few times the paused snapshots play when unpaused snapshots should play and few times the unpaused snapshots play when paused snapshots should.

Fifth, if the zombies get really close to me, I cant damage them.

Code:

Player health using UnityEngine; using UnityEngine.UI; using System.Collections;

 public class PlayerHealth : MonoBehaviour
 {
     public int startingHealth = 100;                            // The amount of health the player starts the game with.
     public int currentHealth;                                   // The current health the player has.
     public Slider healthSlider;                                 // Reference to the UI's health bar.
     public Image damageImage;                                   // Reference to an image to flash on the screen on being hurt.
     public AudioClip deathClip;                                 // The audio clip to play when the player dies.
     public float flashSpeed = 5f;                               // The speed the damageImage will fade at.
     public Color flashColour = new Color(1f, 0f, 0f, 0.1f);     // The colour the damageImage is set to, to flash.
 
 
     Animator anim;                                              // Reference to the Animator component.
     AudioSource playerAudio;                                    // Reference to the AudioSource component.
     PlayerMovement playerMovement;                              // Reference to the player's movement.
     PlayerShooting playerShooting;                              // Reference to the PlayerShooting script.
     bool isDead;                                                // Whether the player is dead.
     bool damaged;                                               // True when the player gets damaged.
 
 
     void Awake ()
     {
         // Setting up the references.
         anim = GetComponent <Animator> ();
         playerAudio = GetComponent <AudioSource> ();
         playerMovement = GetComponent <PlayerMovement> ();
         playerShooting = GetComponentInChildren <PlayerShooting> ();
 
         // Set the initial health of the player.
         currentHealth = startingHealth;
     }
 
 
     void Update ()
     {
         // If the player has just been damaged...
         if(damaged)
         {
             // ... set the colour of the damageImage to the flash colour.
             damageImage.color = flashColour;
         }
         // Otherwise...
         else
         {
             // ... transition the colour back to clear.
             damageImage.color = Color.Lerp (damageImage.color, Color.clear, flashSpeed * Time.deltaTime);
         }
 
         // Reset the damaged flag.
         damaged = false;
     }
 
 
     public void TakeDamage (int amount)
     {
         // Set the damaged flag so the screen will flash.
         damaged = true;
 
         // Reduce the current health by the damage amount.
         currentHealth -= amount;
 
         // Set the health bar's value to the current health.
         healthSlider.value = currentHealth;
 
         // Play the hurt sound effect.
         playerAudio.Play ();
 
         // If the player has lost all it's health and the death flag hasn't been set yet...
         if(currentHealth <= 0 && !isDead)
         {
             // ... it should die.
             Death ();
         }
     }
 
 
     void Death ()
     {
         // Set the death flag so this function won't be called again.
         isDead = true;
 
         // Turn off any remaining shooting effects.
         playerShooting.DisableEffects ();
 
         // Tell the animator that the player is dead.
         anim.SetTrigger ("Die");
 
         // Set the audiosource to play the death clip and play it (this will stop the hurt sound from playing).
         playerAudio.clip = deathClip;
         playerAudio.Play ();
 
         // Turn off the movement and shooting scripts.
         playerMovement.enabled = false;
         playerShooting.enabled = false;
     }       
 }

player movement

 using UnityEngine;
 
 public class PlayerMovement : MonoBehaviour
 {
     public float speed = 6f;
     Vector3 movement;
     Animator anim;
     Rigidbody playerRigidbody;
     int floorMask;
     float camRayLength = 100f;
 
     void Awake()
     {
         floorMask = LayerMask.GetMask("Floor");
         anim = GetComponent<Animator>();
         playerRigidbody = GetComponent<Rigidbody>();
     }
 
     void FixedUpdate()
     {
         float h = Input.GetAxisRaw("Horizontal"), v = Input.GetAxisRaw("Vertical");
         Move(h, v);
         Turning();
         Animating(h, v);
     }
     void Move(float h, float v)
     {
         movement.Set(h, 0f, v);
         movement = movement.normalized * speed * Time.deltaTime;
         playerRigidbody.MovePosition(transform.position + movement);
        
     }
 
     void Turning()
     {
         Ray camRay = Camera.main.ScreenPointToRay(Input.mousePosition);
         RaycastHit floorHit;
 
         if (Physics.Raycast(camRay, out floorHit, camRayLength, floorMask))
         {
             Vector3 playerToMouse = floorHit.point - transform.position;
             playerToMouse.y = 0f;
 
             Quaternion newRotation = Quaternion.LookRotation(playerToMouse);
             playerRigidbody.MoveRotation(newRotation);
         }
     }
 
     void Animating(float h, float v)
     {
         bool walking = h != 0 || v != 0;
         anim.SetBool("IsWalking", walking);
     }
 }
 

player shooting

 using UnityEngine;
 
 public class PlayerShooting : MonoBehaviour
 {
     public int damagePerShot = 20;                  // The damage inflicted by each bullet.
     public float timeBetweenBullets = 0.15f;        // The time between each shot.
     public float range = 100f;                      // The distance the gun can fire.
 
     float timer;                                    // A timer to determine when to fire.
     Ray shootRay;                                   // A ray from the gun end forwards.
     RaycastHit shootHit;                            // A raycast hit to get information about what was hit.
     int shootableMask;                              // A layer mask so the raycast only hits things on the shootable layer.
     ParticleSystem gunParticles;                    // Reference to the particle system.
     LineRenderer gunLine;                           // Reference to the line renderer.
     AudioSource gunAudio;                           // Reference to the audio source.
     Light gunLight;                                 // Reference to the light component.
     float effectsDisplayTime = 0.2f;                // The proportion of the timeBetweenBullets that the effects will display for.
 
     void Awake ()
     {
         // Create a layer mask for the Shootable layer.
         shootableMask = LayerMask.GetMask ("Shootable");
 
         // Set up the references.
         gunParticles = GetComponent<ParticleSystem> ();
         gunLine = GetComponent <LineRenderer> ();
         gunAudio = GetComponent<AudioSource> ();
         gunLight = GetComponent<Light> ();
     }
 
     void Update ()
     {
         // Add the time since Update was last called to the timer.
         timer += Time.deltaTime;
 
         // If the Fire1 button is being press and it's time to fire...
         if(Input.GetButton ("Fire1") && timer >= timeBetweenBullets)
         {
             // ... shoot the gun.
             Shoot ();
         }
 
         // If the timer has exceeded the proportion of timeBetweenBullets that the effects should be displayed for...
         if(timer >= timeBetweenBullets * effectsDisplayTime)
         {
             // ... disable the effects.
             DisableEffects ();
         }
     }
 
     public void DisableEffects ()
     {
         // Disable the line renderer and the light.
         gunLine.enabled = false;
         gunLight.enabled = false;
     }
 
     void Shoot ()
     {
         // Reset the timer.
         timer = 0f;
 
         // Play the gun shot audioclip.
         gunAudio.Play ();
 
         // Enable the light.
         gunLight.enabled = true;
 
         // Stop the particles from playing if they were, then start the particles.
         gunParticles.Stop ();
         gunParticles.Play ();
 
         // Enable the line renderer and set it's first position to be the end of the gun.
         gunLine.enabled = true;
         gunLine.SetPosition (0, transform.position);
 
         // Set the shootRay so that it starts at the end of the gun and points forward from the barrel.
         shootRay.origin = transform.position;
         shootRay.direction = transform.forward;
 
         // Perform the raycast against gameobjects on the shootable layer and if it hits something...
         if(Physics.Raycast (shootRay, out shootHit, range, shootableMask))
         {
             // Try and find an EnemyHealth script on the gameobject hit.
             EnemyHealth enemyHealth = shootHit.collider.GetComponent <EnemyHealth> ();
 
             // If the EnemyHealth component exist...
             if(enemyHealth != null)
             {
                 // ... the enemy should take damage.
                 enemyHealth.TakeDamage (damagePerShot, shootHit.point);
             }
 
             // Set the second position of the line renderer to the point the raycast hit.
             gunLine.SetPosition (1, shootHit.point);
         }
         // If the raycast didn't hit anything on the shootable layer...
         else
         {
             // ... set the second position of the line renderer to the fullest extent of the gun's range.
             gunLine.SetPosition (1, shootRay.origin + shootRay.direction * range);
         }
     }
 }

score manager

 using UnityEngine;
 using UnityEngine.UI;
 using System.Collections;
 
 public class ScoreManager : MonoBehaviour
 {
     public static int score;        // The player's score.
 
 
     Text text;                      // Reference to the Text component.
 
 
     void Awake ()
     {
         // Set up the reference.
         text = GetComponent <Text> ();
 
         // Reset the score.
         score = 0;
     }
 
 
     void Update ()
     {
         // Set the displayed text to be the word "Score" followed by the score value.
         text.text = "Score: " + score;
     }
 }

mix levels

 using UnityEngine;
 using System.Collections;
 using UnityEngine.Audio;
 
 public class MixTheLevels : MonoBehaviour {
 
     public AudioMixer masterMixer;
     
     public void SetSfxLvl(float sfxLevel)
     {
         masterMixer.SetFloat("sfxVol", sfxLevel);
     }
 
     public void SetMusicLvl(float musicLevel)
     {
         masterMixer.SetFloat("musicVol", musicLevel);
     }
 }

game over

 using UnityEngine;
 using UnityEngine.SceneManagement;
 
 public class GameOverManager : MonoBehaviour
 {
     public PlayerHealth playerHealth;       // Reference to the player's health.
     public float restartDelay = 5f;         // Time to wait before restarting the level
 
 
     Animator anim;                          // Reference to the animator component.
     float restartTimer;                     // Timer to count up to restarting the level
 
 
     void Awake ()
     {
         // Set up the reference.
         anim = GetComponent <Animator> ();
     }
 
 
     void Update ()
     {
         // If the player has run out of health...
         if(playerHealth.currentHealth <= 0)
         {
             // ... tell the animator the game is over.
             anim.SetTrigger ("GameOver");
 
             // .. increment a timer to count up to restarting.
             restartTimer += Time.deltaTime;
 
             // .. if it reaches the restart delay...
             if(restartTimer >= restartDelay)
             {
                 // .. then reload the currently loaded level.
                 SceneManager.LoadScene(1);
             }
         }
     }
 }

enemy manager

 using UnityEngine;
 
 public class EnemyManager : MonoBehaviour
 {
     public PlayerHealth playerHealth;       // Reference to the player's heatlh.
     public GameObject enemy;                // The enemy prefab to be spawned.
     public float spawnTime = 3f;            // How long between each spawn.
     public Transform[] spawnPoints;         // An array of the spawn points this enemy can spawn from.
 
 
     void Start ()
     {
         // Call the Spawn function after a delay of the spawnTime and then continue to call after the same amount of time.
         InvokeRepeating ("Spawn", spawnTime, spawnTime);
     }
 
 
     void Spawn ()
     {
         // If the player has no health left...
         if(playerHealth.currentHealth <= 0f)
         {
             // ... exit the function.
             return;
         }
 
         // Find a random index between zero and one less than the number of spawn points.
         int spawnPointIndex = Random.Range (0, spawnPoints.Length);
 
         // Create an instance of the enemy prefab at the randomly selected spawn point's position and rotation.
         Instantiate (enemy, spawnPoints[spawnPointIndex].position, spawnPoints[spawnPointIndex].rotation);
     }
 }

enemy movement

using UnityEngine; using System.Collections;

public class EnemyMovement : MonoBehaviour { Transform player; // Reference to the player's position. PlayerHealth playerHealth; // Reference to the player's health. EnemyHealth enemyHealth; // Reference to this enemy's health. NavMeshAgent nav; // Reference to the nav mesh agent.

 void Awake()
 {
     // Set up the references.
     player = GameObject.FindGameObjectWithTag("Player").transform;
     playerHealth = player.GetComponent<PlayerHealth>();
     enemyHealth = GetComponent<EnemyHealth>();
     nav = GetComponent<NavMeshAgent>();
 }


 void Update()
 {
     Debug.Log (player.transform.position);
     // If the enemy and the player have health left...
     if (enemyHealth.currentHealth > 0 && playerHealth.currentHealth > 0)
     {
         // ... set the destination of the nav mesh agent to the player.
         nav.SetDestination(player.position);
     }
     // Otherwise...
     else
     {
         // ... disable the nav mesh agent.
         nav.enabled = false;
     }
 }

}

enemy health

 using UnityEngine;
 
 public class EnemyHealth : MonoBehaviour
 {
     public int startingHealth = 100;          // The amount of health the enemy starts the game with.
     public int currentHealth;                    // The current health the enemy has.
     public float sinkSpeed = 2.5f;           // The speed at which the enemy sinks through the floor when dead.
     public int scoreValue = 10;               // The amount added to the player's score when the enemy dies.
     public AudioClip deathClip;              // The sound to play when the enemy dies.
 
     Animator anim;                              // Reference to the animator.
     AudioSource enemyAudio;              // Reference to the audio source.
     ParticleSystem hitParticles;             // Reference to the particle system that plays when the enemy is damaged.
     CapsuleCollider capsuleCollider;     // Reference to the capsule collider.
     bool isDead;                                  // Whether the enemy is dead.
     bool isSinking;                               // Whether the enemy has started sinking through the floor.
 
     void Awake ()
     {
         // Setting up the references.
         anim = GetComponent <Animator> ();
         enemyAudio = GetComponent <AudioSource> ();
         hitParticles = GetComponentInChildren <ParticleSystem> ();
         capsuleCollider = GetComponent <CapsuleCollider> ();
 
         // Setting the current health when the enemy first spawns.
         currentHealth = startingHealth;
     }
 
     void Update ()
     {
         // If the enemy should be sinking...
         if(isSinking)
         {
             // ... move the enemy down by the sinkSpeed per second.
             transform.Translate (-Vector3.up * sinkSpeed * Time.deltaTime);
         }
     }

enemy attack using UnityEngine; using System.Collections;

public class EnemyAttack : MonoBehaviour { public float timeBetweenAttacks = 0.5f; // The time in seconds between each attack. public int attackDamage = 10; // The amount of health taken away per attack.

 Animator anim;                              // Reference to the animator component.
 GameObject player;                          // Reference to the player GameObject.
 PlayerHealth playerHealth;                  // Reference to the player's health.
 EnemyHealth enemyHealth;                    // Reference to this enemy's health.
 bool playerInRange;                         // Whether player is within the trigger collider and can be attacked.
 float timer;                                // Timer for counting up to the next attack.


 void Awake()
 {
     // Setting up the references.
     player = GameObject.FindGameObjectWithTag("Player");
     playerHealth = player.GetComponent<PlayerHealth>();
     enemyHealth = GetComponent<EnemyHealth>();
     anim = GetComponent<Animator>();
 }


 void OnTriggerEnter(Collider other)
 {
     // If the entering collider is the player...
     if (other.gameObject == player)
     {
         // ... the player is in range.
         playerInRange = true;
     }
 }


 void OnTriggerExit(Collider other)
 {
     // If the exiting collider is the player...
     if (other.gameObject == player)
     {
         // ... the player is no longer in range.
         playerInRange = false;
     }
 }


 void Update()
 {
     // Add the time since Update was last called to the timer.
     timer += Time.deltaTime;

     // If the timer exceeds the time between attacks, the player is in range and this enemy is alive...
     if (timer >= timeBetweenAttacks && playerInRange && enemyHealth.currentHealth > 0)
     {
         // ... attack.
         Attack();
     }

     // If the player has zero or less health...
     if (playerHealth.currentHealth <= 0)
     {
         // ... tell the animator the player is dead.
         anim.SetTrigger("PlayerDead");
     }
 }


 void Attack()
 {
     // Reset the timer.
     timer = 0f;

     // If the player has health to lose...
     if (playerHealth.currentHealth > 0)
     {
         // ... damage the player.
         playerHealth.TakeDamage(attackDamage);
     }
 }

}

camera follow

 using UnityEngine;
 using System.Collections;
 
 public class CameraFollow : MonoBehaviour
 {
     public Transform target;
     public float smoothing = 5f;
 
     Vector3 offset;
 
     void Start()
     {
         offset = transform.position - target.position;
 
     }
 
     void FixedUpdate()
     {
         Vector3 targetCamPos = target.position + offset;
         transform.position = Vector3.Lerp(transform.position, targetCamPos, smoothing * Time.deltaTime);
 
     }
 }