PlayerHandler Unity C#

using UnityEngine;
using System.Collections;

public class PlayerHandler : Photon.MonoBehaviour {

    private float timer;
    private float startTime;
    public bool isBulletCollidable = false;
    private bool justCollided;
    private float playerHealth = 100f;
    private float shieldHealth = 100f;
    private GameObject overviewCamera;
    private float shieldTimer;
    private bool shieldDestroyed;

    public GameObject redShield;
    public GameObject myRedShield;
    public GameObject camera;
    private GameObject shieldSlider;
    public bool playerJustSpawned;
    public bool foundTarget;
    public float smoothing;
    public GameObject playerCamera;
    public float shieldRegenDelay = 2f;
    public float shieldRegenRate = 20f;
    public float shieldCooldownTimer = 3f;

    public bool playerIsMine = false;

    public GameObject GameScriptObject;
    public NetworkManager networkManager;

    private Vector3 offset;

    private Component playerScript;

    // Use this for initialization
    void Start ()
    {
        // Set if the spawned player is the client's player.
        playerIsMine = gameObject.GetComponent<PhotonView>().isMine;

        if(shieldSlider == null)
        {
            shieldSlider = GameObject.FindWithTag("ShieldSlider");
            Debug.Log(shieldSlider.ToString());
        }

        if(playerIsMine == true)
        {
            overviewCamera = GameObject.FindWithTag("OverviewCamera");
            if(overviewCamera == null)
            {
            }
            else
            {
                overviewCamera.SetActive(false);
            }
            GameScriptObject = GameObject.Find("_SCRIPTS");
            networkManager = GameScriptObject.GetComponent<NetworkManager>();
            foundTarget = false;
            playerJustSpawned = true;
            RespawnShield();
            shieldDestroyed = false;
            playerScript = gameObject.GetComponent<PlayerMovement>();
            SpawnCamera();
        }
    }

    // Update is called once per frame
    void Update ()
    {
        if(playerIsMine == false)
            return;
        //Shield Shiz ----------------------------------------------
        shieldTimer += Time.deltaTime;
        if(justCollided)
            shieldTimer = 0;
        if(shieldHealth < 100 && shieldDestroyed == false)
        {
            if(shieldTimer >= shieldRegenDelay)
            {
                shieldHealth += shieldRegenRate * Time.deltaTime;
                //shieldSlider.GetComponent<Slider>().value = shieldHealth;
                Debug.Log(shieldHealth.ToString());
            }
            if(shieldHealth >= 100f && timer > shieldRegenDelay)
            {
                shieldTimer = 0f;
                shieldHealth = 100f;
                Debug.Log("Shield Regenerated");
            }
        }

        if(shieldHealth < 0 && shieldDestroyed == false)
        {
            DestroyShield();
        }

        //End of Shield Shiz ---------------------------------------

        //----------------------------------------------------------
        timer += Time.deltaTime;
        if(justCollided && shieldDestroyed == true)
        {
            CancelInvoke();
            Invoke("ShieldRespawnCooldown", shieldCooldownTimer);
        }

        if(playerHealth <= 0)
        {
            KillPlayer();
        }
        // If i have a shield, turn off bullet collision bool
        if(shieldDestroyed = false && isBulletCollidable == true)
        {
            isBulletCollidable = false;
        }
        // Otherwise, turn on bullet collision
        else if(shieldDestroyed = true && isBulletCollidable == false)
        {
            isBulletCollidable = true;
        }

        // Turns on or off Player (layer 8) collision with Bullet (layer 9) Collision
        //Physics.IgnoreLayerCollision(8, 9, !isBulletCollidable);
    }

    void FixedUpdate()
    {
        if(playerIsMine == false)
            return;

        cameraFollow();
    }

    void LateUpdate()
    {
        if(playerIsMine == false)
            return;

        justCollided = false;
    }

    void ShieldRespawnCooldown()
    {
        Invoke("RespawnShieldLowHealth", shieldCooldownTimer);
    }

    void SpawnCamera()
    {
        playerCamera = GameObject.FindWithTag("MainCamera");
        if(playerCamera == null)
        {
            playerCamera = (GameObject)Instantiate(camera, new Vector3(transform.position.x, 16, transform.position.z), Quaternion.identity);
        }
        else
        {
            playerCamera.transform.position = new Vector3(transform.position.x, 16, transform.position.z);
        }
        offset = transform.position - playerCamera.transform.position;
        playerCamera.transform.LookAt(Vector3.down);
    }

    void cameraFollow()
    {
        playerCamera.transform.position = Vector3.Slerp(playerCamera.transform.position, transform.position - offset,
                                                  smoothing * Time.deltaTime);
    }

    void RespawnShield()
    {
        if(playerIsMine)
        {
            foreach(Transform child in transform)
            {
                if(child.gameObject.tag == "Shield")
                    myRedShield = child.gameObject; //(GameObject) PhotonNetwork.Instantiate("RedTeamShield", transform.position, Quaternion.identity, 0);
            }
        }
        else
        {
            //gameObject.GetComponent<PhotonView>().RPC("RespawnRemoteShield", PhotonTargets.All);
        }
        shieldDestroyed = false;
        Debug.Log(shieldDestroyed.ToString());
    }

    void RespawnShieldLowHealth()
    {
        if(playerIsMine)
        {
            myRedShield.GetComponent<MeshRenderer>().enabled = true;
            shieldHealth = 1;
            shieldTimer = 0;
            shieldDestroyed = false;
            playerJustSpawned = false;
            Debug.Log(shieldDestroyed.ToString());
            // SEND MESSAGE TO TURN THIS ON ON OTHER CLIENTS
        }
    }

    void KillPlayer()
    {
        GetComponent<PhotonView>().RPC("DestroyPlayer", PhotonTargets.MasterClient);
    }

    void DestroyShield()
    {
        shieldDestroyed = true;
        Debug.Log(shieldDestroyed.ToString());
        myRedShield.GetComponent<MeshRenderer>().enabled = false;
        shieldHealth = 0;

        //GetComponent<PhotonView>().RPC("DestroyShieldGlobally", PhotonTargets.All);
    }

    void OnCollisionEnter(Collision other)
    {
        //If this isn't the client, then leave
        if(playerIsMine == false)
            return;
        //Shield Damage
        if(other.gameObject.tag == "Projectile" && GetComponent<PlayerHandler>().shieldDestroyed == false)
        {
            myRedShield.GetComponent<ShieldEffectScript>().ShowEffect(other.gameObject, myRedShield.GetComponent<ShieldEffectScript>().ShapeOption);
            shieldHealth -= other.gameObject.GetComponent<BulletScript>().damageDealt;
            justCollided = true;
            Debug.Log(shieldHealth.ToString());

            other.gameObject.GetComponent<PhotonView>().RPC("KillBullet", PhotonTargets.MasterClient);
            //other.gameObject.GetComponent<PhotonView>().RPC("KillBullet", PhotonTargets.OthersBuffered);
            //Destroy(other.gameObject);
        }
        //Player Damage if shield is down
        else if(other.gameObject.tag == "Projectile")
        {

            CancelInvoke();
            Invoke("RespawnShieldLowHealth", shieldCooldownTimer);
            playerHealth -= other.gameObject.GetComponent<BulletScript>().damageDealt;
            //shieldSlider.GetComponent<Slider>().value = shieldHealth;
            justCollided = true;

            other.gameObject.GetComponent<PhotonView>().RPC("KillBullet", PhotonTargets.MasterClient);
            //other.gameObject.GetComponent<PhotonView>().RPC("KillBullet", PhotonTargets.OthersBuffered);
            //Destroy(other.gameObject);
        }
    }

    void OnTriggerEnter(Collider other)
    {
        if(playerIsMine == false)
            return;
        //if(other.gameObject.tag == "Projectile" && myRedShield.activeSelf == false)
        //{
        //  playerHealth -= other.gameObject.GetComponent<BulletScript>().damageDealt;
        //  justCollided = true;
        //  Debug.Log(playerHealth.ToString());
        //}
    }

    /// <summary>
    /// RPC's
    /// </summary>

    [RPC]
    public void DestroyRemoteShield()
    {
        myRedShield.GetComponent<MeshRenderer>().enabled = false;
    }

    [RPC]
    public void RespawnRemoteShield()
    {
        myRedShield.GetComponent<MeshRenderer>().enabled = true;
        Debug.Log("RespawnRemoteShield");
    }

    [RPC]
    public void DestroyPlayer()
    {
        PhotonNetwork.Destroy(gameObject);
    }
}