//PhotonNetwork function for handling when PlayerLeaves the room
//need to inherit from MonoBehaviourPunCallbacks to use this
public override void OnPlayerLeftRoom(Player otherPlayer)
{
if (otherPlayer == PhotonNetwork.LocalPlayer && photonView.IsMine && PhotonNetwork.OfflineMode == false)
{
PhotonNetwork.RemoveRPCs(PhotonNetwork.LocalPlayer);
}
}
/// <summary>
/// Called when a remote player left the room.
/// See the official Photon docs for more details.
/// </summary>
public override void OnPlayerLeftRoom(Photon.Realtime.Player player)
{
//only let the master client handle this connection
if (!PhotonNetwork.IsMasterClient)
{
return;
}
//get player-controlled game object from disconnected player
GameObject targetPlayer = GetPlayerGameObject(player);
//process any collectibles assigned to that player
if (targetPlayer != null)
{
Collectible[] collectibles = targetPlayer.GetComponentsInChildren <Collectible>(true);
for (int i = 0; i < collectibles.Length; i++)
{
//let the player drop the Collectible
PhotonNetwork.RemoveRPCs(collectibles[i].spawner.photonView);
collectibles[i].spawner.photonView.RPC("Drop", RpcTarget.AllBuffered, targetPlayer.transform.position);
}
}
//clean up instances after processing leaving player
PhotonNetwork.DestroyPlayerObjects(player);
//decrease the team fill for the team of the leaving player and update room properties
PhotonNetwork.CurrentRoom.AddSize(player.GetTeam(), -1);
}
void ExecuteAction()
{
if (!PhotonNetwork.InRoom)
{
LogError("Operation only allowed when inside a room");
Fsm.Event(failureEvent);
return;
}
_player = player.GetPlayer(this);
if (_player != null)
{
if (!_player.Equals(PhotonNetwork.LocalPlayer) && !PhotonNetwork.IsMasterClient)
{
LogError("Removing a player's Buffered RPC different then your LocalPlayer is not allowed, unless you are the current MasterClient");
Fsm.Event(failureEvent);
}
else
{
PhotonNetwork.RemoveRPCs(_player);
Fsm.Event(successEvent);
}
}
else
{
LogError("Player reference is null");
Fsm.Event(failureEvent);
}
}
private void setLinePhase0()
{
if (this.master == null)
{
if ((IN_GAME_MAIN_CAMERA.gametype != GAMETYPE.SINGLE) && basePV.isMine)
{
PhotonNetwork.Destroy(base.gameObject);
PhotonNetwork.RemoveRPCs(basePV);
}
else if (IN_GAME_MAIN_CAMERA.gametype == GAMETYPE.SINGLE)
{
UnityEngine.Object.Destroy(this.rope);
UnityEngine.Object.Destroy(base.gameObject);
}
return;
}
else if (this.nodes.Count > 0)
{
Vector3 vector = this.myRefT.position - ((Vector3)this.nodes[0]);
this.lineRenderer.SetVertexCount(this.nodes.Count);
for (int i = 0; i <= (this.nodes.Count - 1); i++)
{
this.lineRenderer.SetPosition(i, ((Vector3)this.nodes[i]) + ((Vector3)(vector * Mathf.Pow(0.75f, (float)i))));
}
if (this.nodes.Count > 1)
{
this.lineRenderer.SetPosition(1, this.myRefT.position);
}
}
}
/// <summary>
/// Server only: check for players colliding with the powerup.
/// Possible collision are defined in the Physics Matrix.
/// </summary>
public override void OnTriggerEnter(Collider col)
{
if (!PhotonNetwork.IsMasterClient)
{
return;
}
GameObject obj = col.gameObject;
Player player = obj.GetComponent <Player>();
//try to apply collectible to player, the result should be true
if (Apply(player))
{
//clean up previous buffered RPCs so we only keep the most recent one
PhotonNetwork.RemoveRPCs(spawner.photonView);
//check if colliding player belongs to the same team as the item
if (teamIndex == player.GetView().GetTeam())
{
//player collected team item, return it to team home base
//we do not have to send this as buffered RPC because this is the default spawn position
spawner.photonView.RPC("Return", RpcTarget.All);
}
else
{
//player picked up item from other team, send out buffered RPC for it to be remembered
spawner.photonView.RPC("Pickup", RpcTarget.AllBuffered, (short)player.GetView().ViewID);
}
}
}
public void removeMe()
{
this.isdestroying = true;
if (this.MasterHero != null)
{
if (this.MasterHero.hook["left"] == this)
{
this.MasterHero.hook["left"] = null;
}
else if (this.MasterHero.hook["right"] == this)
{
this.MasterHero.hook["right"] = null;
}
}
if ((IN_GAME_MAIN_CAMERA.gametype != GAMETYPE.SINGLE) && basePV.isMine)
{
PhotonNetwork.Destroy(basePV);
PhotonNetwork.RemoveRPCs(basePV);
}
else if (IN_GAME_MAIN_CAMERA.gametype == GAMETYPE.SINGLE)
{
UnityEngine.Object.Destroy(this.rope);
UnityEngine.Object.Destroy(base.gameObject);
}
}
void DoRemoveRp()
{
if (playerId.IsNone)
{
PhotonNetwork.RemoveRPCs(PhotonNetwork.player);
}
else
{
if (!PhotonNetwork.isMasterClient)
{
Fsm.Event(failureEvent);
return;
}
PhotonPlayer _target = PhotonPlayer.Find(playerId.Value);
if (_target == null)
{
LogError("Player Id '" + playerId.Value + "' not found");
Fsm.Event(failureEvent);
return;
}
PhotonNetwork.RemoveRPCs(_target);
}
Fsm.Event(successEvent);
}
private void Awake()
{
PhotonView = this.GetComponent <PhotonView>();
if (Instance == null)
{
Instance = this;
//PhotonView.DontDestroyOnLoad (this);
}
else if (this != Instance)
{
//SceneManager.sceneLoaded -= OnSceneFinishingLoading;
if (PhotonView.isMine)
{
PhotonNetwork.RemoveRPCs(PhotonView);
}
PhotonView.DestroyImmediate(gameObject);
return;
}
Instance = this;
// Ex: lluma#1234
PlayerName = nameInputField.text;
SceneManager.sceneLoaded += OnSceneFinishingLoading;
}
//calculates the remaining time until the next respawn,
//waits for the delay to have passed and then instantiates the object
IEnumerator SpawnRoutine()
{
yield return(new WaitForEndOfFrame());
float delay = Mathf.Clamp(nextSpawn - (float)PhotonNetwork.Time, 0, respawnTime);
yield return(new WaitForSeconds(delay));
if (PhotonNetwork.IsConnected)
{
//differ between CollectionType
if (colType == CollectionType.Pickup && obj != null)
{
//if the item is of type Pickup, it should not be destroyed after
//the routine is over but returned to its original position again
PhotonNetwork.RemoveRPCs(this.photonView);
this.photonView.RPC("Return", RpcTarget.All);
}
else
{
//instantiate a new copy on all clients
this.photonView.RPC("Instantiate", RpcTarget.All);
}
}
}
/// <summary>
/// Server only: check for collectibles colliding with the zone.
/// Possible collision are defined in the Physics Matrix.
/// </summary>
public void OnTriggerEnter(Collider col)
{
if (!PhotonNetwork.IsMasterClient)
{
return;
}
//the game is already over so don't do anything
if (GameManager.GetInstance().IsGameOver())
{
return;
}
//check for the required object
//continue, if it is not assigned to begin with
if (requireObject != null)
{
//the required object is not instantiated
if (requireObject.obj == null)
{
return;
}
//the required object either does not have a CollectibleTeam component,
//is still being carried around or not yet at back at the spawn position
CollectibleTeam colReq = requireObject.obj.GetComponent <CollectibleTeam>();
if (colReq == null || colReq.carrierId >= 0 ||
colReq.transform.position != requireObject.transform.position)
{
return;
}
}
CollectibleTeam colOther = col.gameObject.GetComponent <CollectibleTeam>();
//a team item, which is not our own, has been brought to this zone
if (colOther != null && colOther.teamIndex != teamIndex)
{
if (scoreClip)
{
AudioManager.Play3D(scoreClip, transform.position);
}
//add points for this score type to the correct team
GameManager.GetInstance().AddScore(ScoreType.Capture, teamIndex);
//the maximum score has been reached now
if (GameManager.GetInstance().IsGameOver())
{
//close room for joining players
PhotonNetwork.CurrentRoom.IsOpen = false;
//tell all clients the winning team
GameManager.GetInstance().localPlayer.photonView.RPC("RpcGameOver", RpcTarget.All, (byte)teamIndex);
return;
}
//remove network messages about the Collectible since it is about to get destroyed
PhotonNetwork.RemoveRPCs(colOther.spawner.photonView);
colOther.spawner.photonView.RPC("Destroy", RpcTarget.All);
}
}
public virtual void Die()
{
if (!enabled)
{
return;
}
print("Die" + pv.PlayerName);
audio.PlayOneShot(dieSound.Random(), 6);
Destroy(model.animation);
var nm = (Transform)Instantiate(model.transform, model.pos, model.rot);
foreach (var a in nm.GetComponentsInChildren <SkinnedMeshRenderer>())
{
a.updateWhenOffscreen = true;
}
nm.SetLayer(LayerMask.NameToLayer("Dead"));
foreach (var a in nm.GetComponentsInChildren <Rigidbody>())
{
a.isKinematic = false;
}
nm.parent = _Game.Fx;
Destroy(nm.gameObject, 10);
enabled = false;
if (IsMine)
{
PhotonNetwork.RemoveRPCs(photonView);
PhotonNetwork.Destroy(gameObject);
}
}
void OnDestroy()
{
GameManager.instance.UpdatePlayerGroup();
if (PhotonNetwork.IsMasterClient)
{
PhotonNetwork.RemoveRPCs(PV);
}
}
void NetworkDestroy()
{
if (gameObject.GetPhotonView().isMine)
{
PhotonNetwork.RemoveRPCs(gameObject.GetPhotonView());
PhotonNetwork.Destroy(gameObject.GetPhotonView());
}
}
public override void OnDisable()
{
if (Application.isPlaying && PhotonNetwork.InRoom && photonView && photonView.IsMine)
{
PhotonNetwork.RemoveRPCs(photonView);
}
base.OnDisable();
}
//PhotonNetwork function for handling when PlayerLeaves the room
//need to inherit from MonoBehaviourPunCallbacks to use this
public override void OnPlayerLeftRoom(Player otherPlayer)
{
if (otherPlayer == PhotonNetwork.LocalPlayer && photonView.IsMine)
{
PhotonNetwork.RemoveRPCs(PhotonNetwork.LocalPlayer);
_myCustomProperty.Remove("PlayerIndexNumber");
}
}
IEnumerator WaitToLoadNextMap(int mapname)
{
yield return(new WaitForSeconds(GameManager.instance.EndGameTime));
PhotonNetwork.RemoveRPCs(GameManager.instance.GameManagerPhotonView);
GameManager.instance.GameManagerPhotonView.RPC("LoadNextMap", RpcTarget.All, mapname);
//ingameui.gameEndScreen.SetActive(false);
//Ending(true);
}
void NetworkDestroy()
{
if (gameObject.GetPhotonView().isMine)
{
GameObject.Find("GameManager").GetPhotonView().RPC("BoulderCountUpdate", PhotonTargets.MasterClient);
PhotonNetwork.RemoveRPCs(gameObject.GetPhotonView());
PhotonNetwork.Destroy(gameObject.GetPhotonView());
}
}
private void OnSceneDoneLoading(Scene arg0, LoadSceneMode arg1)
{
if (arg0.name == "MainScene")
{
SetColor(SkinColor, HeadsetColor, ShirtColor);
PhotonNetwork.RemoveRPCs(photonView);
isMainSceneLoaded = true;
}
}
private void PickUpDestroy()
{
if (PhotonNetwork.IsMasterClient)
{
PhotonNetwork.RemoveRPCs(photonView);
PhotonNetwork.Destroy(gameObject);
}
droppedItemLabel.anim.SetTrigger("Pickup");
}
// 한명이 나가면 룸으로 이동
public override void OnPhotonPlayerDisconnected(PhotonPlayer otherPlayer)
{
PhotonNetwork.RemoveRPCs(PhotonNetwork.player);
if (PhotonNetwork.isMasterClient)
{
PhotonNetwork.LoadLevelAsync("Room");
PhotonNetwork.room.IsOpen = true;
}
}
public void OnClickFinishVoting()
{
// remove the vote RPC so new players don't get it anymore
PhotonNetwork.RemoveRPCs(PhotonNetwork.LocalPlayer);
this.photonView.RPC("OnVotingFinished", RpcTarget.Others);
toggleButtons(false);
// evaluate voting
Debug.Log(votingSystem.Get_Result());
votingSystem.Save_Result();
}
private void PickUpDestroy()
{
//DroppedItemManager.instance.RemoveDroppedItem(photonView.ViewID);
droppedItemLabel.anim.SetTrigger("Pickup");
if (PhotonNetwork.IsMasterClient)
{
PhotonNetwork.RemoveRPCs(photonView);
PhotonNetwork.Destroy(gameObject);
}
}
public override void OnPlayerLeftRoom(Photon.Realtime.Player player)
{
Debug.Log("some player left the room");
foreach (var p in PhotonNetwork.PlayerList)
{
PhotonNetwork.RemoveRPCs(p);
}
PairManager.S.EndGame(PairManager.S.players[playerIndex].GetPhotonView().ViewID, false);
PairManager.S.photonView.RPC("ClearPlayerList", RpcTarget.All);
}
internal void OnTeamSelected()
{
if (_Player != null)
{
PhotonNetwork.RemoveRPCs(_Player.photonView);
PhotonNetwork.Destroy(_Player.gameObject);
}
if (!GameStarted && _Game.pv.team != Team.Spectators)
{
InstanciateShared(NetworkPlayerID, PlayerPrefab);
}
}
public void RemoveMe()
{
isdestroying = true;
if (IN_GAME_MAIN_CAMERA.Gametype != GameType.Singleplayer && base.photonView.isMine)
{
PhotonNetwork.Destroy(base.photonView);
PhotonNetwork.RemoveRPCs(base.photonView);
}
else if (IN_GAME_MAIN_CAMERA.Gametype == GameType.Singleplayer)
{
UnityEngine.Object.Destroy(rope);
UnityEngine.Object.Destroy(base.gameObject);
}
}
public void removeMe()
{
this.isdestroying = true;
if (IN_GAME_MAIN_CAMERA.GameType != GameType.Singleplayer && photonView.isMine)
{
PhotonNetwork.Destroy(photonView);
PhotonNetwork.RemoveRPCs(photonView);
}
else if (IN_GAME_MAIN_CAMERA.GameType == GameType.Singleplayer)
{
Destroy(this.rope);
Destroy(gameObject);
}
}
public void removeMe()
{
this.isdestroying = true;
if ((IN_GAME_MAIN_CAMERA.gametype != GAMETYPE.SINGLE) && base.photonView.isMine)
{
PhotonNetwork.Destroy(base.photonView);
PhotonNetwork.RemoveRPCs(base.photonView);
}
else if (IN_GAME_MAIN_CAMERA.gametype == GAMETYPE.SINGLE)
{
UnityEngine.Object.Destroy(this.rope);
UnityEngine.Object.Destroy(base.gameObject);
}
}
//When a player on remote client leaves their PhotonNetwork.UserID is sent here
//to be removed from GSC.networkOBJs<List> on remaining players in game
public override void OnPlayerLeftRoom(Player otherPlayer)
{
for (int i = 0; i < GSC.networkObjects.Count; i++)
{
if (GSC.networkObjects[i].PhotonUserID == otherPlayer.UserId)
{
Debug.Log("Player: " + GSC.networkObjects[i].PhotonUserID + " Has Left The Game");
GSC.networkObjects.RemoveAt(i);
PhotonNetwork.RemoveRPCs(GSC.networkObjects[i].viewID);
PhotonNetwork.Destroy(GSC.networkObjects[i].viewID);
}
}
}
public void removeMe()
{
isdestroying = true;
if (IN_GAME_MAIN_CAMERA.gametype != GAMETYPE.SINGLE && photonView.isMine)
{
PhotonNetwork.Destroy(photonView);
PhotonNetwork.RemoveRPCs(photonView);
}
else if (IN_GAME_MAIN_CAMERA.gametype == GAMETYPE.SINGLE)
{
Destroy(rope);
Destroy(gameObject);
}
}
void LeaveRoom()
{
if (PhotonNetwork.connected)
{
PhotonNetwork.RemoveAllBufferedMessages();
PhotonNetwork.RemoveRPCs();
cm.enabled = true;
cm.connectingToRoom = true;
cm.fadeDir = -1;
PhotonNetwork.LeaveRoom();
this.enabled = false;
transform.GetChild(0).gameObject.active = true;
isPaused = false;
Player = null;
}
}
