/// <summary> /// Don't use this method directly, unless you know how to cache and apply customActorProperties. /// The PhotonNetwork methods will handle player and room properties for you and call this method. /// </summary> public virtual bool OpCreateRoom(string roomName, RoomOptions roomOptions, TypedLobby lobby, Hashtable playerProperties, bool onGameServer) { if (this.DebugOut >= DebugLevel.INFO) { this.Listener.DebugReturn(DebugLevel.INFO, "OpCreateRoom()"); } Dictionary<byte, object> op = new Dictionary<byte, object>(); if (!string.IsNullOrEmpty(roomName)) { op[ParameterCode.RoomName] = roomName; } if (lobby != null) { op[ParameterCode.LobbyName] = lobby.Name; op[ParameterCode.LobbyType] = (byte)lobby.Type; } if (onGameServer) { if (playerProperties != null && playerProperties.Count > 0) { op[ParameterCode.PlayerProperties] = playerProperties; op[ParameterCode.Broadcast] = true; // TODO: check if this also makes sense when creating a room?! // broadcast actor properties } if (roomOptions == null) { roomOptions = new RoomOptions(); } Hashtable gameProperties = new Hashtable(); op[ParameterCode.GameProperties] = gameProperties; gameProperties.MergeStringKeys(roomOptions.customRoomProperties); gameProperties[GameProperties.IsOpen] = roomOptions.isOpen; // TODO: check default value. dont send this then gameProperties[GameProperties.IsVisible] = roomOptions.isVisible; // TODO: check default value. dont send this then gameProperties[GameProperties.PropsListedInLobby] = roomOptions.customRoomPropertiesForLobby; if (roomOptions.maxPlayers > 0) { gameProperties[GameProperties.MaxPlayers] = roomOptions.maxPlayers; } if (roomOptions.cleanupCacheOnLeave) { op[ParameterCode.CleanupCacheOnLeave] = true; // this is actually setting the room's config gameProperties[GameProperties.CleanupCacheOnLeave] = true; // this is only informational for the clients which join } } // UnityEngine.Debug.Log("CreateGame: " + SupportClass.DictionaryToString(op)); return this.OpCustom(OperationCode.CreateGame, op, true); }
void OnPhotonRandomJoinFailed() { Debug.Log("No Room!"); RoomOptions option = new RoomOptions(); option.isVisible = true; option.isOpen = true; option.maxPlayers = 20; TypedLobby typedLobby = new TypedLobby(); PhotonNetwork.CreateRoom("MyRoom", option, typedLobby); }
void OnPhotonRandomJoinFailed() { // ルームを作成、部屋名は今回はnullに設定 //PhotonNetwork.CreateRoom(null); //PhotonNetwork.CreateRoom(mRoomName, new RoomOptions() { maxPlayers = 4 }, null); Debug.Log("Create"); RoomOptions roomOptions = new RoomOptions (); roomOptions.isVisible = true; roomOptions.isOpen = true; roomOptions.maxPlayers = 4; //roomOptions.customRoomProperties = new ExitGames.Client.Photon.Hashtable() { { "CustomProperties", 0000 } }; //roomOptions.customRoomPropertiesForLobby = new string[] { "CustomProperties" }; TypedLobby sqlLobby = new TypedLobby("myLobby", LobbyType.SqlLobby); PhotonNetwork.CreateRoom(mRoomName, roomOptions, TypedLobby.Default); }
public void JoinRoom() { if (PhotonNetwork.IsConnected) { string roomName = nombreServer.GetComponent <Text>().text; if (roomName == "") { Log.text += "\nIntroduce un nombre de sala "; return; } screenJoin.SetActive(false); screenServer.SetActive(true); RoomOptions roomOptions = new RoomOptions(); TypedLobby typedLobby = new TypedLobby(roomName, LobbyType.Default); PhotonNetwork.JoinOrCreateRoom(roomName, roomOptions, typedLobby); } }
public static bool JoinLobby(TypedLobby typedLobby) { if (connected && Server == ServerConnection.MasterServer) { if (typedLobby == null) { typedLobby = TypedLobby.Default; } bool flag = networkingPeer.OpJoinLobby(typedLobby); if (flag) { networkingPeer.lobby = typedLobby; } return(flag); } return(false); }
public virtual bool OpCreateRoom(string roomName, RoomOptions roomOptions, TypedLobby lobby, Hashtable playerProperties, bool onGameServer) { if (base.DebugOut >= DebugLevel.INFO) { base.Listener.DebugReturn(DebugLevel.INFO, "OpCreateRoom()"); } Dictionary <byte, object> customOpParameters = new Dictionary <byte, object>(); if (!string.IsNullOrEmpty(roomName)) { customOpParameters[0xff] = roomName; } if (lobby != null) { customOpParameters[0xd5] = lobby.Name; customOpParameters[0xd4] = (byte)lobby.Type; } if (onGameServer) { if ((playerProperties != null) && (playerProperties.Count > 0)) { customOpParameters[0xf9] = playerProperties; customOpParameters[250] = true; } if (roomOptions == null) { roomOptions = new RoomOptions(); } Hashtable target = new Hashtable(); customOpParameters[0xf8] = target; target.MergeStringKeys(roomOptions.customRoomProperties); target[(byte)0xfd] = roomOptions.isOpen; target[(byte)0xfe] = roomOptions.isVisible; target[(byte)250] = roomOptions.customRoomPropertiesForLobby; if (roomOptions.maxPlayers > 0) { target[(byte)0xff] = roomOptions.maxPlayers; } if (roomOptions.cleanupCacheOnLeave) { customOpParameters[0xf1] = true; target[(byte)0xf9] = true; } } return(this.OpCustom(0xe3, customOpParameters, true)); }
public virtual bool OpCreateRoom(string roomName, RoomOptions roomOptions, TypedLobby lobby, Hashtable playerProperties, bool onGameServer) { if (base.DebugOut >= DebugLevel.INFO) { base.Listener.DebugReturn(DebugLevel.INFO, "OpCreateRoom()"); } Dictionary <byte, object> customOpParameters = new Dictionary <byte, object>(); if (!string.IsNullOrEmpty(roomName)) { customOpParameters[ParameterCode.RoomName] = roomName; } if (lobby != null) { customOpParameters[ParameterCode.LobbyName] = lobby.Name; customOpParameters[ParameterCode.LobbyType] = (byte)lobby.Type; } if (onGameServer) { if ((playerProperties != null) && (playerProperties.Count > 0)) { customOpParameters[ParameterCode.PlayerProperties] = playerProperties; customOpParameters[ParameterCode.Broadcast] = true; } if (roomOptions == null) { roomOptions = new RoomOptions(); } Hashtable target = new Hashtable(); customOpParameters[ParameterCode.GameProperties] = target; target.MergeStringKeys(roomOptions.customRoomProperties); target[RoomProperty.Joinable] = roomOptions.isOpen; target[RoomProperty.Visibility] = roomOptions.isVisible; target[RoomProperty.PropertiesListedInLobby] = roomOptions.customRoomPropertiesForLobby; if (roomOptions.maxPlayers > 0) { target[RoomProperty.MaxPlayers] = roomOptions.maxPlayers; } if (roomOptions.cleanupCacheOnLeave) { customOpParameters[ParameterCode.CleanupCacheOnLeave] = true; target[RoomProperty.CleanUpCacheOnLeave] = true; } } return(SendOperation(OperationCode.CreateGame, customOpParameters, SendOptions.SendReliable)); }
/// <summary> /// Joins the lobby on the Master Server, where you get a list of RoomInfos of currently open rooms. /// This is an async request which triggers a OnOperationResponse() call. /// </summary> /// <returns>If the operation could be sent (has to be connected).</returns> public virtual bool OpJoinLobby(TypedLobby lobby) { if (this.DebugOut >= DebugLevel.INFO) { this.Listener.DebugReturn(DebugLevel.INFO, "OpJoinLobby()"); } Dictionary<byte, object> parameters = null; if (lobby != null && !lobby.IsDefault) { parameters = new Dictionary<byte, object>(); parameters[(byte)ParameterCode.LobbyName] = lobby.Name; parameters[(byte)ParameterCode.LobbyType] = (byte)lobby.Type; } return this.OpCustom(OperationCode.JoinLobby, parameters, true); }
public virtual bool OpJoinLobby(TypedLobby lobby) { if (DebugOut >= DebugLevel.INFO) { Listener.DebugReturn(DebugLevel.INFO, "OpJoinLobby()"); } Dictionary <byte, object> customOpParameters = null; if (lobby != null && !lobby.IsDefault) { customOpParameters = new Dictionary <byte, object>(); customOpParameters[213] = lobby.Name; customOpParameters[212] = (byte)lobby.Type; } return(SendOperation(229, customOpParameters, SendOptions.SendReliable)); }
/// <summary> /// A method to create a room. /// </summary> /// <param name="input"> /// The name of the room. /// </param> public void CreateRoom(InputField input) { roomNameText = input.name; if (input.text == "") { roomNameText = "Funeral_Room"; //return; } RoomOptions roomOptions = new RoomOptions(); roomOptions.isVisible = true; roomOptions.isOpen = true; roomOptions.maxPlayers = (byte)25; TypedLobby typedLobby = new TypedLobby(); PhotonNetwork.CreateRoom(input.text, roomOptions, typedLobby); }
void SqlSearchStringDemonstration() { TypedLobby newLobby = new TypedLobby("SkyArenaLobby", LobbyType.SqlLobby); string possibleSqlSearch = "( C5 = \"Map2\" OR C5 = \"Map5\" ) AND C2 < 20 AND C2 > 10"; PhotonNetwork.JoinRandomRoom( null, 0, MatchmakingMode.FillRoom, newLobby, possibleSqlSearch ); }
public static bool JoinLobby(TypedLobby typedLobby) { bool flag; if (!connected || (Server != ServerConnection.MasterServer)) { return(false); } if (typedLobby == null) { typedLobby = TypedLobby.Default; } if (flag = networkingPeer.OpJoinLobby(typedLobby)) { networkingPeer.lobby = typedLobby; } return(flag); }
public static bool RejoinRoom(string roomName, RoomOptions roomOptions, TypedLobby typedLobby, bool createIfNotExists, Hashtable Hash) { bool onGameServer = PhotonNetwork.networkingPeer.server == ServerConnection.GameServer; if (!onGameServer) { Room mRoomToGetInto = new Room(roomName, roomOptions); PhotonNetwork.networkingPeer.mRoomToEnterLobby = null; if (createIfNotExists) { if (typedLobby == null) { } PhotonNetwork.networkingPeer.mRoomToEnterLobby = !PhotonNetwork.networkingPeer.insideLobby ? null : PhotonNetwork.networkingPeer.lobby; } } return(PhotonNetwork.networkingPeer.OpJoinRoom(roomName, roomOptions, PhotonNetwork.networkingPeer.mRoomToEnterLobby, createIfNotExists, Hash, onGameServer)); }
public void OnHostServerButton() { if (string.IsNullOrEmpty(m_HostServerName)) { return; } RoomOptions roomOptions = new RoomOptions(); roomOptions.MaxPlayers = MAX_PLAYER_COUNT; //Create room with the lobby TypedLobby sqlLobby = new TypedLobby(LOBBY_NAME, LobbyType.Default); PhotonNetwork.CreateRoom(m_HostServerName, roomOptions, sqlLobby); SetBlockingMessage("Creating room..."); }
public void CreateRoom() { if (playerName == null || roomNameCreated == null) { Debug.Log("you have to privide the player name and the room name!"); return; } controlPanel.SetActive(false); backButton.SetActive(true); progressLabel.text = "status: waiting for other players"; PhotonNetwork.LocalPlayer.NickName = playerName; RoomOptions roomOptions = new RoomOptions(); TypedLobby typedLobby = new TypedLobby(roomNameCreated, LobbyType.Default); PhotonNetwork.CreateRoom(roomNameCreated, roomOptions, typedLobby); }
/// <summary> /// Joins the lobby on the Master Server, where you get a list of RoomInfos of currently open rooms. /// This is an async request which triggers a OnOperationResponse() call. /// </summary> /// <returns>If the operation could be sent (has to be connected).</returns> public virtual bool OpJoinLobby(TypedLobby lobby) { if (this.DebugOut >= DebugLevel.INFO) { this.Listener.DebugReturn(DebugLevel.INFO, "OpJoinLobby()"); } Dictionary <byte, object> parameters = null; if (lobby != null && !lobby.IsDefault) { parameters = new Dictionary <byte, object>(); parameters[(byte)ParameterCode.LobbyName] = lobby.Name; parameters[(byte)ParameterCode.LobbyType] = (byte)lobby.Type; } return(this.OpCustom(OperationCode.JoinLobby, parameters, true)); }
/// <summary> /// Method to be called when the user wants to create a new room. /// </summary> public void CreateNewRoom(int numberOfPlayers, ProjectDelegates.RoomInfoCallback RoomCreatedCallback, int level) { OnJoinedRoomCallback = RoomCreatedCallback; ExitGames.Client.Photon.Hashtable customParams = new ExitGames.Client.Photon.Hashtable(); customParams.Add("C0", level); RoomOptions options = new RoomOptions(); options.maxPlayers = numberOfPlayers; TypedLobby typedLobby = new TypedLobby("GameLobby", LobbyType.Default); //PhotonNetwork.CreateRoom ("",options,typedLobby); //PhotonNetwork.CreateRoom ("", true, true, numberOfPlayers); // testing this to git rid of the build warning PhotonNetwork.CreateRoom("", options, typedLobby); }
private void JoinOrCreateRoom(string roomName) { lobbyGO.SetActive(false); RoomOptions roomOption = new RoomOptions(); roomOption.MaxPlayers = 2; roomOption.CustomRoomProperties = new ExitGames.Client.Photon.Hashtable() { { "C0", "Hello" } }; roomOption.CustomRoomPropertiesForLobby = new string[] { "C0" }; TypedLobby typedLobby = new TypedLobby("XD", LobbyType.SqlLobby); PhotonNetwork.JoinOrCreateRoom(roomName, roomOption, typedLobby); }
public override void OnJoinRandomFailed(short returnCode, string message) { Debug.Log("Fail join room : " + message + " Creating..."); RoomOptions ro = new RoomOptions { MaxPlayers = 2, PublishUserId = true, IsOpen = true, IsVisible = true, EmptyRoomTtl = 1000 }; TypedLobby tl = new TypedLobby { Name = "Ranked" }; PhotonNetwork.CreateRoom("Ranked", ro, tl); }
void CreateRoom(TypedLobby type) { Debug.Log("Creating room"); int randomRoomNumber = Random.Range(0, 10000); RoomOptions roomOps; roomOps = type.Name == "Survival" ? new RoomOptions() { IsVisible = true, IsOpen = true, MaxPlayers = (byte)survivalRoomSize } : new RoomOptions() { IsVisible = true, IsOpen = true, MaxPlayers = (byte)faceoffRoomSize }; PhotonNetwork.CreateRoom("Room" + randomRoomNumber, roomOps, type); Debug.Log(randomRoomNumber); }
private IEnumerator CheckConnectionToLobby() { while (true) { yield return(new WaitForSeconds(1.0f)); if (!PhotonNetwork.IsConnected) { mc.ConnectToPhoton(); } else if (!PhotonNetwork.InLobby) { TypedLobby tl = new TypedLobby { Name = "private" }; PhotonNetwork.JoinLobby(tl); } } }
public TypedLobby GetTypedLobby() { if (name.IsNone && type.IsNone) { return(TypedLobby.Default); } TypedLobby _t = new TypedLobby(); if (!name.IsNone) { _t.Name = name.Value; } if (!type.IsNone) { _t.Type = (LobbyType)type.Value; } return(_t); }
public static bool CreateRoom(string roomName, RoomOptions roomOptions, TypedLobby typedLobby) { if (offlineMode) { if (offlineModeRoom != null) { Debug.LogError("CreateRoom failed. In offline mode you still have to leave a room to enter another."); return(false); } offlineModeRoom = new Room(roomName, roomOptions); NetworkingPeer.SendMonoMessage(PhotonNetworkingMessage.OnCreatedRoom, 0, new object[0]); NetworkingPeer.SendMonoMessage(PhotonNetworkingMessage.OnJoinedRoom, 0, new object[0]); return(true); } if ((networkingPeer.server == ServerConnection.MasterServer) && connectedAndReady) { return(networkingPeer.OpCreateGame(roomName, roomOptions, typedLobby)); } Debug.LogError("CreateRoom failed. Client is not on Master Server or not yet ready to call operations. Wait for callback: OnJoinedLobby or OnConnectedToMaster."); return(false); }
// マスターサーバ接続時のコールバック // ↑ ConnectUsingSettings() を呼んだ時に void OnJoinedLobby() { string userName = "******"; //string userId = "ID : 000" + count++; string userId = "ID : 000" + ClientManager.Instance.number_; PhotonNetwork.autoCleanUpPlayerObjects = false; // ルームプロパティ ExitGames.Client.Photon.Hashtable customProp = new ExitGames.Client.Photon.Hashtable(); customProp.Add("userName", userName); customProp.Add("userId", userId); PhotonNetwork.SetPlayerCustomProperties(customProp); // ルームオプションの設定 RoomOptions myOptions = new RoomOptions(); myOptions.CustomRoomProperties = customProp; myOptions.CustomRoomPropertiesForLobby = new string[] { "userName", "userId" }; myOptions.IsOpen = true; myOptions.IsVisible = true; myOptions.MaxPlayers = 6; // 20人まで // IDの公開 myOptions.PublishUserId = true; // ロビーの設定 TypedLobby myTypedLobby = new TypedLobby(); myTypedLobby.Name = "Default"; myTypedLobby.Type = LobbyType.Default; // ルームを任意の設定で作る PhotonNetwork.JoinOrCreateRoom("DefaultRoom", myOptions, myTypedLobby); }
public override void OnConnectedToMaster() { base.OnConnectedToMaster(); if (MyLobby == null) { MyLobby = new TypedLobby(); } MyLobby.Type = LobbyType.SqlLobby; PhotonNetwork.JoinLobby(MyLobby); //MyOptions.CustomRoomProperties = new ExitGames.Client.Photon.Hashtable() { { "C0", 1 } }; //MyOptions.CustomRoomProperties = new ExitGames.Client.Photon.Hashtable() { { "C1", 2 } }; //MyOptions.CustomRoomProperties = new ExitGames.Client.Photon.Hashtable() { { "M0", 3 } }; //MyOptions.CustomRoomProperties = new ExitGames.Client.Photon.Hashtable() { { "M1", 4 } }; //MyOptions.CustomRoomProperties = new ExitGames.Client.Photon.Hashtable() { { "M2", 5 } }; //MyOptions.CustomRoomPropertiesForLobby = new string[] { "C0" }; Debug.Log("cONECTADO"); }
public IEnumerator SetupVideo(System.Action OnComplete) { VideoChat.framerate = framerate; RoomOptions roomOptions = new RoomOptions(); roomOptions.MaxPlayers = 2; roomOptions.CleanupCacheOnLeave = true; roomOptions.IsVisible = true; roomOptions.IsOpen = true; TypedLobby typedLobby = new TypedLobby(); typedLobby.Name = "chat"; typedLobby.Type = LobbyType.Default; //PhotonNetwork.JoinLobby(typedLobby); PhotonNetwork.JoinOrCreateRoom("MidnightVideoChat", roomOptions, (null != PhotonNetwork.lobby) ? PhotonNetwork.lobby : typedLobby); while (!roomJoined) { yield return(null); } if (PhotonNetwork.GetRoomList().Length > 0) { UnityEngine.Debug.Log("ROOM EXISTS"); } //PhotonNetwork.CreateRoom("MidnightVideoChat", roomOptions, typedLobby); PhotonNetwork.NetworkStatisticsEnabled = true; //PhotonNetwork.GetRoomList() VideoChat.echoCancellation = echoCancellation; if (Application.platform == RuntimePlatform.Android) { VideoChat.deviceIndex++; } OnComplete(); }
/// <summary> /// Joins a specific room by name and creates it on demand. Will callback: OnJoinedRoom or OnJoinRoomFailed. /// </summary> /// <remarks> /// Useful when players make up a room name to meet in: /// All involved clients call the same method and whoever is first, also creates the room. /// /// When successful, the client will enter the specified room. /// The client which creates the room, will callback both OnCreatedRoom and OnJoinedRoom. /// Clients that join an existing room will only callback OnJoinedRoom. /// In all error cases, OnJoinRoomFailed gets called. /// /// Joining a room will fail, if the room is full, closed or when the user /// already is present in the room (checked by userId). /// /// To return to a room, use OpRejoinRoom. /// /// This method can only be called while the client is connected to a Master Server so you should /// implement the callback OnConnectedToMaster. /// Check the return value to make sure the operation will be called on the server. /// Note: There will be no callbacks if this method returned false. /// /// /// If you set room properties in roomOptions, they get ignored when the room is existing already. /// This avoids changing the room properties by late joining players. /// /// You can define an array of expectedUsers, to block player slots in the room for these users. /// The corresponding feature in Photon is called "Slot Reservation" and can be found in the doc pages. /// /// /// More about PUN matchmaking: /// https://doc.photonengine.com/en-us/pun/v2/lobby-and-matchmaking/matchmaking-and-lobby /// </remarks> /// <param name="roomName">Name of the room to join. Must be non null.</param> /// <param name="roomOptions">Options for the room, in case it does not exist yet. Else these values are ignored.</param> /// <param name="typedLobby">Lobby you want a new room to be listed in. Ignored if the room was existing and got joined.</param> /// <param name="expectedUsers">Optional list of users (by UserId) who are expected to join this game and who you want to block a slot for.</param> /// <returns>True will be returned when you are the first user.</returns>> public static async UniTask <bool> JoinOrCreateRoomAsync( string roomName, RoomOptions roomOptions, TypedLobby typedLobby, string[] expectedUsers = null, CancellationToken token = default) { var createdRoomTask = Pun2TaskCallback.OnCreatedRoomAsync().GetAwaiter(); var task = UniTask.WhenAny( Pun2TaskCallback.OnJoinedRoomAsync().AsAsyncUnitUniTask(), Pun2TaskCallback.OnCreateRoomFailedAsync(), Pun2TaskCallback.OnJoinRoomFailedAsync()); var valid = PhotonNetwork.JoinOrCreateRoom(roomName, roomOptions, typedLobby, expectedUsers); if (!valid) { throw new InvalidRoomOperationException("It is not ready to join a room."); } var(winIndex, _, (createFailedCode, createFailedMessage), (joinFailedCode, joinFailedMessage)) = await task.WithCancellation(token); if (winIndex == 0) { return(createdRoomTask.IsCompleted); } if (winIndex == 1) { throw new FailedToCreateRoomException(createFailedCode, createFailedMessage); } else { throw new FailedToJoinRoomException(createFailedCode, createFailedMessage); } }
/* ============================== INTERFACE ============================== */ public void InitMenu() { if (listRoom == null) { listRoom = new Dictionary <string, GameObject>(); } else { ClearRoom(); } TypedLobby tl = new TypedLobby { Name = "private" }; PhotonNetwork.JoinLobby(tl); joinRoomButton.interactable = false; StartCoroutine(CheckConnectionToLobby()); }
public IEnumerator Connect() { NetworkView = gameObject.AddComponent <PhotonView>(); NetworkView.synchronization = ViewSynchronization.Off; NetworkView.viewID = 3; if (Application.internetReachability != NetworkReachability.NotReachable) { PhotonNetwork.ConnectUsingSettings("1.0"); } while (!connectedToMaster) { yield return(null); } RoomOptions roomOptions = new RoomOptions(); roomOptions.MaxPlayers = 2; roomOptions.CleanupCacheOnLeave = true; roomOptions.IsVisible = true; roomOptions.IsOpen = true; TypedLobby typedLobby = new TypedLobby(); typedLobby.Name = "chat"; typedLobby.Type = LobbyType.Default; PhotonNetwork.JoinLobby(typedLobby); if (PhotonNetwork.GetRoomList().Length > 0) { UnityEngine.Debug.Log("ROOM EXISTS"); } //PhotonNetwork.JoinOrCreateRoom("MidnightVideoChat", roomOptions, typedLobby); //PhotonNetwork.CreateRoom("MidnightVideoChat", roomOptions, typedLobby); PhotonNetwork.NetworkStatisticsEnabled = true; //PhotonNetwork.GetRoomList() }
private void CreateRoomAction() { if (roomNameField.text == "") { return; } RoomOptions ro = new RoomOptions { MaxPlayers = (byte)nbPlayersSlider.value, PublishUserId = true, IsOpen = true, IsVisible = true, EmptyRoomTtl = 1000 }; TypedLobby tl = new TypedLobby { Name = "private" }; PhotonNetwork.CreateRoom(roomNameField.text, ro, tl); }
public void CreateRoom(GameOptions options) { if (!Rooms.ContainsKey(options.name)) { RoomOptions roomOptions = new RoomOptions(); roomOptions.IsVisible = true; roomOptions.IsOpen = true; roomOptions.Plugins = new string[] { "MineSweepers" + options.plugin }; roomOptions.CustomRoomProperties = new ExitGames.Client.Photon.Hashtable() { { "plugin", "MineSweepers" + options.plugin }, { "hight", options.hight }, { "width", options.width }, { "maxPlayers", options.numOfPlayers }, { "mineRate", options.mineRate }, { "firstSafe", options.firstSafe }, { "endOnExpload", options.endOnExpload }, { "joinAfter", options.JoinAfterStart } }; roomOptions.CustomRoomPropertiesForLobby = new string[] { "plugin", "hight", "width", "mineRate", "maxPlayers", "joinAfter" }; roomOptions.MaxPlayers = (byte)options.numOfPlayers; TypedLobby lobby = new TypedLobby("Main", LobbyType.SqlLobby); PhotonNetwork.CreateRoom(options.name, roomOptions, lobby); } }
// Start the connection process. // - If already connected, we attempt joining a random room. // - If not yet connected, Connect this application instance to Photon Cloud Network public void Connect() { CurrentState = GameConnectState.Disconnected; RoomOptions roomOptions = new RoomOptions(); roomOptions.MaxPlayers = 2; TypedLobby typedLobby = new TypedLobby(); typedLobby.Type = LobbyType.Default; if (PhotonNetwork.IsConnected) { //PhotonNetwork.JoinRandomRoom(); Debug.Log("room name:" + roomName); PhotonNetwork.JoinOrCreateRoom(roomName, roomOptions, typedLobby); } else { PhotonNetwork.GameVersion = _gameVersion; PhotonNetwork.ConnectUsingSettings(); } }
// Token: 0x060002ED RID: 749 RVA: 0x00012F10 File Offset: 0x00011110 public virtual bool OpGetGameList(TypedLobby lobby, string queryData) { if (this.DebugOut >= DebugLevel.INFO) { base.Listener.DebugReturn(DebugLevel.INFO, "OpGetGameList()"); } if (lobby == null) { if (this.DebugOut >= DebugLevel.INFO) { base.Listener.DebugReturn(DebugLevel.INFO, "OpGetGameList not sent. Lobby cannot be null."); } return(false); } if (lobby.Type != LobbyType.SqlLobby) { if (this.DebugOut >= DebugLevel.INFO) { base.Listener.DebugReturn(DebugLevel.INFO, "OpGetGameList not sent. LobbyType must be SqlLobby."); } return(false); } if (lobby.IsDefault) { if (this.DebugOut >= DebugLevel.INFO) { base.Listener.DebugReturn(DebugLevel.INFO, "OpGetGameList not sent. LobbyName must be not null and not empty."); } return(false); } Dictionary <byte, object> dictionary = new Dictionary <byte, object>(); dictionary[213] = lobby.Name; dictionary[212] = (byte)lobby.Type; dictionary[245] = queryData; return(this.SendOperation(217, dictionary, SendOptions.SendReliable)); }
void OnGUI() { RoomOptions classRoomOptions = new RoomOptions(); classRoomOptions.isOpen = true; classRoomOptions.isVisible = true; classRoomOptions.maxPlayers = 16; TypedLobby classLobby = new TypedLobby("Class Lobby", LobbyType.Default); if (!PhotonNetwork.connected) { GUILayout.Label(PhotonNetwork.connectionStateDetailed.ToString()); } else if (PhotonNetwork.room == null) { // Create Room if (GUI.Button(new Rect(100, 100, 250, 100), "Start Server")) { // PhotonNetwork.CreateRoom(roomName + System.Guid.NewGuid().ToString("N"), true, true, 5); PhotonNetwork.CreateRoom(classRoomName, classRoomOptions, classLobby); } // Join Room if (roomsList != null) { for (int i = 0; i < roomsList.Length; i++) { if (GUI.Button(new Rect(100, 250 + (110 * i), 250, 100), "Join " + roomsList[i].name)) { PhotonNetwork.JoinRoom(roomsList[i].name); } } } } }
/// <summary>NetworkingPeer.OpJoinRoom</summary> public bool OpJoinRoom(string roomName, RoomOptions roomOptions, TypedLobby typedLobby, bool createIfNotExists) { bool onGameServer = this.server == ServerConnection.GameServer; if (!onGameServer) { // roomOptions and typedLobby will be null, unless createIfNotExists is true this.mRoomOptionsForCreate = roomOptions; this.mRoomToGetInto = new Room(roomName, roomOptions); this.mRoomToEnterLobby = null; if (createIfNotExists) { this.mRoomToEnterLobby = typedLobby ?? ((this.insideLobby) ? this.lobby : null); // use given lobby, or active lobby (if any active) or none } } this.mLastJoinType = (createIfNotExists) ? JoinType.JoinOrCreateOnDemand : JoinType.JoinGame; return base.OpJoinRoom(roomName, roomOptions, this.mRoomToEnterLobby, createIfNotExists, this.GetLocalActorProperties(), onGameServer); }
/// <summary>NetworkingPeer.OpCreateGame</summary> public bool OpCreateGame(string roomName, RoomOptions roomOptions, TypedLobby typedLobby) { bool onGameServer = this.server == ServerConnection.GameServer; if (!onGameServer) { this.mRoomOptionsForCreate = roomOptions; this.mRoomToGetInto = new Room(roomName, roomOptions); this.mRoomToEnterLobby = typedLobby ?? ((this.insideLobby) ? this.lobby : null); // use given lobby, or active lobby (if any active) or none } this.mLastJoinType = JoinType.CreateGame; return base.OpCreateRoom(roomName, roomOptions, this.mRoomToEnterLobby, this.GetLocalActorProperties(), onGameServer); }
/// <summary> /// Method to be called when the user wants to create a new room. /// </summary> public void CreateNewRoom(int numberOfPlayers,ProjectDelegates.RoomInfoCallback RoomCreatedCallback, int level) { OnJoinedRoomCallback = RoomCreatedCallback; ExitGames.Client.Photon.Hashtable customParams = new ExitGames.Client.Photon.Hashtable(); customParams.Add("C0", level); RoomOptions options = new RoomOptions(); options.maxPlayers = numberOfPlayers; TypedLobby typedLobby = new TypedLobby("GameLobby",LobbyType.Default); //PhotonNetwork.CreateRoom ("",options,typedLobby); //PhotonNetwork.CreateRoom ("", true, true, numberOfPlayers); // testing this to git rid of the build warning PhotonNetwork.CreateRoom("", options, typedLobby); }
/// <summary> /// Attempts to join an open room with fitting, custom properties but fails if none is currently available. /// </summary> /// <remarks> /// Rooms can be created in arbitrary lobbies which get created on demand. /// You can join rooms from any lobby without actually joining the lobby with this overload. /// /// This method will only match rooms attached to one lobby! If you use many lobbies, you /// might have to repeat JoinRandomRoom, to find some fitting room. /// This method looks up a room in the specified lobby or the currently active lobby (if none specified) /// or in the default lobby (if none active). /// /// If this fails, you can still create a room (and make this available for the next who uses JoinRandomRoom). /// Alternatively, try again in a moment. /// /// In offlineMode, a room will be created but no properties will be set and all parameters of this /// JoinRandomRoom call are ignored. The event/callback OnJoinedRoom gets called (see enum PhotonNetworkingMessage). /// </remarks> /// <param name="expectedCustomRoomProperties">Filters for rooms that match these custom properties (string keys and values). To ignore, pass null.</param> /// <param name="expectedMaxPlayers">Filters for a particular maxplayer setting. Use 0 to accept any maxPlayer value.</param> /// <param name="matchingType">Selects one of the available matchmaking algorithms. See MatchmakingMode enum for options.</param> /// <param name="typedLobby">The lobby in which you want to lookup a room. Pass null, to use the default lobby. This does not join that lobby and neither sets the lobby property.</param> /// <param name="sqlLobbyFilter">A filter-string for SQL-typed lobbies.</param> public static bool JoinRandomRoom(Hashtable expectedCustomRoomProperties, byte expectedMaxPlayers, MatchmakingMode matchingType, TypedLobby typedLobby, string sqlLobbyFilter) { if (offlineMode) { if (offlineModeRoom != null) { Debug.LogError("JoinRandomRoom failed. In offline mode you still have to leave a room to enter another."); return false; } offlineModeRoom = new Room("offline room", null); offlineModeRoom.masterClientId = 1; NetworkingPeer.SendMonoMessage(PhotonNetworkingMessage.OnJoinedRoom); return true; } if (networkingPeer.server != ServerConnection.MasterServer || !connectedAndReady) { Debug.LogError("JoinRandomRoom failed. Client is not on Master Server or not yet ready to call operations. Wait for callback: OnJoinedLobby or OnConnectedToMaster."); return false; } return networkingPeer.OpJoinRandomRoom(expectedCustomRoomProperties, expectedMaxPlayers, null, matchingType, typedLobby, sqlLobbyFilter); }
/// <summary>Lets you either join a named room or create it on the fly - you don't have to know if someone created the room already.</summary> /// <remarks> /// This makes it easier for groups of players to get into the same room. Once the group /// exchanged a roomName, any player can call JoinOrCreateRoom and it doesn't matter who /// actually joins or creates the room. /// /// The parameters roomOptions and typedLobby are only used when the room actually gets created by this client. /// You know if this client created a room, if you get a callback OnCreatedRoom (before OnJoinedRoom gets called as well). /// </remarks> /// <param name="roomName">Name of the room to join. Must be non null.</param> /// <param name="roomOptions">Options for the room, in case it does not exist yet. Else these values are ignored.</param> /// <param name="typedLobby">Lobby you want a new room to be listed in. Ignored if the room was existing and got joined.</param> /// <returns>If the operation got queued and will be sent.</returns> public static bool JoinOrCreateRoom(string roomName, RoomOptions roomOptions, TypedLobby typedLobby) { if (offlineMode) { if (offlineModeRoom != null) { Debug.LogError("JoinOrCreateRoom failed. In offline mode you still have to leave a room to enter another."); return false; } offlineModeRoom = new Room(roomName, roomOptions); offlineModeRoom.masterClientId = 1; NetworkingPeer.SendMonoMessage(PhotonNetworkingMessage.OnCreatedRoom); // in offline mode you create, too for JoinOrCreateRoom NetworkingPeer.SendMonoMessage(PhotonNetworkingMessage.OnJoinedRoom); return true; } if (networkingPeer.server != ServerConnection.MasterServer || !connectedAndReady) { Debug.LogError("JoinOrCreateRoom failed. Client is not on Master Server or not yet ready to call operations. Wait for callback: OnJoinedLobby or OnConnectedToMaster."); return false; } if (string.IsNullOrEmpty(roomName)) { Debug.LogError("JoinOrCreateRoom failed. A roomname is required. If you don't know one, how will you join?"); return false; } return networkingPeer.OpJoinRoom(roomName, roomOptions, typedLobby, true); }
/// <summary>On a Master Server you can join a lobby to get lists of available rooms.</summary> /// <remarks> /// The room list is sent and refreshed by the server. You can access this cached list by /// PhotonNetwork.GetRoomList(). /// /// Any client can "make up" any lobby on the fly. Splitting rooms into multiple lobbies will /// keep each list shorter. However, having too many lists might ruin the matchmaking experience. /// /// In best case, you create a limited number of lobbies. For example, create a lobby per /// game-mode: "koth" for king of the hill and "ffa" for free for all, etc. /// /// There is no listing of lobbies at the moment. /// /// Sql-typed lobbies offer a different filtering model for random matchmaking. This might be more /// suited for skillbased-games. However, you will also need to follow the conventions for naming /// filterable properties in sql-lobbies! Both is explained in the matchmaking doc linked below. /// /// In best case, you make your clients join random games, as described here: /// http://confluence.exitgames.com/display/PTN/Op+JoinRandomGame /// /// /// Per room you should check if it's full or not before joining. Photon does list rooms that are /// full, unless you close and hide them (room.open = false and room.visible = false). /// /// You can show your games current players and room count without joining a lobby (but you must /// be on the master server). Use: countOfPlayers, countOfPlayersOnMaster, countOfPlayersInRooms and /// countOfRooms. /// /// When creating new rooms, they will be "attached" to the currently used lobby or the default lobby. /// /// You can use JoinRandomRoom without being in a lobby! /// Set autoJoinLobby = false before you connect, to not join a lobby. In that case, the /// connect-workflow will call OnConnectedToMaster (if you implement it) when it's done. /// </remarks> /// <param name="typedLobby">A typed lobby to join (must have name and type).</param> public static bool JoinLobby(TypedLobby typedLobby) { if (PhotonNetwork.connected && PhotonNetwork.Server == ServerConnection.MasterServer) { if (typedLobby == null) { typedLobby = TypedLobby.Default; } bool sending = networkingPeer.OpJoinLobby(typedLobby); if (sending) { networkingPeer.lobby = typedLobby; } return sending; } return false; }
/// <summary> /// Creates a room but fails if this room is existing already. Can only be called on Master Server. /// </summary> /// <remarks> /// When successful, this calls the callbacks OnCreatedRoom and OnJoinedRoom (the latter, cause you join as first player). /// If the room can't be created (because it exists already), OnPhotonCreateRoomFailed gets called. /// /// If you don't want to create a unique room-name, pass null or "" as name and the server will assign a roomName (a GUID as string). /// /// Rooms can be created in any number of lobbies. Those don't have to exist before you create a room in them (they get /// auto-created on demand). Lobbies can be useful to split room lists on the server-side already. That can help keep the room /// lists short and manageable. /// If you set a typedLobby parameter, the room will be created in that lobby (no matter if you are active in any). /// If you don't set a typedLobby, the room is automatically placed in the currently active lobby (if any) or the /// default-lobby. /// /// Call this only on the master server. /// Internally, the master will respond with a server-address (and roomName, if needed). Both are used internally /// to switch to the assigned game server and roomName. /// /// PhotonNetwork.autoCleanUpPlayerObjects will become this room's autoCleanUp property and that's used by all clients that join this room. /// /// You can define an array of expectedUsers, to block player slots in the room for these users. /// The corresponding feature in Photon is called "Slot Reservation" and can be found in the doc pages. /// </remarks> /// <param name="roomName">Unique name of the room to create. Pass null or "" to make the server generate a name.</param> /// <param name="roomOptions">Common options for the room like MaxPlayers, initial custom room properties and similar. See RoomOptions type..</param> /// <param name="typedLobby">If null, the room is automatically created in the currently used lobby (which is "default" when you didn't join one explicitly).</param> /// <param name="expectedUsers">Optional list of users (by UserId) who are expected to join this game and who you want to block a slot for.</param> /// <returns>If the operation got queued and will be sent.</returns> public static bool CreateRoom(string roomName, RoomOptions roomOptions, TypedLobby typedLobby, string[] expectedUsers) { if (offlineMode) { if (offlineModeRoom != null) { Debug.LogError("CreateRoom failed. In offline mode you still have to leave a room to enter another."); return false; } EnterOfflineRoom(roomName, roomOptions, true); return true; } if (networkingPeer.Server != ServerConnection.MasterServer || !connectedAndReady) { Debug.LogError("CreateRoom failed. Client is not on Master Server or not yet ready to call operations. Wait for callback: OnJoinedLobby or OnConnectedToMaster."); return false; } typedLobby = typedLobby ?? ((networkingPeer.insideLobby) ? networkingPeer.lobby : null); // use given lobby, or active lobby (if any active) or none EnterRoomParams opParams = new EnterRoomParams(); opParams.RoomName = roomName; opParams.RoomOptions = roomOptions; opParams.Lobby = typedLobby; opParams.ExpectedUsers = expectedUsers; return networkingPeer.OpCreateGame(opParams); }
/// <summary> /// Method to be called when the user wants to try to connect to an existing room. /// </summary> public void JoinRoom(byte maxPlayers, int level, ProjectDelegates.RoomInfoCallback JoinedRoomCallback) { this.maxPlayers = maxPlayers; this.level = level; OnJoinedRoomCallback = JoinedRoomCallback; string sqlFilter = "C0 > " + (level-3) + " AND C0 < " + (level+3); Debug.Log (sqlFilter); TypedLobby typedLobby = new TypedLobby("GameLobby",LobbyType.Default); PhotonNetwork.JoinRandomRoom(null,maxPlayers,MatchmakingMode.FillRoom,typedLobby,""); //PhotonNetwork.JoinRandomRoom (, MatchmakingMode.FillRoom, typedLobby, sqlFilter); }
/// <summary> /// Operation to join a random, available room. Overloads take additional player properties. /// This is an async request which triggers a OnOperationResponse() call. /// If all rooms are closed or full, the OperationResponse will have a returnCode of ErrorCode.NoRandomMatchFound. /// If successful, the OperationResponse contains a gameserver address and the name of some room. /// </summary> /// <param name="expectedCustomRoomProperties">Optional. A room will only be joined, if it matches these custom properties (with string keys).</param> /// <param name="expectedMaxPlayers">Filters for a particular maxplayer setting. Use 0 to accept any maxPlayer value.</param> /// <param name="playerProperties">This player's properties (custom and well known).</param> /// <param name="matchingType">Selects one of the available matchmaking algorithms. See MatchmakingMode enum for options.</param> /// <returns>If the operation could be sent currently (requires connection).</returns> public virtual bool OpJoinRandomRoom(Hashtable expectedCustomRoomProperties, byte expectedMaxPlayers, Hashtable playerProperties, MatchmakingMode matchingType, TypedLobby typedLobby, string sqlLobbyFilter) { if (this.DebugOut >= DebugLevel.INFO) { this.Listener.DebugReturn(DebugLevel.INFO, "OpJoinRandomRoom()"); } Hashtable expectedRoomProperties = new Hashtable(); expectedRoomProperties.MergeStringKeys(expectedCustomRoomProperties); if (expectedMaxPlayers > 0) { expectedRoomProperties[GameProperties.MaxPlayers] = expectedMaxPlayers; } Dictionary<byte, object> opParameters = new Dictionary<byte, object>(); if (expectedRoomProperties.Count > 0) { opParameters[ParameterCode.GameProperties] = expectedRoomProperties; } if (playerProperties != null && playerProperties.Count > 0) { opParameters[ParameterCode.PlayerProperties] = playerProperties; } if (matchingType != MatchmakingMode.FillRoom) { opParameters[ParameterCode.MatchMakingType] = (byte)matchingType; } if (typedLobby != null) { opParameters[ParameterCode.LobbyName] = typedLobby.Name; opParameters[ParameterCode.LobbyType] = (byte)typedLobby.Type; } if (!string.IsNullOrEmpty(sqlLobbyFilter)) { opParameters[ParameterCode.Data] = sqlLobbyFilter; } // UnityEngine.Debug.LogWarning("OpJoinRandom: " + opParameters.ToStringFull()); return this.OpCustom(OperationCode.JoinRandomGame, opParameters, true); }
/// <summary>LoadBalancingPeer.OpJoinRoom</summary> public virtual bool OpJoinRoom(string roomName, RoomOptions roomOptions, TypedLobby lobby, bool createIfNotExists, Hashtable playerProperties, bool onGameServer) { Dictionary<byte, object> op = new Dictionary<byte, object>(); if (!string.IsNullOrEmpty(roomName)) { op[ParameterCode.RoomName] = roomName; } if (createIfNotExists) { op[ParameterCode.CreateIfNotExists] = true; if (lobby != null) { op[ParameterCode.LobbyName] = lobby.Name; op[ParameterCode.LobbyType] = (byte)lobby.Type; } } if (onGameServer) { if (playerProperties != null && playerProperties.Count > 0) { op[ParameterCode.PlayerProperties] = playerProperties; op[ParameterCode.Broadcast] = true; // broadcast actor properties } if (createIfNotExists) { if (roomOptions == null) { roomOptions = new RoomOptions(); } Hashtable gameProperties = new Hashtable(); op[ParameterCode.GameProperties] = gameProperties; gameProperties.MergeStringKeys(roomOptions.customRoomProperties); gameProperties[GameProperties.IsOpen] = roomOptions.isOpen; gameProperties[GameProperties.IsVisible] = roomOptions.isVisible; gameProperties[GameProperties.PropsListedInLobby] = roomOptions.customRoomPropertiesForLobby; if (roomOptions.maxPlayers > 0) { gameProperties[GameProperties.MaxPlayers] = roomOptions.maxPlayers; } if (roomOptions.cleanupCacheOnLeave) { op[ParameterCode.CleanupCacheOnLeave] = true; // this is actually setting the room's config gameProperties[GameProperties.CleanupCacheOnLeave] = true; // this is only informational for the clients which join } if (roomOptions.suppressRoomEvents) { op[ParameterCode.SuppressRoomEvents] = true; } } } // UnityEngine.Debug.Log("JoinGame: " + SupportClass.DictionaryToString(op)); return this.OpCustom(OperationCode.JoinGame, op, true); }
/// <summary> /// Attempts to join an open room with fitting, custom properties but fails if none is currently available. /// </summary> /// <remarks> /// Rooms can be created in arbitrary lobbies which get created on demand. /// You can join rooms from any lobby without actually joining the lobby with this overload. /// /// This method will only match rooms attached to one lobby! If you use many lobbies, you /// might have to repeat JoinRandomRoom, to find some fitting room. /// This method looks up a room in the specified lobby or the currently active lobby (if none specified) /// or in the default lobby (if none active). /// /// If this fails, you can still create a room (and make this available for the next who uses JoinRandomRoom). /// Alternatively, try again in a moment. /// /// In offlineMode, a room will be created but no properties will be set and all parameters of this /// JoinRandomRoom call are ignored. The event/callback OnJoinedRoom gets called (see enum PhotonNetworkingMessage). /// /// You can define an array of expectedUsers, to block player slots in the room for these users. /// The corresponding feature in Photon is called "Slot Reservation" and can be found in the doc pages. /// </remarks> /// <param name="expectedCustomRoomProperties">Filters for rooms that match these custom properties (string keys and values). To ignore, pass null.</param> /// <param name="expectedMaxPlayers">Filters for a particular maxplayer setting. Use 0 to accept any maxPlayer value.</param> /// <param name="matchingType">Selects one of the available matchmaking algorithms. See MatchmakingMode enum for options.</param> /// <param name="typedLobby">The lobby in which you want to lookup a room. Pass null, to use the default lobby. This does not join that lobby and neither sets the lobby property.</param> /// <param name="sqlLobbyFilter">A filter-string for SQL-typed lobbies.</param> /// <param name="expectedUsers">Optional list of users (by UserId) who are expected to join this game and who you want to block a slot for.</param> /// <returns>If the operation got queued and will be sent.</returns> public static bool JoinRandomRoom(Hashtable expectedCustomRoomProperties, byte expectedMaxPlayers, MatchmakingMode matchingType, TypedLobby typedLobby, string sqlLobbyFilter, string[] expectedUsers = null) { if (offlineMode) { if (offlineModeRoom != null) { Debug.LogError("JoinRandomRoom failed. In offline mode you still have to leave a room to enter another."); return false; } EnterOfflineRoom("offline room", null, true); return true; } if (networkingPeer.Server != ServerConnection.MasterServer || !connectedAndReady) { Debug.LogError("JoinRandomRoom failed. Client is not on Master Server or not yet ready to call operations. Wait for callback: OnJoinedLobby or OnConnectedToMaster."); return false; } typedLobby = typedLobby ?? ((networkingPeer.insideLobby) ? networkingPeer.lobby : null); // use given lobby, or active lobby (if any active) or none OpJoinRandomRoomParams opParams = new OpJoinRandomRoomParams(); opParams.ExpectedCustomRoomProperties = expectedCustomRoomProperties; opParams.ExpectedMaxPlayers = expectedMaxPlayers; opParams.MatchingType = matchingType; opParams.TypedLobby = typedLobby; opParams.SqlLobbyFilter = sqlLobbyFilter; opParams.ExpectedUsers = expectedUsers; return networkingPeer.OpJoinRandomRoom(opParams); }
/// <summary>Lets you either join a named room or create it on the fly - you don't have to know if someone created the room already.</summary> /// <remarks> /// This makes it easier for groups of players to get into the same room. Once the group /// exchanged a roomName, any player can call JoinOrCreateRoom and it doesn't matter who /// actually joins or creates the room. /// /// The parameters roomOptions and typedLobby are only used when the room actually gets created by this client. /// You know if this client created a room, if you get a callback OnCreatedRoom (before OnJoinedRoom gets called as well). /// /// You can define an array of expectedUsers, to block player slots in the room for these users. /// The corresponding feature in Photon is called "Slot Reservation" and can be found in the doc pages. /// </remarks> /// <param name="roomName">Name of the room to join. Must be non null.</param> /// <param name="roomOptions">Options for the room, in case it does not exist yet. Else these values are ignored.</param> /// <param name="typedLobby">Lobby you want a new room to be listed in. Ignored if the room was existing and got joined.</param> /// <param name="expectedUsers">Optional list of users (by UserId) who are expected to join this game and who you want to block a slot for.</param> /// <returns>If the operation got queued and will be sent.</returns> public static bool JoinOrCreateRoom(string roomName, RoomOptions roomOptions, TypedLobby typedLobby, string[] expectedUsers) { if (offlineMode) { if (offlineModeRoom != null) { Debug.LogError("JoinOrCreateRoom failed. In offline mode you still have to leave a room to enter another."); return false; } EnterOfflineRoom(roomName, roomOptions, true); // in offline mode, JoinOrCreateRoom assumes you create the room return true; } if (networkingPeer.Server != ServerConnection.MasterServer || !connectedAndReady) { Debug.LogError("JoinOrCreateRoom failed. Client is not on Master Server or not yet ready to call operations. Wait for callback: OnJoinedLobby or OnConnectedToMaster."); return false; } if (string.IsNullOrEmpty(roomName)) { Debug.LogError("JoinOrCreateRoom failed. A roomname is required. If you don't know one, how will you join?"); return false; } typedLobby = typedLobby ?? ((networkingPeer.insideLobby) ? networkingPeer.lobby : null); // use given lobby, or active lobby (if any active) or none EnterRoomParams opParams = new EnterRoomParams(); opParams.RoomName = roomName; opParams.RoomOptions = roomOptions; opParams.Lobby = typedLobby; opParams.CreateIfNotExists = true; opParams.PlayerProperties = player.customProperties; opParams.ExpectedUsers = expectedUsers; return networkingPeer.OpJoinRoom(opParams); }
/// <summary>Lets you either join a named room or create it on the fly - you don't have to know if someone created the room already.</summary> /// <remarks> /// This makes it easier for groups of players to get into the same room. Once the group /// exchanged a roomName, any player can call JoinOrCreateRoom and it doesn't matter who /// actually joins or creates the room. /// /// The parameters roomOptions and typedLobby are only used when the room actually gets created by this client. /// You know if this client created a room, if you get a callback OnCreatedRoom (before OnJoinedRoom gets called as well). /// </remarks> /// <param name="roomName">Name of the room to join. Must be non null.</param> /// <param name="roomOptions">Options for the room, in case it does not exist yet. Else these values are ignored.</param> /// <param name="typedLobby">Lobby you want a new room to be listed in. Ignored if the room was existing and got joined.</param> /// <returns>If the operation got queued and will be sent.</returns> public static bool JoinOrCreateRoom(string roomName, RoomOptions roomOptions, TypedLobby typedLobby) { return JoinOrCreateRoom(roomName, roomOptions, typedLobby, null); }
/// <summary>NetworkingPeer.OpJoinRandomRoom</summary> /// <remarks>this override just makes sure we have a mRoomToGetInto, even if it's blank (the properties provided in this method are filters. they are not set when we join the game)</remarks> public override bool OpJoinRandomRoom(Hashtable expectedCustomRoomProperties, byte expectedMaxPlayers, Hashtable playerProperties, MatchmakingMode matchingType, TypedLobby typedLobby, string sqlLobbyFilter) { this.mRoomToGetInto = new Room(null, null); this.mRoomToEnterLobby = null; // join random never stores the lobby. the following join will not affect the room lobby // if typedLobby is null, the server will automatically use the active lobby or default, which is what we want anyways this.mLastJoinType = JoinType.JoinRandomGame; return base.OpJoinRandomRoom(expectedCustomRoomProperties, expectedMaxPlayers, playerProperties, matchingType, typedLobby, sqlLobbyFilter); }
void OnGUI() // da alte GUI haben wir dies im Projekt nicht verwendet, war nur zu testzwecken { //zeigt Details über den derzeitigen Status im Photonnetzwerk an GUILayout.Label(PhotonNetwork.connectionStateDetailed.ToString()); //GUILayout.Label (PhotonNetwork.GetPing ().ToString ()); //überprüft ob ich im Netzwerk und Lobby bin if (PhotonNetwork.insideLobby == true) { //Zeigt die Lobby Room-List und gestattet es Räume selbst zu erstellen GUI.Box(new Rect(Screen.width / 2.5f, Screen.height / 3, 400, 550), ""); GUILayout.BeginArea(new Rect(Screen.width / 2.5f, Screen.height / 3f, 400, 500)); GUI.color = Color.red; GUILayout.Box("Lobby"); GUI.color = Color.white; GUILayout.Label("Room Name:"); roomName = GUILayout.TextField(roomName); //hier kann man seinen Raumnamen eintragen GUILayout.Label("Max Amount of player 1-20:"); maxPlayerString = GUILayout.TextField(maxPlayerString, 2); //Eingabe der max. SPieleranzahl in dem Raum //überprüft ob im maxplayerstring etwas eingetragen wurde if (maxPlayerString != "") { maxPlayer = int.Parse(maxPlayerString); // wandelt den maxPlayerString in ein Int um es folgend auszuwerten if (maxPlayer % 2 == 1) maxPlayer += 1; // wenn ungleiche Zahl dann +1 maxplayer if (maxPlayer > 20) maxPlayer = 20; // es können nicht mehr als 20 Spieler in den Raum if (maxPlayer == 0) maxPlayer = 2; // das Minimum an SPielern beträgt immer 2 } else { maxPlayer = 2; // wenn nichts eingetragen wurde setzt es Standartwert von 2 Spielern } if (GUILayout.Button("Create Room")) { if (roomName != "" && maxPlayer > 0) //überprüft ob es einen Raumnamen gibt und ob die max Player Anzahl stimmt { RoomOptions options = new RoomOptions(); ; options.isOpen = true; options.isVisible = true; options.maxPlayers = maxPlayer; TypedLobby lobby = new TypedLobby(); lobby.Type = LobbyType.Default; PhotonNetwork.CreateRoom(roomName,options, lobby); // erstellt den Photonraum mit derzeitigen einstellungen } } GUILayout.Space(20); GUI.color = Color.red; GUILayout.Box("Game Rooms"); GUI.color = Color.white; GUILayout.Space(20); scrollPosition = GUILayout.BeginScrollView(scrollPosition, false, true, GUILayout.Width(400), GUILayout.Height(300)); foreach (RoomInfo game in PhotonNetwork.GetRoomList()) // geht durch die anzahl an vorhandenen und offenen Räume { GUI.color = Color.green; GUILayout.Box(game.name + " " + game.playerCount + "/" + game.maxPlayers); //zeigt für jeden Raum Spieleranzahl und Name des RAums an GUI.color = Color.white; if (GUILayout.Button("Join Room")) { PhotonNetwork.JoinRoom(game.name); //neben jedem Raum ist ein Button um diesem zu joinen } } GUILayout.EndScrollView(); GUILayout.EndArea(); } }
/// <summary> /// Creates a room but fails if this room is existing already. Can only be called on Master Server. /// </summary> /// <remarks> /// When successful, this calls the callbacks OnCreatedRoom and OnJoinedRoom (the latter, cause you join as first player). /// If the room can't be created (because it exists already), OnPhotonCreateRoomFailed gets called. /// /// If you don't want to create a unique room-name, pass null or "" as name and the server will assign a roomName (a GUID as string). /// /// Rooms can be created in any number of lobbies. Those don't have to exist before you create a room in them (they get /// auto-created on demand). Lobbies can be useful to split room lists on the server-side already. That can help keep the room /// lists short and manageable. /// If you set a typedLobby parameter, the room will be created in that lobby (no matter if you are active in any). /// If you don't set a typedLobby, the room is automatically placed in the currently active lobby (if any) or the /// default-lobby. /// /// Call this only on the master server. /// Internally, the master will respond with a server-address (and roomName, if needed). Both are used internally /// to switch to the assigned game server and roomName. /// /// PhotonNetwork.autoCleanUpPlayerObjects will become this room's autoCleanUp property and that's used by all clients that join this room. /// </remarks> /// <param name="roomName">Unique name of the room to create. Pass null or "" to make the server generate a name.</param> /// <param name="roomOptions">Common options for the room like maxPlayers, initial custom room properties and similar. See RoomOptions type..</param> /// <param name="typedLobby">If null, the room is automatically created in the currently used lobby (which is "default" when you didn't join one explicitly).</param> public static bool CreateRoom(string roomName, RoomOptions roomOptions, TypedLobby typedLobby) { if (offlineMode) { if (offlineModeRoom != null) { Debug.LogError("CreateRoom failed. In offline mode you still have to leave a room to enter another."); return false; } offlineModeRoom = new Room(roomName, roomOptions); offlineModeRoom.masterClientId = 1; NetworkingPeer.SendMonoMessage(PhotonNetworkingMessage.OnCreatedRoom); NetworkingPeer.SendMonoMessage(PhotonNetworkingMessage.OnJoinedRoom); return true; } if (networkingPeer.server != ServerConnection.MasterServer || !connectedAndReady) { Debug.LogError("CreateRoom failed. Client is not on Master Server or not yet ready to call operations. Wait for callback: OnJoinedLobby or OnConnectedToMaster."); return false; } return networkingPeer.OpCreateGame(roomName, roomOptions, typedLobby); }