Ajuda Com Sala de Jogo Multiplayer

voce pode me dar uma ajuda?
este e o problema eu tenho um jogo online para 2 jogadores
quando conecta os 2 jogadores a sala de jogo fica indisponível para outros jogadores entrarem ela fica invisível 
ate ai tudo bem.
o problema e quando finaliza a partida e um jogador sai ou cai a conexão a sala volta a ficar disponível novamente
ai se outro jogador entrar ele entra na partida mas ela ja acabou entendeu?
veja este vídeo que fiz.
eu queria que a sala não ficasse disponível pois ja não existe mais a partida entendeu existe algum comando para destruir a sala ou algo do tipo?




este e o meu codigo da criação das salas e outras coisas. obs nem todo codigo e usado pois adaptei ele de um outro jogo. mas ele funciona normal para o que eu quero o problema e so este mesmo das salas.

Código:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.SceneManagement;
using Photon.Realtime;
using Photon.Pun;
namespace MultiplayerShooter
{
public class LobbyManager : MonoBehaviourPunCallbacks
{
   
   public static LobbyManager  instance;

   public enum Status {Offline,Online, Connecting,Connected, Joining, Creating, Rooming};

   [Header("Informative")]
   public Status status = Status.Offline;

    [Header("Main Menu")]
   public Canvas  mainPanel;

    [Header("Lobby Room")]
   public Canvas  lobbyRoom;
   
   [Header("Create Room Panel")]
   public Canvas  createRoomPanel;

    [Header("Room List Panel")]
   public Canvas  roomListPanel;

   [Header("Choose Character Panel")]
   public Canvas  ChooseCharacterPanel;
   
   [Header("Alert Dialog panel")]
   public Canvas alertgameDialog;
   
   [Header("Alert Dialog Text")]
   public Text alertDialogText;
   
   [Header("Mesage Text")]
   public Text messageText;
   
   public GameObject lobbyCamera;

   public string currentMenu;
   
   [Header("loading Image")]
   public Canvas loadingImg;

   [Header("Input Login")]
   public InputField inputLogin;
   [Header("Input SALANOME")]
   public InputField SALANOME;

      [Header("Private Room ID")]
   public InputField inputPrivateRoomID;
      [Header("Private Room IDcria")]
      public InputField inputPrivateRoomIDcria;

      [Header("Text Room ID")]
   public Text txtRoomID;

   public Button roomType;
   
   [Header("Current Room Players Text")]
   public Text txtCurrentRoomPlayers;

    [Header("Max Room Players Text")]
   public Text txtMaxRoomPlayers;

    [Header("Content Rooms")]
   public GameObject contentRooms;

    [Header("Room Prefab")]
   public GameObject roomPrefab;

   public GameObject btnMap1;

   public GameObject btnMap2;

   public GameObject btnMap3;

    [Header("Avaliable Maps")]
   public GameObject[] avaliableMaps;

    [Header("Max Players Buttons")]
   public GameObject[] maxPlayersBtns;

   public GameObject btnPrivateRoom;
   public GameObject btnPrivateFind;

   public GameObject activeBtnSprite;

   public GameObject desabledBtnSprite;

   public string currentMap;

   public byte maxPlayers;

   public int maxPlayers2;

   public bool isPrivateRoom;
   public bool isPrivateRoomcria;

      ArrayList roomList;
   
   public string roomName = string.Empty;

   public float delay = 0f;

   public Dictionary<string, PhotonRoom> photonRooms = new Dictionary<string, PhotonRoom>();

   public float cont;
   
   public  AudioClip buttonSound;

   public class PhotonRoom
   {
      public string  name;

      public string ownerName;

      public string map;

      public string isPrivate;

      public string currentPlayers ;

      public string maxPlayers ;

   }

   public PhotonView view{ get{ return GetComponent<PhotonView>(); }}
      const string playerNamePrefKey = "PlayerName";
      public void SetPlayerName(string value)
      {
         // #Important
         if (string.IsNullOrEmpty(value))
         {
            Debug.LogError("Player Name is null or empty");
            return;
         }



         PhotonNetwork.NickName = value;


         PlayerPrefs.SetString(playerNamePrefKey, value);
      }
      public void Awake()
    {
         btnPrivateFind.SetActive(value: false);

         //inputPrivateRoomIDcria.enabled = false;
         PhotonNetwork.AutomaticallySyncScene = true;
         string defaultName = string.Empty;
         
         if (inputLogin != null)
         {
            if (PlayerPrefs.HasKey(playerNamePrefKey))
            {
               defaultName = PlayerPrefs.GetString(playerNamePrefKey);
               inputLogin.text = defaultName;
            }
            else
            {
               defaultName = "Player " + UnityEngine.Random.Range(1000, 10000);

            }
         }
         //inputLogin.text = "Player " + UnityEngine.Random.Range(1000, 10000);

        if (Application.internetReachability != NetworkReachability.NotReachable) { // Check if there is a connection here
           
            Debug.Log ("Connected to the Internet!"); // Here executes the desired action if there is a connection
            status = Status.Online;
         if (!PhotonNetwork.IsConnected)
            {
          
              // Connect to the photon master-server. We use the settings saved in PhotonServerSettings (a .asset file in this project)
              PhotonNetwork.ConnectUsingSettings();
               PhotonNetwork.GameVersion = "1056";
               status = Status.Connecting;

              }
      
      }//END_IF

        if (Application.internetReachability == NetworkReachability.NotReachable) { // Here it is checked if there is no connection
           
            Debug.Log ("There is no connection!");// Here performs the desired action if there is no connection
         
        }
    }

      public void setPlayerProperties()
      {
         int @int = PlayerPrefs.GetInt("PlayerFlag");
         int int2 = PlayerPrefs.GetInt("PlayerFormation");
         //int level= PlayerPrefs.GetInt("level");
         PhotonNetwork.SetPlayerCustomProperties(new ExitGames.Client.Photon.Hashtable
      {
         {
            "Flag",
            @int
         },
         {
            "Formation",
            int2
         }
      });
      }


      // Use this for initialization
      void Start () {

      if (instance == null) {

         instance = this;

         roomList = new ArrayList ();
         
         CloseAlertDialog ();

         CloseLoadingImg();

         SetMap("map1");
         SetMaxPlayers(2);
         OpenScreen("main_menu");
         
      }
      else
      {
         Destroy(this.gameObject);
      }



   }

   void Update()
   {
         if (inputPrivateRoomIDcria.text.Length < 3)
         {
            btnPrivateRoom.SetActive(value: false);

         }
         else
         {
            btnPrivateRoom.SetActive(value: true);
         }
         if (inputPrivateRoomID.text.Length < 3)
         {
            btnPrivateFind.SetActive(value: false);

         }
         else
         {
            btnPrivateFind.SetActive(value: true);
         }
         delay += Time.deltaTime;

      if (Input.GetKey ("escape") && delay > 1f) {

        switch (currentMenu) {

         case "main_menu":
          delay = 0f;
          Application.Quit ();
         break;

         case "lobby_room":
          delay = 0f;
         OpenScreen( "main_menu");
         break;
         case "roomList":
          delay = 0f;
         OpenScreen( "main_menu");
         break;
         case "choose_character":
          delay = 0f;
         OpenScreen( "main_menu");
         break;



      

       }//END_SWITCH

    }//END_IF
}
   /// <summary>
   /// opens a selected screen.
   /// </summary>
   /// <param name="_current">Current screen</param>
   public void  OpenScreen(string _current)
   {
      switch (_current)
      {
         case "loading":
         Screen.orientation = ScreenOrientation.Landscape;
         currentMenu = _current;
         mainPanel.enabled = false;
         lobbyRoom.enabled = false;
         createRoomPanel.enabled = false;
         roomListPanel.enabled = false;
         //ChooseCharacterPanel.enabled = false;

         ShowLoadingImg();

         break;
          //lobby menu
          case "main_menu":
         CloseLoadingImg();
         currentMenu = _current;
         mainPanel.enabled = true;
         lobbyRoom.enabled = false;
         createRoomPanel.enabled = false;
         roomListPanel.enabled = false;
         //ChooseCharacterPanel.enabled = false;
         
         break;

         case "lobby_room":
         currentMenu = _current;
         ShowLoadingImg();
         mainPanel.enabled = false;
         lobbyRoom.enabled = true;
         createRoomPanel.enabled = false;
         roomListPanel.enabled = false;
         //ChooseCharacterPanel.enabled = false;
         
         break;


          case "roomList":
         currentMenu = _current;
         mainPanel.enabled = false;
         lobbyRoom.enabled = false;
         createRoomPanel.enabled =false;
         roomListPanel.enabled = true;
         //ChooseCharacterPanel.enabled = false;
         
      
         break;
         case "create_room":
         currentMenu = _current;
         mainPanel.enabled = false;
         lobbyRoom.enabled = false;
         createRoomPanel.enabled = true;
         roomListPanel.enabled = false;
         //ChooseCharacterPanel.enabled = false;
         break;

         case "choose_character":
         currentMenu = _current;
         mainPanel.enabled = false;
         lobbyRoom.enabled = false;
         createRoomPanel.enabled = false;
         roomListPanel.enabled = false;
         //ChooseCharacterPanel.enabled = true;
         break;
   
      }

   }

    #region PUN CALLBACKS

      /// <summary>
      /// callback that processes the server's response after the user is connected to the server
      /// </summary>
     public override void OnConnected(){
        Debug.Log("onConnected stage achieved: next one should be ConnectedToMaster");
    }

    /// <summary>
    /// callback that processes the server's response after the user is connected to the server
    /// </summary>
    public override void OnConnectedToMaster(){
   
       status = Status.Connected;
        Debug.Log("Server host: "+ PhotonNetwork.CloudRegion +
      ",  ping:" + PhotonNetwork.GetPing());
      PhotonNetwork.JoinLobby();
   

    }

    /// <summary>
    /// callback that processes server response after the user enters the lobby room
    /// </summary>
    public override void OnJoinedLobby(){
       
        Debug.Log("You are now at the lobby.");

      status = Status.Rooming;
     
       OpenScreen("main_menu");

    }

   

    public override void OnLeftLobby(){}



  /// <summary>
  ///  lists all rooms corresponding to map chosen by the user
  /// </summary>
  /// <param name="_map"> map chosen by the user</param>

   public void GetRooms(string _map)
   {
     
      OpenScreen("roomList");

      ClearRooms();

      foreach (KeyValuePair<string, PhotonRoom> room in photonRooms) {
          Debug.Log("is private: "+room.Value.isPrivate);

        if(room.Value.map.Equals(_map) && room.Value.isPrivate.Equals("False") )
        {
            SpawnRoom(room.Value.name,room.Value.ownerName, room.Value.currentPlayers, room.Value.maxPlayers);
      
        }
          

      }//END_FOREACH

       
   }

 
   /// <summary>
   /// this method checks for new rooms every 5 seconds and only evidently executes if there are new rooms.
   /// </summary>
   /// <param name="roomList"></param>
   public override void OnRoomListUpdate(List<RoomInfo> roomList)
    {
      Debug.Log("On Received room");
        foreach (RoomInfo room in roomList)
        {
            RoomReceived(room);
        }

    }


   
   /// <summary>
   /// configures a room object to be used in the future by the GetRooms method.
   /// </summary>
   /// <param name="room"></param>
    private void RoomReceived(RoomInfo room)
    {
   
     if (room.IsVisible && room.PlayerCount < room.MaxPlayers && !photonRooms.ContainsKey (room.Name))
      {
       PhotonRoom new_room = new PhotonRoom ();

       new_room.name = room.Name;//set room name
       new_room.ownerName = (string) room.CustomProperties["OwnerName"];
       new_room.map = (string)room.CustomProperties["Map"];
       new_room.isPrivate = (string) room.CustomProperties["isPrivateRoom"];
       new_room.currentPlayers = room.PlayerCount.ToString();
       new_room.maxPlayers = room.MaxPlayers.ToString();
            if (room.PlayerCount < room.MaxPlayers)
            {
               // Adiciona a sala à lista filtrada
               photonRooms.Add(room.Name, new_room);
                }
                else
                {
               PhotonNetwork.CurrentRoom.IsOpen = false;
               PhotonNetwork.CurrentRoom.IsVisible = false;
            }
            //photonRooms.Add (room.Name, new_room);
       Debug.Log("room: "+room.Name+" created");


     }
         

      }


       
   /// <summary>
   /// method called automatically after the player has created the room.
   /// </summary>
   public override void OnCreatedRoom()
   {
      Debug.Log("Room Created Successfully");
   }


   /// <summary>
   ///  CREATE_ROOM.
   /// </summary>
   public void CreateRoom()
   {
         setPlayerProperties();
         isPrivateRoom = false;
         roomName = "Room " + UnityEngine.Random.Range(1000, 10000);
         
         
         //roomName = SALANOME.text;
         RoomOptions roomOptions = new RoomOptions {MaxPlayers = maxPlayers};

      roomOptions.CustomRoomPropertiesForLobby = new string[3] { "OwnerName","Map", "isPrivateRoom"};
      roomOptions.CustomRoomProperties = new ExitGames.Client.Photon.Hashtable();
   
        roomOptions.CustomRoomProperties.Add("OwnerName", inputLogin.text);
      roomOptions.CustomRoomProperties.Add("Map", currentMap);
        roomOptions.CustomRoomProperties.Add("isPrivateRoom",isPrivateRoom.ToString());

        PhotonNetwork.CreateRoom(roomName, roomOptions, null);

        status = Status.Creating;
          
   }

      public void CreateRoomPRIVADA()
      {
         setPlayerProperties();
         if (inputPrivateRoomIDcria!= null)
         {
            //btnPrivateRoom.GetComponent<Image>().sprite = activeBtnSprite.GetComponent<SpriteRenderer>().sprite;
            isPrivateRoom = true;
            roomName = inputPrivateRoomIDcria.text;



            //roomName = SALANOME.text;
            RoomOptions roomOptions = new RoomOptions { MaxPlayers = maxPlayers };

            roomOptions.CustomRoomPropertiesForLobby = new string[3] { "OwnerName", "Map", "isPrivateRoom" };
            roomOptions.CustomRoomProperties = new ExitGames.Client.Photon.Hashtable();

            roomOptions.CustomRoomProperties.Add("OwnerName", inputLogin.text);
            roomOptions.CustomRoomProperties.Add("Map", currentMap);
            roomOptions.CustomRoomProperties.Add("isPrivateRoom", isPrivateRoom.ToString());

            PhotonNetwork.CreateRoom(roomName, roomOptions, null);

            status = Status.Creating;
            }
         

      }

      /// <summary>
      /// adds the player to the chosen room.
      /// </summary>
      public  void JoinRoom(string _roomName){

         setPlayerProperties();
         PhotonNetwork.JoinRoom(_roomName);
         print(_roomName);
 
    }
   
   /// <summary>
   /// method called automatically after the player has joined the room.
   /// </summary>
   public override void OnJoinedRoom(){

        status = Status.Rooming;
      
      Debug.Log ("\n joining ...\n");
      
      Debug.Log("RoomJoined " + PhotonNetwork.CurrentRoom.Name);

      PhotonNetwork.LocalPlayer.NickName = inputLogin.text;
     

      OpenScreen("lobby_room");
       
      SetUpRoom( PhotonNetwork.CurrentRoom.Name,PhotonNetwork.CurrentRoom.PlayerCount.ToString(),
                                            PhotonNetwork.CurrentRoom.MaxPlayers.ToString(), (string)PhotonNetwork.CurrentRoom.CustomProperties["Map"]);
         setPlayerProperties();
         PhotonNetwork.LoadLevel("MatchMaking-c#");
         // view.RPC("Matchmaking", RpcTarget.AllBuffered, PhotonNetwork.LocalPlayer);


      }
 
   /// <summary>
   /// method called when a player enters the room.
   /// check if the room is already full so you can start the game
   ///(as it is RPC, the method is called for all players in the Lobby)
   /// </summary>
   [PunRPC]
    public void Matchmaking(Player player) {

     
      UpdateCurrentPlayers(PhotonNetwork.CurrentRoom.PlayerCount.ToString());
     

        if (PhotonNetwork.CurrentRoom.PlayerCount.Equals(PhotonNetwork.CurrentRoom.MaxPlayers)) {
           
          //unlocks the button to start the game
          LoadLevel();
            PhotonNetwork.CurrentRoom.IsOpen = false;
            PhotonNetwork.CurrentRoom.IsVisible = false;
         

        }
           
    }

    /// <summary>
   ///  LoadLevel is a function that loads a scene, its parameter being the scene's index in the build settings.
   /// </summary>
   public void LoadLevel()
   {
      if (PhotonNetwork.IsMasterClient)
      {
         
            PhotonNetwork.LoadLevel("Game");      
             
      
      }
   }

   #endregion

   public void SetUpRoom(string room_id, string current_players,string max_players,string map)
   {
   
     txtRoomID.text = room_id;
     
     txtCurrentRoomPlayers.text = current_players;

     txtMaxRoomPlayers.text = max_players;

   }

   public void SetPrivateRoom()
   {
      isPrivateRoom =!isPrivateRoom;

      if(isPrivateRoom)
      {
          btnPrivateRoom.GetComponent<Image> ().sprite = activeBtnSprite.GetComponent<SpriteRenderer> ().sprite;
            inputPrivateRoomIDcria.enabled = true;
      }
      else
      {
          btnPrivateRoom.GetComponent<Image> ().sprite = desabledBtnSprite.GetComponent<SpriteRenderer> ().sprite;
            inputPrivateRoomIDcria.enabled = false;
         }

      

   }

       
   /// <summary>
   /// method called automatically after the player has joined the room.
   /// </summary>
   public void SetMap(string _map)
   {
      currentMap = _map;
      switch (_map)
      {
         
          case "map1":
         
         btnMap1.GetComponent<Image> ().sprite = activeBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         btnMap2.GetComponent<Image> ().sprite = desabledBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         btnMap3.GetComponent<Image> ().sprite =  desabledBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         break;
          case "map2":
      
         btnMap1.GetComponent<Image> ().sprite =  desabledBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         btnMap2.GetComponent<Image> ().sprite = activeBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         btnMap3.GetComponent<Image> ().sprite =  desabledBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         break;
          case "map3":
         
         btnMap1.GetComponent<Image> ().sprite = desabledBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         btnMap2.GetComponent<Image> ().sprite = desabledBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         btnMap3.GetComponent<Image> ().sprite =  activeBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         break;
      }
   }

   public void ChooseAvaliableMaps(string _map)
   {
      currentMap = _map;
      GetRooms(_map);
      
      switch (_map)
      {
         
          case "map1":
         
         avaliableMaps[0].GetComponent<Image> ().sprite = activeBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         avaliableMaps[1].GetComponent<Image> ().sprite = desabledBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         avaliableMaps[2].GetComponent<Image> ().sprite =  desabledBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         break;
          case "map2":
      
         avaliableMaps[0].GetComponent<Image> ().sprite =  desabledBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         avaliableMaps[1].GetComponent<Image> ().sprite = activeBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         avaliableMaps[2].GetComponent<Image> ().sprite =  desabledBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         break;
          case "map3":
         
         avaliableMaps[0].GetComponent<Image> ().sprite = desabledBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         avaliableMaps[1].GetComponent<Image> ().sprite = desabledBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         avaliableMaps[2].GetComponent<Image> ().sprite =  activeBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         break;
      }
   }

   public void SetMaxPlayers(int  _max_players)
   {
      maxPlayers = (byte)_max_players;

      maxPlayers2 = _max_players;

      for(int i =0; i< maxPlayersBtns.Length;i++ )
      {
         int index = _max_players-1;
         if(i.Equals(index))
         {
            maxPlayersBtns[i].GetComponent<Image> ().sprite = activeBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         }
         else
         {
            maxPlayersBtns[i].GetComponent<Image> ().sprite = desabledBtnSprite.GetComponent<SpriteRenderer> ().sprite;
         }
      }
      
   }



   /// <summary>
   /// Shows the alert dialog.
   /// </summary>
   /// <param name="_message">Message.</param>
   public void ShowAlertDialog(string _message)
   {
      alertDialogText.text = _message;
      alertgameDialog.enabled = true;
   }

   public void ShowLoadingImg()
   {
      loadingImg.enabled = true;


   }
   public void CloseLoadingImg()
   {
      loadingImg.enabled = false;

   }
   /// <summary>
   /// Closes the alert dialog.
   /// </summary>
   public void CloseAlertDialog()
   {
      alertgameDialog.enabled = false;
   }
   
      /// <summary>
   /// Shows the alert dialog.Debug.Log
   /// </summary>
   /// <param name="_message">Message.</param>
   public void ShowMessage(string _message)
   {
      messageText.text = _message;
      messageText.enabled = true;
      StartCoroutine (CloseMessage() );//chama corrotina para esperar o player colocar o outro pé no chão
   }
   
   /// <summary>
   /// Closes the alert dialog.
   /// </summary>

   IEnumerator CloseMessage()
   {

      yield return new WaitForSeconds(4);
      messageText.text = "";
      messageText.enabled = false;
   }




   public void PlayAudio(AudioClip _audioclip)
   {
      
     GetComponent<AudioSource> ().PlayOneShot (_audioclip);

   }

   public void PlayButtonSound()
   {
      
     GetComponent<AudioSource> ().PlayOneShot (buttonSound);

   }




   public void UpdateCurrentPlayers( string current_players)
   {
   
     txtCurrentRoomPlayers.text = current_players;


   }

   /// <summary>
   /// Clears rooms.
   /// </summary>
   public void ClearRooms()
   {
      foreach (GameObject room in roomList)
      {

         Destroy (room.gameObject);
      }

      roomList.Clear ();
   }

   public void SpawnRoom(string id,string name, string current_players, string max_players)
   {
      
     
      GameObject newRoom = Instantiate (roomPrefab) as GameObject;

      newRoom.GetComponent<Room>().id = id;
      newRoom.GetComponent<Room>().txtRoomName.text = name;
      newRoom.GetComponent<Room>().txtPlayers.text = current_players+" / "+max_players.ToString();
   
      newRoom.transform.parent = contentRooms.transform;
      newRoom.GetComponent<RectTransform> ().localScale = new Vector3 (1, 1, 1);

      roomList.Add (newRoom);
            

   }

   public  void JoinToPrivateRoom()
   {
         setPlayerProperties();
         JoinRoom(inputPrivateRoomID.text);
   }
   
   
}//END_CLASS
}//END_NAMESPACE

Para resolver esse problema, você precisa garantir que a sala seja corretamente reiniciada após a partida terminar. Quando um jogador sai da sala ou perde a conexão, o outro jogador deve ser desconectado da sala e a sala deve ser excluída ou reiniciada antes que outros jogadores possam ingressar novamente.

Existem várias maneiras de fazer isso, mas uma abordagem comum é usar callbacks para lidar com a saída de jogadores da sala. Quando um jogador sai da sala ou perde a conexão, o servidor notifica os outros jogadores na sala usando um callback. Os jogadores restantes podem então tomar as medidas necessárias para reiniciar a sala e garantir que ela esteja pronta para outros jogadores ingressarem.

Outra abordagem seria usar um temporizador para reiniciar a sala após a partida terminar. Quando a partida terminar, inicie um temporizador para aguardar alguns segundos antes de reiniciar a sala. Isso dá aos jogadores tempo suficiente para ver a tela de resultados e sair da sala, se quiserem. Depois que o temporizador expirar, a sala pode ser reiniciada automaticamente e estar pronta para outros jogadores ingressarem.

Independentemente da abordagem escolhida, é importante garantir que a sala seja reiniciada ou excluída corretamente após a partida terminar. Isso garante que os jogadores não ingressem em salas antigas ou vazias e que as partidas sejam iniciadas corretamente para todos os jogadores.

O problema parece estar relacionado à lógica que trata a finalização da partida e a disponibilidade da sala.

Quando a partida é finalizada, você precisa garantir que a sala seja novamente disponibilizada para outros jogadores entrarem. Para fazer isso, você pode adicionar uma função que verifica se ambos os jogadores ainda estão conectados e, caso contrário, marca a sala como disponível novamente. Essa função pode ser chamada quando a partida termina ou quando um jogador sai ou perde a conexão.

Algo Assim:

Código:

private void CheckPlayersConnected(Room _room)
{
    bool player1Connected = false;
    bool player2Connected = false;

    foreach (Player player in _room.Players)
    {
        if (player.IsConnected)
        {
            if (player.PlayerNumber == 1)
            {
                player1Connected = true;
            }
            else if (player.PlayerNumber == 2)
            {
                player2Connected = true;
            }
        }
    }

    if (!player1Connected || !player2Connected)
    {
        _room.IsAvailable = true;
        // aqui você pode adicionar uma lógica para remover a sala da lista de salas ocupadas
    }
}

Você pode chamar essa função sempre que um jogador sai ou perde a conexão, ou quando a partida termina. Dessa forma, a sala será marcada como disponível novamente e outros jogadores poderão entrar.

Magnatah escreveu:Para resolver esse problema, você precisa garantir que a sala seja corretamente reiniciada após a partida terminar. Quando um jogador sai da sala ou perde a conexão, o outro jogador deve ser desconectado da sala e a sala deve ser excluída ou reiniciada antes que outros jogadores possam ingressar novamente.

Existem várias maneiras de fazer isso, mas uma abordagem comum é usar callbacks para lidar com a saída de jogadores da sala. Quando um jogador sai da sala ou perde a conexão, o servidor notifica os outros jogadores na sala usando um callback. Os jogadores restantes podem então tomar as medidas necessárias para reiniciar a sala e garantir que ela esteja pronta para outros jogadores ingressarem.

Outra abordagem seria usar um temporizador para reiniciar a sala após a partida terminar. Quando a partida terminar, inicie um temporizador para aguardar alguns segundos antes de reiniciar a sala. Isso dá aos jogadores tempo suficiente para ver a tela de resultados e sair da sala, se quiserem. Depois que o temporizador expirar, a sala pode ser reiniciada automaticamente e estar pronta para outros jogadores ingressarem.

Independentemente da abordagem escolhida, é importante garantir que a sala seja reiniciada ou excluída corretamente após a partida terminar. Isso garante que os jogadores não ingressem em salas antigas ou vazias e que as partidas sejam iniciadas corretamente para todos os jogadores.

O problema parece estar relacionado à lógica que trata a finalização da partida e a disponibilidade da sala.

Quando a partida é finalizada, você precisa garantir que a sala seja novamente disponibilizada para outros jogadores entrarem. Para fazer isso, você pode adicionar uma função que verifica se ambos os jogadores ainda estão conectados e, caso contrário, marca a sala como disponível novamente. Essa função pode ser chamada quando a partida termina ou quando um jogador sai ou perde a conexão.

Algo Assim:

Código:

private void CheckPlayersConnected(Room _room)
{
    bool player1Connected = false;
    bool player2Connected = false;

    foreach (Player player in _room.Players)
    {
        if (player.IsConnected)
        {
            if (player.PlayerNumber == 1)
            {
                player1Connected = true;
            }
            else if (player.PlayerNumber == 2)
            {
                player2Connected = true;
            }
        }
    }

    if (!player1Connected || !player2Connected)
    {
        _room.IsAvailable = true;
        // aqui você pode adicionar uma lógica para remover a sala da lista de salas ocupadas
    }
}

Você pode chamar essa função sempre que um jogador sai ou perde a conexão, ou quando a partida termina. Dessa forma, a sala será marcada como disponível novamente e outros jogadores poderão entrar.

eu queria que depois que iniciasse a partida quando tiver 2 jogadores a sala não ficace mais disponivel ate ai tudo certo ela não fica disponivel mas quando um player sai da partida e fica na tela de fim da partida  quem estiver la no inicio do game se ele clicar em procurar sala.
a sala que saiu um jogador volta a aparecer entendeu? ai ele não poderia entrar pois a partida ja acabou mas o estranho e que se ele clicar ele entra e vai para a partida  sabe algum comando que posso colocar para destruir a sala imediatamente apos finalizar a partida?

Sim, para evitar que a sala que acabou de ser encerrada fique disponível para outros jogadores, você pode destruí-la imediatamente após a partida terminar. Para fazer isso, você pode adicionar uma função que destrua a sala no final da partida.

Por exemplo, dentro da função "EndGame()", após chamar a função "PhotonNetwork.LeaveRoom()", você pode adicionar a linha de código "PhotonNetwork.Destroy(gameObject)" para destruir a sala atual imediatamente. Isso garantirá que a sala não esteja mais disponível para outros jogadores se tentarem entrar.

Aqui está um exemplo de como ficaria a função "EndGame()" com a linha de código adicionada:

Código:

public void EndGame()
{
  PhotonNetwork.LeaveRoom();
  PhotonNetwork.Destroy(gameObject); // Destruir a sala atual
  SceneManager.LoadScene("LobbyScene");
}

Assim, quando um jogador clicar em procurar sala após a partida ter terminado e a sala ter sido destruída, ele não poderá entrar novamente na partida.

Magnatah escreveu:Sim, para evitar que a sala que acabou de ser encerrada fique disponível para outros jogadores, você pode destruí-la imediatamente após a partida terminar. Para fazer isso, você pode adicionar uma função que destrua a sala no final da partida.

Por exemplo, dentro da função "EndGame()", após chamar a função "PhotonNetwork.LeaveRoom()", você pode adicionar a linha de código "PhotonNetwork.Destroy(gameObject)" para destruir a sala atual imediatamente. Isso garantirá que a sala não esteja mais disponível para outros jogadores se tentarem entrar.

Aqui está um exemplo de como ficaria a função "EndGame()" com a linha de código adicionada:

Código:

public void EndGame()
{
   PhotonNetwork.LeaveRoom();
   PhotonNetwork.Destroy(gameObject); // Destruir a sala atual
   SceneManager.LoadScene("LobbyScene");
}

Assim, quando um jogador clicar em procurar sala após a partida ter terminado e a sala ter sido destruída, ele não poderá entrar novamente na partida.

e que a sala que os jogadores entrar para jogar ela não e um prefabs os objetos que eles controlam ja estão na cena do jogo eles so assumem o controle dos objetos  nada e criado mesmo assim posso usar este comando? PhotonNetwork.Destroy(gameObject);

Magnatah escreveu:Sim, para evitar que a sala que acabou de ser encerrada fique disponível para outros jogadores, você pode destruí-la imediatamente após a partida terminar. Para fazer isso, você pode adicionar uma função que destrua a sala no final da partida.

Por exemplo, dentro da função "EndGame()", após chamar a função "PhotonNetwork.LeaveRoom()", você pode adicionar a linha de código "PhotonNetwork.Destroy(gameObject)" para destruir a sala atual imediatamente. Isso garantirá que a sala não esteja mais disponível para outros jogadores se tentarem entrar.

Aqui está um exemplo de como ficaria a função "EndGame()" com a linha de código adicionada:

Código:

public void EndGame()
{
   PhotonNetwork.LeaveRoom();
   PhotonNetwork.Destroy(gameObject); // Destruir a sala atual
   SceneManager.LoadScene("LobbyScene");
}

Assim, quando um jogador clicar em procurar sala após a partida ter terminado e a sala ter sido destruída, ele não poderá entrar novamente na partida.

isso deu certo quando finaliza a partida e destruido e a sala some.
agora tem outro problema e que por exemplo se tiver 3 jogadores na lista de sala quando os 2 iniciam a partida para o terceiro jogador mostra que existe ainda a sala. ele não consegue entrar mas ela esta la. ela so some se ele sair do lobby e voltar novamente como faço para ela sumir imediatamente? tipo algum codigo para atualizar no update ou algo assim?

Uma possível solução para esse problema é usar um sistema de atualização periódica da lista de salas disponíveis, de forma que a lista seja atualizada regularmente e as salas que não existem mais sejam removidas da lista.

Para isso, você pode adicionar uma nova função ao seu script que atualize a lista de salas disponíveis. Essa função pode ser chamada no início do jogo e a cada X segundos, por exemplo. Dentro dessa função, você pode verificar se cada sala ainda existe e remover as salas que não existem mais da lista.

Segue um exemplo de como implementar essa função:

Código:

public void UpdateRoomList()
{
    // Percorre a lista de salas
    for (int i = 0; i < roomList.Count; i++)
    {
        // Verifica se a sala ainda existe
        if (!PhotonNetwork.GetRoomList().ToList().Exists(x => x.Name == roomList[i].GetComponent<Room>().id))
        {
            // Se a sala não existe mais, remove da lista
            Destroy(roomList[i].gameObject);
            roomList.RemoveAt(i);
            i--;
        }
    }
}

Nesse exemplo, a função "PhotonNetwork.GetRoomList()" é usada para obter a lista atualizada de salas disponíveis na rede. O método "ToList()" é usado para converter o array de RoomInfo em uma lista, que permite o uso do método "Exists()" para verificar se a sala ainda existe na lista.

Você pode chamar essa função no início do jogo e a cada X segundos usando a função "InvokeRepeating()" do Unity, por exemplo:

Código:

void Start()
{
    // Chama a função UpdateRoomList a cada 5 segundos
    InvokeRepeating("UpdateRoomList", 0f, 5f);
}

Com essa solução, a lista de salas disponíveis será atualizada regularmente e as salas que não existem mais serão removidas da lista, evitando que os jogadores tentem entrar em salas que já foram encerradas.

Magnatah escreveu:Uma possível solução para esse problema é usar um sistema de atualização periódica da lista de salas disponíveis, de forma que a lista seja atualizada regularmente e as salas que não existem mais sejam removidas da lista.

Para isso, você pode adicionar uma nova função ao seu script que atualize a lista de salas disponíveis. Essa função pode ser chamada no início do jogo e a cada X segundos, por exemplo. Dentro dessa função, você pode verificar se cada sala ainda existe e remover as salas que não existem mais da lista.

Segue um exemplo de como implementar essa função:

Código:

public void UpdateRoomList()
{
    // Percorre a lista de salas
    for (int i = 0; i < roomList.Count; i++)
    {
        // Verifica se a sala ainda existe
        if (!PhotonNetwork.GetRoomList().ToList().Exists(x => x.Name == roomList[i].GetComponent<Room>().id))
        {
            // Se a sala não existe mais, remove da lista
            Destroy(roomList[i].gameObject);
            roomList.RemoveAt(i);
            i--;
        }
    }
}

como eu poderia encaixar este script no meu adicionei ele mas da erro no ( PhotonNetwork.GetRoomList) e tambem no (Destroy(roomList[i].gameObject)
o script que quero encaixar e o la de cima se poder me dar esta ajuda desde ja agradeço.