//----------------------------------------------------------------------------- // Purpose: Handle clients connecting //----------------------------------------------------------------------------- void OnP2PSessionRequest(P2PSessionRequest_t pCallback) { Logging.BMSLog.Log("OnP2PSesssionRequest Called steamIDRemote: " + pCallback.m_steamIDRemote); // we'll accept a connection from anyone if (AcceptingConnections) { SteamNetworking.AcceptP2PSessionWithUser(pCallback.m_steamIDRemote); } }
private void OnP2PSessionRequest(P2PSessionRequest_t result) { CSteamID mSteamIDRemote = result.m_steamIDRemote; if (this._connectionStateMap.ContainsKey(mSteamIDRemote) && this._connectionStateMap[mSteamIDRemote] != NetSocialModule.ConnectionState.Inactive) { SteamNetworking.AcceptP2PSessionWithUser(mSteamIDRemote); } }
private void OnP2PSessionRequest(P2PSessionRequest_t result) { CSteamID steamIDRemote = result.m_steamIDRemote; if (_connectionStateMap.ContainsKey(steamIDRemote) && _connectionStateMap[steamIDRemote] != 0) { SteamNetworking.AcceptP2PSessionWithUser(steamIDRemote); } }
/// <summary> /// Callback for SteamNetworking.OnP2PSessionRequest /// Accepts all incoming connections /// </summary> /// <param name="requestorSteamId">Incoming P2P request</param> private void OnP2PSessionRequest(SteamId requestorSteamId) { // TODO: Add logic to check/filter incoming P2Prequests? if (!SteamNetworking.AcceptP2PSessionWithUser(requestorSteamId)) { Logging.BMSLog.LogWarning("Could not accept P2P Session with User: " + requestorSteamId.Value); } }
private void OnP2PSessionRequest(P2PSessionRequest_t request) { // if (LogHelper.CurrentLogLevel <= LogLevel.Developer) LogHelper.LogInfo("SteamP2PTransport - OnP2PSessionRequest - m_steamIDRemote: " + request.m_steamIDRemote); CSteamID userId = request.m_steamIDRemote; //Todo: Might want to check if we expect the user before just accepting it. SteamNetworking.AcceptP2PSessionWithUser(userId); }
void OnNewConnection(P2PSessionRequest_t result) { //Debug.Log("Wa"); if (Array.IndexOf(Sender.TOmb, result.m_steamIDRemote) != -1) { hassession = SteamNetworking.AcceptP2PSessionWithUser(result.m_steamIDRemote); return; } }
/// <summary> /// Callback for SteamNetworking.OnP2PSessionRequest /// Currently accepts all P2PSession requests /// </summary> /// <param name="requestorSteamId">Server SteamId</param> private void OnP2PSessionRequest(SteamId requestorSteamId) { // TODO: Add in logic to check that the P2PSession request comes from the server if (!SteamNetworking.AcceptP2PSessionWithUser(requestorSteamId)) { Logging.BMSLog.LogWarning("Could not accept P2P Session with User: " + requestorSteamId.Value); } }
void OnP2PSessionRequest(P2PSessionRequest_t pCallback) { Debug.Log("[" + P2PSessionRequest_t.k_iCallback + " - P2PSessionRequest] - " + pCallback.m_steamIDRemote); bool ret = SteamNetworking.AcceptP2PSessionWithUser(pCallback.m_steamIDRemote); print("SteamNetworking.AcceptP2PSessionWithUser(" + pCallback.m_steamIDRemote + ") - " + ret); m_RemoteSteamId = pCallback.m_steamIDRemote; }
private void OnP2PSessionRequest(SteamId userId) { if (NetworkLog.CurrentLogLevel <= LogLevel.Developer) { NetworkLog.LogInfo("SteamP2PTransport - OnP2PSessionRequest - m_steamIDRemote: " + userId); } //Todo: Might want to check if we expect the user before just accepting it. SteamNetworking.AcceptP2PSessionWithUser(userId); }
private void OnP2PSessionRequest(P2PSessionRequest_t result) { CSteamID steamIdRemote = (CSteamID)result.m_steamIDRemote; if (!this._connectionStateMap.ContainsKey(steamIdRemote) || this._connectionStateMap[steamIdRemote] == NetSocialModule.ConnectionState.Inactive) { return; } SteamNetworking.AcceptP2PSessionWithUser(steamIdRemote); }
void OnP2PSessionRequest(P2PSessionRequest_t pCallback) { Console.WriteLine("[OnP2PSessionRequest] -- Got session request from {0}", pCallback.m_steamIDRemote); bool ok = SteamNetworking.AcceptP2PSessionWithUser(pCallback.m_steamIDRemote); Console.WriteLine("[OnP2PSessionRequest] -- Accept ok: {0}", ok); m_RemoteSteamID = pCallback.m_steamIDRemote; }
private void OnP2PSessionRequest(P2PSessionRequest_t pCallback, bool bIOFailure) { Debug.Log("[" + P2PSessionRequest_t.k_iCallback + " - P2PSessionRequest] - " + pCallback.m_steamIDRemote); bool ret = SteamNetworking.AcceptP2PSessionWithUser(pCallback.m_steamIDRemote); Debug.Log("SteamNetworking.AcceptP2PSessionWithUser(" + pCallback.m_steamIDRemote + ") - " + ret); //add this to the list of id's we have accepted m_AcceptedIDs.Add(pCallback.m_steamIDRemote); }
void OnNewConnection(P2PSessionRequest_t result) { foreach (CSteamID id in lobby_members_) { if (id == result.m_steamIDRemote) { SteamNetworking.AcceptP2PSessionWithUser(result.m_steamIDRemote); return; } } }
public void OnP2PSessionRequest(P2PSessionRequest_t callback) { if (!SteamNetworking.AcceptP2PSessionWithUser(callback.m_steamIDRemote)) { LogUtils.Debug("Failde to accept P2P Request: " + callback.m_steamIDRemote); } else { LogUtils.Debug("Accepted P2P Request: " + callback.m_steamIDRemote); } }
//------------ ACCEPT OR REJECT INCOMING CONNECTION ------------ private void OnP2PSessionRequest(P2PSessionRequest_t request) { if (request.m_steamIDRemote.Equals(_globals.HostId) || _globals.UserIds.Contains(request.m_steamIDRemote)) { SteamNetworking.AcceptP2PSessionWithUser(request.m_steamIDRemote); } else { GD.Print($"A connection was just rejected from {request.m_steamIDRemote}."); } }
protected override void OnNewConnection(SteamId id) { if (hostSteamID == id) { SteamNetworking.AcceptP2PSessionWithUser(id); } else { Debug.LogError("P2P Acceptance Request from unknown host ID."); } }
protected override void OnNewConnection(P2PSessionRequest_t result) { if (hostSteamID == result.m_steamIDRemote) { SteamNetworking.AcceptP2PSessionWithUser(result.m_steamIDRemote); } else { Debug.LogError("P2P Acceptance Request from unknown host ID."); } }
private void OnP2PSessionRequest(SteamId id) { if (id != ServerId) { MelonModLogger.LogError("Got a P2P session request from something that is not the server."); } else { SteamNetworking.AcceptP2PSessionWithUser(id); } }
// Token: 0x060009A4 RID: 2468 RVA: 0x0004673C File Offset: 0x0004493C private static void OnSessionRequest(P2PSessionRequest_t data) { ZLog.Log("Got session request from " + data.m_steamIDRemote); if (SteamNetworking.AcceptP2PSessionWithUser(data.m_steamIDRemote)) { ZSteamSocketOLD listner = ZSteamSocketOLD.GetListner(); if (listner != null) { listner.QueuePendingConnection(data.m_steamIDRemote); } } }
// ----------- ACCEPT OR REJECT INCOMING CONNECTION ----------- public void OnP2PSessionRequest(P2PSessionRequest_t request) { if (request.m_steamIDRemote == global.player1 || request.m_steamIDRemote == global.player2) { SteamNetworking.AcceptP2PSessionWithUser(request.m_steamIDRemote); GD.Print("You have accepted incoming connection from " + SteamFriends.GetFriendPersonaName(request.m_steamIDRemote)); } else { GD.Print("A connection was just rejected from " + request.m_steamIDRemote + "."); } }
private void OnP2PSessionRequest(P2PSessionRequest_t request) { if (NetworkingManager.Singleton.LogLevel <= LogLevel.Developer) { UnityEngine.Debug.Log("SteamP2PTransport - OnP2PSessionRequest - m_steamIDRemote: " + request.m_steamIDRemote); } CSteamID userId = request.m_steamIDRemote; //Todo: Might want to check if we expect the user before just accepting it. SteamNetworking.AcceptP2PSessionWithUser(userId); }
void OnP2PSessionRequest(P2PSessionRequest_t request) { CSteamID clientId = request.m_steamIDRemote; // if (SteamNetworking) // { SteamNetworking.AcceptP2PSessionWithUser(clientId); // } // else // { // Debug.LogWarning("Unexpected session request from " + clientId); // } }
protected override void OnNewConnectionInternal(P2PSessionRequest_t result) { Debug.Log("OnNewConnectionInternal in client"); if (hostSteamID == result.m_steamIDRemote) { SteamNetworking.AcceptP2PSessionWithUser(result.m_steamIDRemote); } else { Debug.LogError(""); } }
protected override void OnNewConnectionInternal(SteamId id) { Debug.Log("OnNewConnectionInternal in client"); if (hostSteamID == id) { SteamNetworking.AcceptP2PSessionWithUser(id); } else { Debug.LogError(""); } }
private void OnP2PSessionRequest(P2PSessionRequest_t request) { CSteamID clientId = request.m_steamIDRemote; if (IsExpectingClient(clientId)) { SteamNetworking.AcceptP2PSessionWithUser(clientId); } else { Debug.LogWarning("Unexpected session request from " + clientId); } }
/// <summary> /// Callback for SteamNetworking.OnP2PSessionRequest /// Accepts all incoming connections /// </summary> /// <param name="requestorSteamId">Incoming P2P request</param> private void OnP2PSessionRequest(SteamId requestorSteamId) { if (AcceptingConnections) { if (!SteamNetworking.AcceptP2PSessionWithUser(requestorSteamId)) { Logging.BMSLog.LogWarning("Could not accept P2P Session with user: "******"P2P Request received but server is not accepting connections"); } }
void OnP2PSessionRequested(P2PSessionRequest_t pCallback) { Debug.Log("P2P session request received"); var member = pCallback.m_steamIDRemote; if (NetworkServer.active && SteamNetworkManager.Instance.IsMemberInSteamLobby(member)) { // Accept the connection if this user is in the lobby Debug.Log("P2P connection accepted"); SteamNetworking.AcceptP2PSessionWithUser(member); CreateP2PConnectionWithPeer(member); } }
private void OnP2PSessionRequest(P2PSessionRequest_t result) { //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_0011: Unknown result type (might be due to invalid IL or missing references) //IL_0016: Unknown result type (might be due to invalid IL or missing references) //IL_001d: Unknown result type (might be due to invalid IL or missing references) //IL_002b: Unknown result type (might be due to invalid IL or missing references) //IL_0033: Unknown result type (might be due to invalid IL or missing references) WeGameHelper.WriteDebugString(" OnP2PSessionRequest"); CSteamID steamIDRemote = result.m_steamIDRemote; if (_connectionStateMap.ContainsKey(steamIDRemote) && _connectionStateMap[steamIDRemote] != 0) { SteamNetworking.AcceptP2PSessionWithUser(steamIDRemote); } }
private void OnP2PSessionRequest(P2PSessionRequest_t request) { if (NetworkManager.Singleton.LogLevel <= LogLevel.Developer) { NetworkLog.LogInfoServer(nameof(SteamNetworkingTransport) + " - OnP2PSessionRequest - m_steamIDRemote: " + request.m_steamIDRemote); } CSteamID userId = request.m_steamIDRemote; //Todo: Might want to check if we expect the user before just accepting it. #if UNITY_SERVER SteamGameServerNetworking.AcceptP2PSessionWithUser(userId); #else SteamNetworking.AcceptP2PSessionWithUser(userId); #endif }
public void OnStateEnter() { if (!SteamAPI.Init()) { DialogResult eResult = MessageBox.Show("Coult not initialize Steam API...\n" + "Make sure Steam is not closed\n" + "What do you want to do?\n" + "Press OK to get back to Main Menu\n" + "Press Cancel to Abort the Game.", "Steam API Error!", MessageBoxButtons.OKCancel, MessageBoxIcon.Error); if (eResult == DialogResult.OK) { //go back to main menu! } else { } } SteamMatchmaking.AddRequestLobbyListStringFilter("name", "Glukosesirup's game", ELobbyComparison.k_ELobbyComparisonEqual); //Creation and management of lobby, the lobbies created must be set with SteamMatchmackig.SetData(); lobbyCreated = Callback <LobbyCreated_t> .Create(OnLobbyCreated); lobbyList = Callback <LobbyMatchList_t> .Create(OnGetLobbiesList); lobbyEnter = Callback <LobbyEnter_t> .Create(OnLobbyEntered); lobbyChatMsg = Callback <LobbyChatMsg_t> .Create(OnLobbyChatMsg); connectionInfo = Callback <P2PSessionRequest_t> .Create(OnNewP2PConnection); //To accept a P2P connection Callback <P2PSessionRequest_t> .Create(cb => { SteamNetworking.AcceptP2PSessionWithUser(cb.m_steamIDRemote); } ); //SteamMatchmaking.RequestLobbyList(); //start multiplayer game, look for lobbies, if no lobbies are found then create a single lobby and join it }