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:
Como resolver vazamento de memoria?
Procuro Pessoas para Projeto
Ativar o objeto correto em Clones.
[TUTORIAL] Como fazer um interruptor simples (Unity 2018)
Unity - RawImages e Renderizção com Câmera deixa o Jogo Lento e travnado
Preciso de 20 testadores jogo mobile
Jogo multiplayer com steam
O Labirinto II - Trailer Oficial
Ue posso divulgar meu game que ainda esta em criaçao aqui no forum?
[RESOLVIDO] Inverter o sprite para a direçao que o personagem anda.
Set Active não a reabiilitado C#
Build APK VR Google Cardbord com video.
[PROGRAMADOR FREELA] $$
Mais Um jogo!
Collider (mesh?)
[TUTORIAL] Deformar mesh com batidas (para objetos, veículos, etc)
WW2 Low poly Pack (Free)
Procuro freelancer
Novo Teaser do jogo Dark Age
Unity Admob Erro
DEATH ISLAND 0.2.5 SURVIVAL GAME 4 ANOS EM DESENVOLVIMENTO
Player travando na colisão com o chão Unity 2D
Sombras estão quadradas na build
nao consigo fazer o player sentar no sofa alguem me ajuda
Unity - Ao mudar de scene, todas as Lights são deletadas
210 Linhas de código para inimigo é muito grande?
modelar avatar e skins para um jogo web
ShapeKeys do Blender para a Unity altera áreas próximas
COMO EVITAR QUE UM OBJETO (PLAYER,ITEM ETC...) ATRAVESSE UMA PAREDE.
Ajuda em Script de Verificação de Ação e Reação
unity Failed to load PlayerSettings (internal index #0). Most likely data f
PRECISO FAZER QUE MEU GAME FIQUE ONLINE
Materiais do Blander não aparecem no MeshRendere do Objeto na Unity
Repetiçoes de Textura no Terreno
SERVER IS DOWN - UNITY+MSQL
Procuro programadores - Novo jogo
Problema com o MS VEHICLES
Preciso de ajuda com a Unity
Problema com vídeo em 360° na Unity
Problemas no MS Vehicles
unity- eventos na Animação com Armature/Bones vinda do blender não funciona
ajuda exibir resultados simulados em uma liga Game Unity
Unity - ParticleSystem não é redirecionado no rawimage no canvas
Como resolver o problema de "face orientation" no Blender.
[DÚVIDA] Tive um problema com meu Canvas
erro na Directional Light
Problemas com o Directional Light da Unity 3D
Novo jogo da franquia Sphere game em desenvolvimento
malha da roda não girando com wheel collider unity
Problemas com ambiguidade
Touch mobile
INVALID TOKEN
Como acessar o "HD Render Pipeline" do HDRP por script?
CHAT GPT PRA JOGO DE TIRO? comentem
Tutorial script inimigo segue e foge do player
Ainda vale a pena lançar Asset na Asset Store?
Ajuda com tabela de historico de pontuaçao.
[TUTORIAL] Entrar no carro estilo GTA
Como derrapar um Whell Collider
Como altertar o valor do "Asymptote Value" do Whell Collider via Script
Preciso de ajuda para substituir valor de variavel em outro script
Ajuda com Top Down Shooter utilizando Photon
Duvida com Netcode
[RESOLVIDO] Unity - Movendo a Câmera na Horizontal/Vertical com Touch
Alguém me ajuda com os anúncios pfv
Segundo Trailer do jogo Dark Age, Feliz Natal a todos!
Unity - ScrollRect, Viewport, Content - O Conteúdo ñ inicia no topo
Coleta de itens
Unity - Cadastro do email do jogador
[GRATIS] PACK DE MODELOS 3D PARA JOGO DE TERROR
Onde Conseguir músicas para meu Jogo?
error CS0246 em Script
Alguem teve ja esse problema?
[Projeto em Andamento] Draug, um jogo de hordas
DISPONIVEL PARA FAZER MODELOS 3D
Unity-Loja.Como os Jogadores terão acesso aos ítens comprados na PlayStore?
Bugando depois do Build.
Primeiro Trailer do jogo Dark Age
Problema com sombra
Mesh e Material do objeto trocando para uma instancia no inicio do jogo
[RESOLVIDO] Unity - RawImages_Layer_Camera
INVESTIMENTO EM JOGOS E BANCO DE TALENTO
Teaser do meu novo projeto pessoal, Dark Age
Preciso de ajuda com mudança para mobile androide.
[RESOLVIDO] Posição final do objeto em jogo 2D
Input.GetAxis() obedercer a orientação de um objeto.
Interação com elementos UI
Meu primeiro jogo na steam
Minimap/Radar/GPS Estilo GTA V
[RESOLVIDO] Erro no console depois que formatei o pc
PACK GRÁTIS de Músicas ELETRÔNICAS para ajudar vocês em seus Jogos Indies!
[TUTORIAL] Entenda como funciona: ENUM, SWITCH, BREAK, CASE no C#
O Labirinto II - Baixe o Jogo
Qual e o codigo de Botões na unity para saber seus estados?
Como carregar itens pequenos dentro do carro sem que atravesse os colliders
[Duvida] Script pegar itens
Travamento ao trocar de cena
Colisão zoada e movimentação
Salvar objetos que foram destruidos entre cenas na unity
Seg Jul 15, 2024 7:02 pm
Dom Jul 14, 2024 11:24 pm
Sáb Jul 13, 2024 12:33 am
Qui Jun 27, 2024 5:49 pm
Sáb Jun 22, 2024 9:05 pm
Qui Jun 20, 2024 12:30 pm
Sáb Jun 15, 2024 6:43 am
Dom Jun 09, 2024 7:43 pm
Dom Jun 09, 2024 2:16 pm
Seg Jun 03, 2024 11:39 am
Seg maio 27, 2024 12:45 pm
Seg maio 20, 2024 9:01 pm
Dom maio 19, 2024 3:08 pm
Sáb maio 18, 2024 11:46 am
Sáb maio 11, 2024 8:55 am
Qui maio 09, 2024 11:33 pm
Seg Abr 29, 2024 9:34 pm
Qui Abr 25, 2024 3:34 pm
Seg Abr 22, 2024 5:15 pm
Seg Abr 15, 2024 12:23 pm
Qua Abr 10, 2024 1:33 am
Ter Abr 09, 2024 10:28 am
Seg Abr 08, 2024 9:27 pm
Seg Abr 08, 2024 8:01 am
Sáb Abr 06, 2024 8:05 pm
Qui Abr 04, 2024 11:34 pm
Qui Abr 04, 2024 11:13 pm
Sex Mar 22, 2024 2:41 pm
Dom Mar 10, 2024 2:30 pm
Sex Mar 01, 2024 1:27 pm
Qui Fev 22, 2024 9:57 pm
Ter Fev 20, 2024 9:28 am
Ter Fev 20, 2024 12:15 am
Seg Fev 19, 2024 1:06 pm
Seg Fev 12, 2024 1:56 pm
Seg Fev 12, 2024 1:17 pm
Dom Fev 11, 2024 8:55 pm
Dom Fev 11, 2024 11:16 am
Seg Fev 05, 2024 4:18 pm
Dom Fev 04, 2024 9:39 pm
Qua Jan 31, 2024 11:59 pm
Ter Jan 30, 2024 7:37 pm
Ter Jan 23, 2024 6:33 pm
Dom Jan 21, 2024 6:03 pm
Sáb Jan 20, 2024 7:03 pm
Sáb Jan 20, 2024 6:58 pm
Sáb Jan 20, 2024 6:39 pm
Sex Jan 19, 2024 8:40 am
Dom Jan 14, 2024 5:30 pm
Qua Jan 10, 2024 10:29 pm
Qua Jan 10, 2024 8:55 pm
Qua Jan 10, 2024 7:14 pm
Ter Jan 09, 2024 3:55 pm
Ter Jan 09, 2024 8:04 am
Sáb Jan 06, 2024 8:02 pm
Sex Jan 05, 2024 7:01 am
Sex Jan 05, 2024 12:12 am
Qui Jan 04, 2024 6:55 pm
Qui Jan 04, 2024 12:52 pm
Qui Jan 04, 2024 4:34 am
Ter Jan 02, 2024 11:48 pm
Dom Dez 31, 2023 7:25 pm
Qua Dez 27, 2023 5:44 pm
Qua Dez 27, 2023 3:08 pm
Sáb Dez 23, 2023 7:27 pm
Sáb Dez 23, 2023 5:06 pm
Qui Dez 21, 2023 8:10 pm
Seg Dez 18, 2023 2:04 pm
Sex Dez 15, 2023 5:11 pm
Qui Dez 14, 2023 9:13 pm
Qui Dez 14, 2023 2:47 pm
Qui Dez 14, 2023 1:48 pm
Qua Dez 13, 2023 8:58 pm
Ter Dez 12, 2023 2:32 pm
Seg Dez 11, 2023 1:53 pm
Qua Dez 06, 2023 8:13 pm
Sáb Dez 02, 2023 8:06 pm
Qui Nov 30, 2023 7:49 am
Seg Nov 27, 2023 1:35 am
Qua Nov 22, 2023 7:37 am
Qui Nov 09, 2023 1:22 pm
Seg Nov 06, 2023 11:59 am
Ter Out 31, 2023 9:53 am
Dom Out 29, 2023 8:05 pm
Dom Out 29, 2023 3:03 am
Sex Out 27, 2023 3:43 pm
Sex Out 27, 2023 3:28 pm
Qua Out 25, 2023 1:20 pm
Seg Out 23, 2023 10:34 am
Dom Out 22, 2023 6:55 pm
Qui Out 19, 2023 11:57 pm
Qui Out 19, 2023 6:39 pm
Ter Out 17, 2023 6:37 pm
Ter Out 17, 2023 6:18 pm
Seg Out 16, 2023 1:59 pm
Sáb Out 14, 2023 12:15 pm
Qua Out 11, 2023 6:07 pm
Seg Out 09, 2023 4:19 pm
Qua Out 04, 2023 12:12 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 : 1535
REPUTAÇÃO : 38
Idade : 37
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 : 3419
REPUTAÇÃO : 208
Idade : 24
Á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

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 : 1535
REPUTAÇÃO : 38
Idade : 37
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 : 3419
REPUTAÇÃO : 208
Idade : 24
Á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

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 : 1535
REPUTAÇÃO : 38
Idade : 37
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 : 1535
REPUTAÇÃO : 38
Idade : 37
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 : 3419
REPUTAÇÃO : 208
Idade : 24
Á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

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 : 3419
REPUTAÇÃO : 208
Idade : 24
Á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

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 : 1535
REPUTAÇÃO : 38
Idade : 37
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