SchultzGames
Para tirar dúvidas, crie um tópico especifico na área "Dúvidas em Geral" e aguarde ser respondido. Evite comentar em tópicos não relacionados a sua dúvida :D
TÓPICOS RECENTES:
Tópico:
Postado em:
Postado por:
[RESOLVIDO] Unity - Scrollbar não funciona
[TUTORIAL] AI que cria scripts para você, inclusive scripts para Unity !!!!
[RESOLVIDO] Animando Image na Unity não funciona
Aplicativo para IOS
Hospedar um jogo multiplay na itch.io
Unity -TextMeshProUGUI- 1 das coisas q estão deixando a scene lenta p abrir
Script para detetectar o movimento do player
Alguém ajuda com um erro por favor? PSDImporter.cs
[RESOLVIDO] - Unity - Rotação da Câmera - Mathf.Clamp não funciona
Alterar textura .unity3d
Comportamento do movimento do inimigo. Sair do caminho e Fugir
Procuro uma equipe
Ajuda Com Sala de Jogo Multiplayer
COMO FAZER A PORTA ABRIR SÓ EMPURRANDO ELA COM O PLAYER?
Visual Studio - Vend os Scripts na Aba "Modo de Exibição de Classe" soltos
app fica fechendo após mobile notification
[RESOLVIDO] Controlar dois player dentro de um jogo multiplay usando mirror
Unity - O Jogo fecha quando vai abrir a Scene
[TUTORIAL] Mudando material
Procuro programador Unity para jogo 2D
AJUDA REALISTIC CAR CONTROLLER
Chama para isqueiro
[RESOLVIDO] Ajuda para destruir objeto
Unity - Sistema de Giro da Tela - Ajuda pfv!
Unity - Touch na Tela do Celular
Dawn Of Hell - Horror Game BR (2022-2023)
Unity - Jogo online ou offline?
ANIMAÇÃO INIMIGO ESTÁ INDO PRA TUDO QUANTO É LADO
[RESOLVIDO] Erro de Script no Android
Bundle Assets, Resources, e Addressables
Jogo online (qual a melhor opção?)
Dúvida sobre como criar o inimigo IA!
Unity dando pause no jogo a cada 4 segundos
bom dia amigos eu sou meio lego nos scripts será que alguem pode me ajudar
JOGO "CHALLENGE" FINALIZADO E DISPONÍVEL PARA BAIXAR.
error CS0246
[TUTORIAL]Como Chamar Um Método Usando Uma String como Parametro
[TUTORIAL] Sistema de FPS com Corpo
NullReferenceException: Object reference not set to an instance
dúvida ao criar subscription no play console
Unity - Scene Demorando pra abrir
Erro Slider de Cor
Alguem sabe que tipo de antena é essa ?
Encontrando um ponto de colisão.
Preciso de vocess! Coisinha simples mais me embananei. Meu primeiro game.
[TUTORIAL] Como carregar uma cena em segundo plano?
push notification com firebase falha
PROCURO UMA EQUIPE - Pagamento VIA PIX
Testem Meu Novo Jogo WEBGL ANDROIDD
ajuste de tela automático de celular
como fazer um chat interativo offline?
Música grátis para Jogos Indies [Calma, Relaxante, Flauta e outras coisas]
PROCURO PROGRAMADOR EXPERIENTE PHOTON
problema com canvas ui button
Banco de dados em Unity v2021.3.4f1
Sistema de Yu-Gi-Oh! - LINK PARA DOWNLOAD 2023
Int de dinheiro fica com numeros negativos em vez de travar no "0"
UNITY - FORMAÇÃO DE EQUIPE
[TUTORIAL] Open World Project - Para Unity-
Tutorial + Kit Para Criar seu Game Multiplayer em 5 Minutos
Como fazer movimentação no estilo tunnel Rush
[RESOLVIDO] Ajuste de tela
Debugar erro ao fechar build do projeto
[RESOLVIDO] Como Suavizar transição de uma Animação pra outra
[RESOLVIDO] Fixar tamanho/resolução proporcional da janela da aplicação
Como faço pra chamar a funçao de um script em outro ?
[RESOLVIDO] Alterar variaveis de classes instanciadas no inspector
como fazer o objeto spawnar com uma cor aleatória dentre as que eu quero?
Blender-Cell Fracture - Juntar as Animações de Todos os Fragmentos em 1 só
Oque acham dessa pequena música?
Unity - Faz mal ou tem algum problema se usar mts Layers?
Drag and drop em um rect específico da UI
Inimigo mudar de animação
[RESOLVIDO] Texto aparecer tipo donkey kong
De 0 a 10, qual a chance de isso causar problemas legais ao vender o jogo?
Teaser do meu novo projeto, War land
SCRIPT QUE SALVA A CENA INTEIRA.
datebest.net - visit link to find love or quick sex !
[RESOLVIDO] Dropdown Salvar a Resolução da tela
[RESOLVIDO] Visual Studio - Como saber onde um método está sendo usado
Teste Chat Openai
Como alterar um GameObject dentro de uma array
Baixos Brasil - Jogo de Carro Brasileiro!
Erro il2cpp unity 2022
[RESOLVIDO] "Is Trigger" não funcionando
FORMAÇÃO DE EQUIPE UNITY 3D
Equipamento para usar no Cinemachine
[RESOLVIDO] Destruir objetos com o mesmo id
Salvar seleção do Toggle
Fiz uma música orquestral para uma batalha final contra um Boss
Como você foi Hackeado DENOVO!!!???
PROCURO UMA EQUIPE - Pagamento VIA Pix
PROCURO PROGRAMADOR EXPERIENTE EM MIRROR
Visual Studio - Como abrir um Script com determinada configuração?
Mover objeto no eixo y
EXPORTAR CENA EM FORMATO DE VIDEO?
LANÇAMENTO JOGO DE CARRO E MOTO PARA ANDROID
Como fazer um sistema para trocar musica da cena com DROPDOWN?
SOU MODELADOR
Qui Mar 23, 2023 4:52 pm
Ter Mar 21, 2023 11:20 pm
Ter Mar 21, 2023 8:52 pm
Ter Mar 21, 2023 4:00 pm
Sáb Mar 18, 2023 8:41 pm
Sáb Mar 18, 2023 4:35 pm
Sex Mar 17, 2023 3:12 pm
Sex Mar 17, 2023 1:24 pm
Seg Mar 13, 2023 10:45 pm
Seg Mar 13, 2023 9:48 pm
Seg Mar 13, 2023 8:24 pm
Seg Mar 13, 2023 7:17 pm
Dom Mar 12, 2023 10:27 pm
Dom Mar 12, 2023 7:22 pm
Sex Mar 10, 2023 8:26 pm
Sex Mar 10, 2023 8:00 pm
Qui Mar 09, 2023 9:05 am
Ter Mar 07, 2023 2:27 pm
Sex Mar 03, 2023 6:47 pm
Sex Mar 03, 2023 12:01 am
Qui Mar 02, 2023 4:00 pm
Qui Mar 02, 2023 1:35 pm
Qua Mar 01, 2023 5:47 pm
Qua Mar 01, 2023 2:11 am
Seg Fev 27, 2023 11:08 pm
Seg Fev 27, 2023 7:19 pm
Dom Fev 26, 2023 11:49 pm
Dom Fev 26, 2023 8:29 pm
Dom Fev 26, 2023 7:47 pm
Dom Fev 26, 2023 7:46 pm
Dom Fev 26, 2023 6:08 pm
Sáb Fev 25, 2023 8:16 pm
Seg Fev 13, 2023 7:02 pm
Seg Fev 13, 2023 2:44 am
Dom Fev 12, 2023 9:57 pm
Dom Fev 12, 2023 2:19 pm
Sáb Fev 11, 2023 1:01 pm
Sex Fev 10, 2023 11:14 pm
Sex Fev 10, 2023 8:18 pm
Sex Fev 10, 2023 7:46 pm
Qui Fev 09, 2023 11:29 pm
Qui Fev 09, 2023 11:01 pm
Qui Fev 09, 2023 5:42 pm
Qua Fev 08, 2023 2:20 pm
Ter Fev 07, 2023 11:47 pm
Seg Fev 06, 2023 8:24 pm
Seg Fev 06, 2023 5:40 pm
Dom Fev 05, 2023 12:53 am
Sáb Fev 04, 2023 3:42 pm
Sáb Fev 04, 2023 2:29 pm
Sáb Fev 04, 2023 12:07 am
Sex Fev 03, 2023 10:53 pm
Sex Fev 03, 2023 10:28 pm
Qui Fev 02, 2023 7:52 pm
Qui Fev 02, 2023 8:49 am
Qua Fev 01, 2023 5:56 pm
Ter Jan 31, 2023 1:00 am
Dom Jan 29, 2023 11:12 pm
Sáb Jan 28, 2023 6:50 pm
Sex Jan 27, 2023 8:52 pm
Sex Jan 27, 2023 4:53 am
Qui Jan 26, 2023 10:56 pm
Dom Jan 22, 2023 11:53 am
Dom Jan 22, 2023 3:33 am
Sáb Jan 21, 2023 3:27 pm
Sáb Jan 21, 2023 2:15 pm
Sex Jan 20, 2023 4:30 pm
Sex Jan 20, 2023 2:15 pm
Qua Jan 18, 2023 10:19 pm
Qua Jan 18, 2023 9:47 am
Ter Jan 17, 2023 10:52 pm
Ter Jan 17, 2023 4:08 pm
Ter Jan 17, 2023 2:45 pm
Seg Jan 16, 2023 7:20 pm
Seg Jan 16, 2023 12:18 pm
Dom Jan 15, 2023 3:02 pm
Sáb Jan 14, 2023 7:02 pm
Sex Jan 13, 2023 8:29 am
Qui Jan 12, 2023 5:15 am
Qui Jan 12, 2023 2:31 am
Qua Jan 11, 2023 1:33 pm
Ter Jan 10, 2023 11:55 am
Ter Jan 10, 2023 10:58 am
Ter Jan 10, 2023 3:04 am
Seg Jan 09, 2023 10:43 pm
Seg Jan 09, 2023 6:30 am
Seg Jan 09, 2023 3:18 am
Seg Jan 09, 2023 2:32 am
Sáb Jan 07, 2023 5:55 pm
Sáb Jan 07, 2023 4:01 pm
Sáb Jan 07, 2023 1:38 pm
Sex Jan 06, 2023 9:15 am
Sex Jan 06, 2023 6:33 am
Qui Jan 05, 2023 5:27 pm
Qui Jan 05, 2023 2:50 pm
Qua Jan 04, 2023 3:07 pm
Qua Jan 04, 2023 9:19 am
Sáb Dez 31, 2022 4:38 pm
Sáb Dez 31, 2022 3:18 am



































































































Ajuda Com Sala de Jogo Multiplayer

2 participantes

Ir para baixo

DÚVIDA Ajuda Com Sala de Jogo Multiplayer

Mensagem por claudiano2020 Sáb Mar 11, 2023 9:17 pm

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
claudiano2020
claudiano2020
Avançado
Avançado

Masculino PONTOS : 1040
REPUTAÇÃO : 37
Idade : 36
Respeito as regras : Ajuda Com Sala de Jogo Multiplayer WvDYdlf

Ir para o topo Ir para baixo

DÚVIDA Re: Ajuda Com Sala de Jogo Multiplayer

Mensagem por Magnatah Sáb Mar 11, 2023 9:33 pm

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
Magnatah
Instrutor

Masculino PONTOS : 2841
REPUTAÇÃO : 188
Idade : 27
Áreas de atuação : Dєรєиvσlvєdσя Wєb(Fяσит-єиd), Blєиdєя, υиiтy, C#, ρнρ є Jαvαรcяiρт.
Respeito as regras : Ajuda Com Sala de Jogo Multiplayer Aad8pUi

https://www.instagram.com/ampercygames/

Ir para o topo Ir para baixo

DÚVIDA Re: Ajuda Com Sala de Jogo Multiplayer

Mensagem por claudiano2020 Dom Mar 12, 2023 3:37 pm

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?
claudiano2020
claudiano2020
Avançado
Avançado

Masculino PONTOS : 1040
REPUTAÇÃO : 37
Idade : 36
Respeito as regras : Ajuda Com Sala de Jogo Multiplayer WvDYdlf

Ir para o topo Ir para baixo

DÚVIDA Re: Ajuda Com Sala de Jogo Multiplayer

Mensagem por Magnatah Dom Mar 12, 2023 6:06 pm

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
Magnatah
Instrutor

Masculino PONTOS : 2841
REPUTAÇÃO : 188
Idade : 27
Áreas de atuação : Dєรєиvσlvєdσя Wєb(Fяσит-єиd), Blєиdєя, υиiтy, C#, ρнρ є Jαvαรcяiρт.
Respeito as regras : Ajuda Com Sala de Jogo Multiplayer Aad8pUi

https://www.instagram.com/ampercygames/

Ir para o topo Ir para baixo

DÚVIDA Re: Ajuda Com Sala de Jogo Multiplayer

Mensagem por claudiano2020 Dom Mar 12, 2023 7:21 pm

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);
claudiano2020
claudiano2020
Avançado
Avançado

Masculino PONTOS : 1040
REPUTAÇÃO : 37
Idade : 36
Respeito as regras : Ajuda Com Sala de Jogo Multiplayer WvDYdlf

Ir para o topo Ir para baixo

DÚVIDA Re: Ajuda Com Sala de Jogo Multiplayer

Mensagem por claudiano2020 Dom Mar 12, 2023 8:44 pm

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?
claudiano2020
claudiano2020
Avançado
Avançado

Masculino PONTOS : 1040
REPUTAÇÃO : 37
Idade : 36
Respeito as regras : Ajuda Com Sala de Jogo Multiplayer WvDYdlf

Ir para o topo Ir para baixo

DÚVIDA Re: Ajuda Com Sala de Jogo Multiplayer

Mensagem por Magnatah Dom Mar 12, 2023 8:57 pm

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--;
        }
    }
}
Magnatah
Magnatah
Instrutor

Masculino PONTOS : 2841
REPUTAÇÃO : 188
Idade : 27
Áreas de atuação : Dєรєиvσlvєdσя Wєb(Fяσит-єиd), Blєиdєя, υиiтy, C#, ρнρ є Jαvαรcяiρт.
Respeito as regras : Ajuda Com Sala de Jogo Multiplayer Aad8pUi

https://www.instagram.com/ampercygames/

Ir para o topo Ir para baixo

DÚVIDA Re: Ajuda Com Sala de Jogo Multiplayer

Mensagem por Magnatah Dom Mar 12, 2023 8:58 pm

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
Magnatah
Instrutor

Masculino PONTOS : 2841
REPUTAÇÃO : 188
Idade : 27
Áreas de atuação : Dєรєиvσlvєdσя Wєb(Fяσит-єиd), Blєиdєя, υиiтy, C#, ρнρ є Jαvαรcяiρт.
Respeito as regras : Ajuda Com Sala de Jogo Multiplayer Aad8pUi

https://www.instagram.com/ampercygames/

Ir para o topo Ir para baixo

DÚVIDA Re: Ajuda Com Sala de Jogo Multiplayer

Mensagem por claudiano2020 Dom Mar 12, 2023 10:27 pm

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)Piscadinha
o script que quero encaixar e o la de cima se poder me dar esta ajuda desde ja agradeço.
claudiano2020
claudiano2020
Avançado
Avançado

Masculino PONTOS : 1040
REPUTAÇÃO : 37
Idade : 36
Respeito as regras : Ajuda Com Sala de Jogo Multiplayer WvDYdlf

Ir para o topo Ir para baixo

Ir para o topo

- Tópicos semelhantes

 
Permissões neste sub-fórum
Não podes responder a tópicos