public override void OnPhotonPlayerDisconnected(PhotonPlayer otherPlayer)
    {
        base.OnPhotonPlayerDisconnected(otherPlayer);

        if (PhotonNetwork.isMasterClient)
            MatchMakerSendPlayerToClassSelect();
    }

    public void SpawnSpectre( Vector2 spawnCoordinates, Quaternion spawnRotation, PhotonPlayer owner )
    {
        if ( PhotonNetwork.isMasterClient )
        {
            //Check if coordinate is vacant
            GridSpace space = GridSystem.GetSpaceByCoordinate( spawnCoordinates );
            if ( space.GridTile != null && !space.GridTile.IsOccupied )
            {
                //Spawn new unit on the network
                GameObject newSpectre = PhotonNetwork.Instantiate( "Units/PlayerSpectre", new Vector3( spawnCoordinates.x, 0, spawnCoordinates.y ), spawnRotation, 0 );
                PlayerSpectre spectre = newSpectre.GetComponent<PlayerSpectre>( );

                spectre.SetOwner( owner );
                spectre.CurrentTile = space.GridTile;

                //Notify tile of this objects arrival
                space.GridTile.RegisterUnit( spectre );

                //Add this spectre to list
                if ( Spectres == null )
                    Spectres = new List<PlayerSpectre>( );

                Spectres.Add( newSpectre.GetComponent<PlayerSpectre>( ) );
            }
        }
        else
        {
            photonView.RPC( "SpawnSpectre", PhotonTargets.MasterClient, spawnCoordinates, spawnRotation, owner );
        }
    }

 public void OnPhotonPlayerConnected(PhotonPlayer newPlayer)
 {
     if (PhotonNetwork.isMasterClient)
     {
         this.SendPickedUpItems(newPlayer);
     }
 }

 void recieveCurrentParty(PhotonPlayer[] _players, bool _open)
 {
     List<PhotonPlayer> _players2 = new List<PhotonPlayer>();
     foreach (PhotonPlayer _p in _players) { _players2.Add(_p); }
     Party _party = new Party(_players2, _open);
     GameObject.FindGameObjectWithTag("MenuController").GetComponentInChildren<SocialScreen>().recieveCurrentParty(_party);
 }

    //
    // Add a weapon of type weaponName to the player
    // - if the player already has the weapon then just add ammo
    // - confirm it works correctly
    public void AddPickedUpWeapon(string weaponName, PhotonPlayer player)
    {
        if (weapons[weaponName]) {
          weapons[weaponName].AddAmmo(weapons[weaponName].DefaultAmmoAmount());
        } else {

          // spawn weapon for the player
          if (PhotonNetwork.player == player) {

        GameObject weaponObject = PhotonNetwork.Instantiate(weaponName, weaponPosition.transform.position, camera.transform.rotation, 0);
        Weapon weapon = weaponObject.GetComponent<Weapon>();

        // need all copies to be not pick upable
        weapon.GetComponent<PhotonView>().RPC("PickUp", PhotonTargets.All, null);

        // syncs weapon name to weapon so all players have a reference to each players weapons
        weapons[weaponName] = weapon;

        // this needs to be an rpc
        weapon.GetComponent<PhotonView>().RPC("SetParent", PhotonTargets.All, playerController.GetComponent<PhotonView>().viewID, true);

        playerController.GetComponent<PhotonView>().RPC("ChangeWeapon", PhotonTargets.All, weaponName, weapon.GetComponent<PhotonView>().viewID);
          }
        }
    }

    public void RPCBoss3TakeDamage(float damage, PhotonPlayer owningPlayer)
    {
        // Flash the thug white
        characterTextureFlasher.Flash(0.04f);

        // Deduct the hitpoint count
        hitPoints -= damage;

        // Handling for the owner (the master client)
        if (PhotonNetwork.isMasterClient)
        {
            // If the character is doomed, then begin its VISUAL death sequence. Other players
            // will discover this with the next serialization; and you, as the master client,
            // will eventually destroy the character entirely.
            if (hitPoints - damage < MinHitpointsBeforeFrag)
            {
                GameDirector gameDirector = (GameDirector)Object.FindObjectOfType(typeof(GameDirector));
                // Do stuff for the owning player
                if (null != owningPlayer)
                {
                    // Increase their score
                    int currentScore = (int)owningPlayer.customProperties["Player.ActiveSession.Score"];
                    gameDirector.photonView.RPC("RPCSetScore", owningPlayer, currentScore + pointValue);
                }

                // Tell everybody that this character is dying
                photonView.RPC("RPCBoss3BeginDying", PhotonTargets.All);

                // Tell everybody that the boss has been defeated. Do it buffered in case someone
                // jumps in during the victory sequence.
                gameDirector.photonView.RPC("RPCBossDefeated", PhotonTargets.AllBuffered);
            }
        }
    }

 private void Die(PhotonPlayer killer)
 {
     if (playerController.transform.GetComponent<PhotonView>().isMine) {
       GameController.instance.PlayerDied(killer);
       PhotonNetwork.Destroy(playerController.gameObject);
     }
 }

	public void GetShot(float damage, PhotonPlayer enemyPlayer)
	{
			health -= damage;

			if (photonView.isMine) {
			
			particle = GameObject.Find("spPoint");
			AudioSource.PlayClipAtPoint(damagesound, particle.transform.position);
			mainscreen.health = health;
			}

			if (health <= 0 && photonView.isMine) {

				//if(SendNetworkMessage != null)
				//	SendNetworkMessage(PhotonNetwork.player.name + " was killed by " + enemyName);

				enemyPlayer.AddKill(1);
				PhotonNetwork.player.AddDeath(1);
				
				if(RespawnMe != null)
					RespawnMe(3f);
				
				GameObject.Find("screenset").SetActive(false);
				PhotonNetwork.Destroy (gameObject);
				
			}
	}

	void OnEnable () {
        if (CurrentParty == null)
        {
            CurrentParty = new Party(PhotonNetwork.player);
        }
        nonGmPlayers = new PhotonPlayer[9];
        GmPlayers = new PhotonPlayer[11];
        ConnectedPlayers = PhotonNetwork.playerList;
        int counter = 0;
        int gmcounter = 0;
        foreach (GameObject _object in PlayerButtons)
        {
            _object.SetActive(false);
        }
        foreach (GameObject _object in PartyButtons)
        {
            _object.SetActive(false);
        }
        foreach (PhotonPlayer _player in ConnectedPlayers)
        {
            if (_player.name != "" && _player.name != PhotonNetwork.player.name)
            {
                nonGmPlayers[counter] = _player;
                PlayerButtons[counter].SetActive(true);
                PlayerButtons[counter].GetComponentInChildren<Text>().text = _player.name;
                counter++;
            }
            else if (_player.name != PhotonNetwork.player.name && !_player.isMasterClient)
            {
                GmPlayers[gmcounter] = _player;
                gmcounter++;
            }
        }
        updateCurrentPartyUi();
	}

 //public void OnPawnTakesDamage(CombatEventListener.PawnTakesDamageCallback callback, PhotonPlayer thePlayer, int damageTaken)
 public void OnPawnTakesDamage(PhotonPlayer thePlayer, int currentHealth, int maxHealth)
 {
     foreach (ICombatEventListener listener in IterateListeners<ICombatEventListener>())
     {
         listener.OnPawnTakesDamage(thePlayer, currentHealth, maxHealth);
     }
 }

 /// <remarks>
 /// In theory, the client which created the room might crash/close before it sets the start time.
 /// Just to make extremely sure this never happens, a new masterClient will check if it has to
 /// start a new round.
 /// </remarks>
 public void OnMasterClientSwitched(PhotonPlayer newMasterClient)
 {
     if (!PhotonNetwork.room.customProperties.ContainsKey (StartTimeKey)) {
         Debug.Log ("The new master starts a new round, cause we didn't start yet.");
         this.StartRoundNow ();
     }
 }

 protected void OnPickup(PhotonPlayer m_actor,int m_view)
 {
     PhotonView view = PhotonView.Find(m_view);
     if (view != null)
     {
         bl_CTFPlayerLogic logic = view.GetComponent<bl_CTFPlayerLogic>();
         if (CanBePickedUpBy(logic) == true)
         {
             OnPickup(logic);
             if (PhotonNetwork.player == m_actor)
             {
                 bool t_send = false;//Prevent call two or more events
                 if (!t_send)
                 {
                     t_send = true;
                     Team oponentTeam;
                     if ((string)PhotonNetwork.player.customProperties[PropiertiesKeys.TeamKey] == Team.Delta.ToString())
                         oponentTeam = Team.Recon;
                     else
                         oponentTeam = Team.Delta;
                     bl_EventHandler.KillEvent(PhotonNetwork.player.name, "", "Obtained at the " + oponentTeam.ToString() + " flag", (string)PhotonNetwork.player.customProperties[PropiertiesKeys.TeamKey], 777, 15);
                 }
             }
         }
     }
 }

    void OnPhotonPlayerConnected(PhotonPlayer other)
    {
        if (PhotonNetwork.playerList.Length > 1)
        {
            FadingManager.Instance.Fade(scene);
        }

    }

 public void SetPlayer(int inLevel, string inName, int inPlayerID, PhotonPlayer inPhotonPlayer)
 {
     playerLevel = inLevel;
     playerID = inPlayerID;
     playerName = inName;
     nameLabel.text = playerName;
     netPlayer = inPhotonPlayer;
 }

    /**
       * How to handle player deaths, each subclass can set their own rules for
       * player deaths
       */
    public virtual void PlayerDied(PlayerManager playerManager, PhotonPlayer killer)
    {
        ScoreBoard.instance.GetComponent<PhotonView>().RPC("AddKillToScoreBoard", PhotonTargets.All, killer);

        MenuCamera.instance.gameObject.SetActive(true);

        playerManager.SetNextSpawnTime();
    }

 public override void OnPhotonPlayerConnected(PhotonPlayer newPlayer)
 {
     base.OnPhotonPlayerConnected(newPlayer);
     InitPlayer();
     SpawnPlayerUnits();
     PhotonNetwork.room.open = false;
     PhotonNetwork.room.visible = false;
 }

 public override void OnMasterClientSwitched(PhotonPlayer newMasterClient)
 {
     base.OnMasterClientSwitched(newMasterClient);
     if (newMasterClient == PhotonNetwork.player)
     {
         view.RequestOwnership();
     }
 }

 public void OnMasterClientSwitched(PhotonPlayer newMasterPlayer)
 {
     if (PhotonNetwork.isMasterClient)
     {
         //disable the ui buttons for the master
         FindObjectOfType<UIManager>().DisableClientButtons();//just a temp ugly call as it's a test project
     }
 }

    // Calculates damage taken based on distance between player and explosion
    private int CalculatePlayerDamage(PhotonPlayer p)
    {
        if ((string)p.customProperties[PropiertiesKeys.TeamKey] == myTeam)
            return 0;

        float distance = Vector3.Distance(base.transform.position, FindPhotonPlayer(p).transform.position);
        return Mathf.Clamp((int) (this.explosionDamage * ((this.explosionRadius - distance) / this.explosionRadius)), 0, (int) this.explosionDamage);
    }

 void OnPhotonPlayerConnected(PhotonPlayer newPlayer)
 {
     if (PhotonNetwork.isMasterClient)
     {
         //A player connected to me(the MasterClient), spawn a player for it:
         Spawnplayer(newPlayer);
     }
 }