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] Ausencia da funçao NavMesh na Unity 2022.2.12
Interação com elementos UI
[_____IMPORTANTE_____] ALTERAÇÕES NA POLÍTICA DE COBRANÇA DA UNITY - 2
Roll Up Um jogo de aventura e desáfios
Terminologia da Unity em outras engines
Como criar a iluminação do Sol no Sistema Solar?
Unity - SceneManager.LoadScene abre scene com objeto "vazio"
Conexão de lobby pelo OnConnectedToMaster
Problema na exportção de projeto unity
[RESOLVIDO] Unity - Áudios estão emitindo som só Depois do Botão ser solto
Unity - Banco de Dados Online junto ao Jogo
Player virar para o inimigo(Prefab)
[_____IMPORTANTE_____] ALTERAÇÕES NA POLÍTICA DE COBRANÇA DA UNITY
[TUTORIAL] Sistema De Save Game Ao Sair Da Fase
Problema de Sincronização de um objeto de um jogo multiplayer usa q Photon
Unity - Compartilhar meu Jogo
Alguém que manja do Google ADmob?
Unity - Avaliar meu Jogo
[RESOLVIDO] Destruir inimigo com o player.
Salvar e carregar dados na Unity de objetos prefabs sem sobrescrever os dad
Unity - Salvar os Dados do Jogador Online
Input.GetAxis() obedercer a orientação de um objeto.
ajuda com o sistema de drag and drop com controle no invetario
Como executar outros blocos fora do bloco static void Main()
Usando a biblioteca UnityEngine fora da Unity
Mixamo - Character Gratuito?
Touch mobile
Erro NullReferenceException Não consigo resolver
Criador de Sites Freelancer DISPONIVEL!!!
Unity - Não deixar o Jogador alterar o Jogo pelo regedit do pc?
Tiro com Botao UI (ME AJUDEM)
[Projeto em Andamento] Draug, um jogo de hordas
Vagas de programadores e modeladores para startup
Consigo herdar/ copiar parâmetros do animator da unity?
O que seriam os códigos-fonte?
[RESOLVIDO] Unity Vulkan - Out of memory! (allocating memory for image)
Unity Problema de Vírus
[TUTORIAL] Como fazer uma gota de água na Unity
Mirror ou Photon Pun 2 ??? para Mobile
Character Player Modular
Icones não aparecem na Interface da Unity
Verificar se player está posado em blogo
Logica para criar (Player, Inventario, Arma) - Mobile
Sistema de pegar passageiros
Trailer Final de O Labirinto II
Meu jogo não conecta no google play games
ALGUEM ME AJUDA PFV
Problema tentando inserir "Sprite"
Oferto Serviço Programação para Jogos
FAZER AÇÂO AO ENTRAR NO CAMPO DA CAMERA
[RESOLVIDO] QUEBRA DE LINHA NO PLACEHOLDER. Nao lembro como que faz
Unity - Qual o Limite Máximo de Linhas em um Script para q ele fique Leve?
movimento 2d
Alguém que ja publicou na steam pode me ajudar com isso?
Animação Unity toda bugada
UDaySurvival - Jogo de sobrevivência de mundo aberto para mobile!https://yo
Trailer do meu jogo O Labirinto II
Jogo Atisk (Trailer)
Adicionem meu jogo na lista de desejos
Discord!
Como executar a void de um outro scrypt
Shader não funciona no Unity URP
Jogo Mobile - Ultimate Flight Simulator - Real World SDK
Unity - FPS e CPU ???
Usar microfone na Unity
Jogo ficando escuro quando faço a Build pela cena menu
Dúvida sobre movimentação do personagem
[RESOLVIDO] ACESSAR SCRIPT DE OUTRO GAMEOBJECT
Para eu ter shader em meu projeto eu tenho que usar o hdrp ou o 3d padrao?
Rotate Camera Mobile
Sou modelador 3d (!!! Arquitetonico!!!) Disponivel !!!!!!
Preciso de alguém que saiba programação e Raycast
Servidor/cliente usando sockets
Assets carregados com addressables causando erro na versão "buildada"
Jogo multiplayer com salas - não vai para o lobby
Texto - Não escreve no 'play'. Clica mais não digita.
Câmera Não esta renderizando na segunda janela.
Movimento da Câmera No Android
[RESOLVIDO] - Unity não está mais funcionando o "Build and Run"
Precisa de modelador com ou sem experiência
Duvida com "mesclagem" de animação
Missoes Aparecerem aleatoriamente do nada
Dúvida pafra IOS
botoes não esta funcionando corretamente nem a fisica?
Duvida com NavMeshAgent
COMO AUMENTAR E DIMINUÍ A SENSIBILIDADE DO TOQUE POR CÓDICO (MOBILE)
A Licença da Unity só funciona se eu tiver Internet
Problema com OnTriggerEnter
Transparência ao colidir
bool para evitar de salvar frames repetido
Unity - Transições no AnimatorController rodando errado
problemas com "wall Jump" , atribuir força ao eixo X
Meu Jogo ja Esta Pronto! EXPERIMENTEM!!
JOSTICK NAO SE MOVE
botoes para mobile
ERRO NO SCRIPT FOME E SEDE ETC
CORTAR ARVORES E DROPAR
Configurar sistema
Unity - Sugestões da Loja
Hoje à(s) 2:10 pm
Hoje à(s) 12:32 pm
Ontem à(s) 9:01 pm
Qui Set 21, 2023 11:04 am
Qua Set 20, 2023 4:40 pm
Qua Set 20, 2023 9:15 am
Dom Set 17, 2023 7:12 pm
Dom Set 17, 2023 12:17 pm
Sex Set 15, 2023 7:24 pm
Sex Set 15, 2023 5:41 pm
Sex Set 15, 2023 4:28 pm
Sex Set 15, 2023 10:56 am
Sex Set 15, 2023 10:22 am
Sex Set 15, 2023 10:15 am
Seg Set 11, 2023 11:43 am
Seg Set 11, 2023 11:31 am
Sáb Set 09, 2023 4:53 pm
Sáb Set 09, 2023 1:44 pm
Ter Set 05, 2023 11:12 pm
Ter Set 05, 2023 3:12 pm
Seg Set 04, 2023 11:53 pm
Seg Set 04, 2023 7:39 pm
Dom Set 03, 2023 9:47 pm
Sáb Set 02, 2023 11:53 am
Sex Set 01, 2023 2:21 pm
Qui Ago 31, 2023 8:19 pm
Qui Ago 31, 2023 6:15 pm
Qua Ago 30, 2023 11:21 am
Ter Ago 29, 2023 8:43 pm
Seg Ago 28, 2023 7:18 pm
Sáb Ago 26, 2023 4:49 pm
Sáb Ago 26, 2023 4:38 pm
Qui Ago 17, 2023 1:56 am
Qua Ago 16, 2023 10:21 pm
Seg Ago 14, 2023 12:28 pm
Dom Ago 06, 2023 5:24 pm
Dom Ago 06, 2023 10:58 am
Qui Ago 03, 2023 9:38 am
Qua Ago 02, 2023 8:20 am
Ter Ago 01, 2023 6:07 pm
Dom Jul 30, 2023 5:43 pm
Sáb Jul 29, 2023 7:24 pm
Qui Jul 27, 2023 9:27 am
Seg Jul 24, 2023 11:12 am
Seg Jul 24, 2023 12:44 am
Seg Jul 24, 2023 12:37 am
Seg Jul 24, 2023 12:17 am
Seg Jul 24, 2023 12:10 am
Qua Jul 19, 2023 11:37 am
Ter Jul 18, 2023 7:12 pm
Qua Jul 12, 2023 9:49 am
Ter Jul 11, 2023 8:58 am
Ter Jul 11, 2023 1:03 am
Seg Jul 10, 2023 9:10 pm
Sex Jul 07, 2023 4:14 pm
Ter Jul 04, 2023 12:11 am
Sex Jun 30, 2023 8:10 pm
Qui Jun 29, 2023 5:19 pm
Qui Jun 29, 2023 3:40 pm
Ter Jun 27, 2023 1:45 am
Seg Jun 19, 2023 11:03 am
Dom Jun 18, 2023 6:11 pm
Dom Jun 04, 2023 2:41 pm
Ter maio 30, 2023 7:28 pm
Ter maio 30, 2023 6:04 am
Seg maio 29, 2023 7:53 pm
Sáb maio 27, 2023 3:11 pm
Sex maio 26, 2023 4:59 pm
Sex maio 26, 2023 11:27 am
Qui maio 25, 2023 10:33 am
Sáb maio 20, 2023 12:25 pm
Ter maio 16, 2023 5:43 pm
Ter maio 16, 2023 5:42 pm
Ter maio 09, 2023 7:42 pm
Seg maio 08, 2023 7:13 am
Seg maio 08, 2023 6:38 am
Sáb maio 06, 2023 11:44 pm
Sáb maio 06, 2023 6:42 pm
Sáb maio 06, 2023 1:35 am
Qua maio 03, 2023 12:32 pm
Seg maio 01, 2023 8:51 pm
Dom Abr 30, 2023 8:49 pm
Dom Abr 30, 2023 5:06 pm
Sáb Abr 29, 2023 4:05 pm
Qui Abr 27, 2023 4:39 pm
Qui Abr 27, 2023 12:40 am
Ter Abr 25, 2023 5:33 pm
Ter Abr 25, 2023 10:23 am
Dom Abr 23, 2023 12:11 am
Sáb Abr 22, 2023 4:27 am
Sex Abr 21, 2023 11:38 pm
Sex Abr 21, 2023 10:21 pm
Qui Abr 20, 2023 4:57 pm
Qui Abr 20, 2023 12:28 pm
Qua Abr 19, 2023 3:03 pm
Qua Abr 19, 2023 1:52 pm
Qua Abr 19, 2023 11:59 am
Qua Abr 19, 2023 11:54 am
Sáb Abr 15, 2023 8:13 pm



































































































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 : 1231
REPUTAÇÃO : 38
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 : 3091
REPUTAÇÃO : 204
Idade : 28
Á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 : 1231
REPUTAÇÃO : 38
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 : 3091
REPUTAÇÃO : 204
Idade : 28
Á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 : 1231
REPUTAÇÃO : 38
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 : 1231
REPUTAÇÃO : 38
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 : 3091
REPUTAÇÃO : 204
Idade : 28
Á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 : 3091
REPUTAÇÃO : 204
Idade : 28
Á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 : 1231
REPUTAÇÃO : 38
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