private void CBACK_P2PSessionRequest(P2PSessionRequest_t rq) { // // TODO: This needs to verify that they're in this game with us! // SteamNetworking.AcceptP2PSessionWithUser(rq.m_steamIDRemote); }
void OnConnectRequested(P2PSessionRequest_t ev) { if (connection.Remote == ev.m_steamIDRemote) { SteamNetworking.AcceptP2PSessionWithUser(ev.m_steamIDRemote); } }
private void OnSessionRequest(P2PSessionRequest_t request) { CSteamID clientId = request.m_steamIDRemote; if (steamIdToConnection.ContainsKey(clientId)) { SteamNetworking.AcceptP2PSessionWithUser(clientId); } else { if (steamIdToConnection.Count < maxConnections - 1) { if (ShouldAcceptSteamId(clientId)) { if (SteamNetworking.AcceptP2PSessionWithUser(clientId)) { if (SteamNetworking.SendP2PPacket(clientId, null, 0, EP2PSend.k_EP2PSendReliable)) { var conn = new SteamNetConnection(clientId); ForceInitConnection(conn); steamIdToConnection.Add(clientId, conn); NetworkServer.AddExternalConnection(conn); } } } else { Debug.Log("Steam session request ignored"); } } } }
private void OnP2PRequest(P2PSessionRequest_t pCallback) { var steamId = pCallback.m_steamIDRemote; var name = SteamFriends.GetFriendPersonaName(steamId); Debug.Log("p2p request from " + name); }
public void P2PRequest(P2PSessionRequest_t request) { if (connectedPlayers.Contains(request.m_steamIDRemote.m_SteamID)) { SteamNetworking.AcceptP2PSessionWithUser(request.m_steamIDRemote); } }
private void OnP2PSessionRequest(P2PSessionRequest_t result) { CSteamID steamIdRemote = (CSteamID)result.m_steamIDRemote; if (this._connectionStateMap.ContainsKey(steamIdRemote) && this._connectionStateMap[steamIdRemote] != NetSocialModule.ConnectionState.Inactive) { SteamNetworking.AcceptP2PSessionWithUser(steamIdRemote); } else { if (!this._acceptingClients || !this._mode.HasFlag((Enum)ServerMode.FriendsOfFriends) && SteamFriends.GetFriendRelationship(steamIdRemote) != 3) { return; } SteamNetworking.AcceptP2PSessionWithUser(steamIdRemote); P2PSessionState_t p2PsessionStateT; do { ; }while (SteamNetworking.GetP2PSessionState(steamIdRemote, ref p2PsessionStateT) && p2PsessionStateT.m_bConnecting == 1); if (p2PsessionStateT.m_bConnectionActive == null) { this.Close(steamIdRemote); } this._connectionStateMap[steamIdRemote] = NetSocialModule.ConnectionState.Authenticating; this._connectionAcceptedCallback((ISocket) new SocialSocket((RemoteAddress) new SteamAddress(steamIdRemote))); } }
private static void onP2PSessionRequest(P2PSessionRequest_t req) { CSteamID other = req.m_steamIDRemote; Log.info("Got a P2P session request: " + req.m_steamIDRemote); Friend match = null; foreach (Friend friend in IPlatform.instance.getFriends()) { if (friend.id == other.m_SteamID) { match = friend; break; } } if (match == null) { match = getFriendFromId(other); } if (IPlatform.instance.onFriendConnected != null) { PlatformConnection conn = new SteamConnection(match, true); conns.Add(other.m_SteamID, conn); IPlatform.instance.onFriendConnected(match, conn); } }
//----------------------------------------------------------------------------- // Purpose: Handle clients connecting //----------------------------------------------------------------------------- void OnP2PSessionRequest(P2PSessionRequest_t pCallback) { Debug.Log("OnP2PSesssionRequest Called steamIDRemote: " + pCallback.m_steamIDRemote); // Riley // we'll accept a connection from anyone SteamGameServerNetworking.AcceptP2PSessionWithUser(pCallback.m_steamIDRemote); }
// Token: 0x06000B45 RID: 2885 RVA: 0x003CD544 File Offset: 0x003CB744 private void OnP2PSessionRequest(P2PSessionRequest_t result) { CSteamID steamIDRemote = result.m_steamIDRemote; if (this._connectionStateMap.ContainsKey(steamIDRemote) && this._connectionStateMap[steamIDRemote] != NetSocialModule.ConnectionState.Inactive) { SteamNetworking.AcceptP2PSessionWithUser(steamIDRemote); return; } if (!this._acceptingClients) { return; } if (!this._mode.HasFlag(ServerMode.FriendsOfFriends) && SteamFriends.GetFriendRelationship(steamIDRemote) != EFriendRelationship.k_EFriendRelationshipFriend) { return; } SteamNetworking.AcceptP2PSessionWithUser(steamIDRemote); P2PSessionState_t p2PSessionState_t; while (SteamNetworking.GetP2PSessionState(steamIDRemote, out p2PSessionState_t) && p2PSessionState_t.m_bConnecting == 1) { } if (p2PSessionState_t.m_bConnectionActive == 0) { this.Close(steamIDRemote); } this._connectionStateMap[steamIDRemote] = NetSocialModule.ConnectionState.Authenticating; this._connectionAcceptedCallback(new SocialSocket(new SteamAddress(steamIDRemote))); }
private void OnP2PSessionRequest(P2PSessionRequest_t result) { P2PSessionState_t p2PSessionStateT; CSteamID mSteamIDRemote = result.m_steamIDRemote; if (this._connectionStateMap.ContainsKey(mSteamIDRemote) && this._connectionStateMap[mSteamIDRemote] != NetSocialModule.ConnectionState.Inactive) { SteamNetworking.AcceptP2PSessionWithUser(mSteamIDRemote); return; } if (!this._acceptingClients) { return; } SteamNetworking.AcceptP2PSessionWithUser(mSteamIDRemote); while (SteamNetworking.GetP2PSessionState(mSteamIDRemote, out p2PSessionStateT) && p2PSessionStateT.m_bConnecting == 1) { } if (p2PSessionStateT.m_bConnectionActive == 0) { this.Close(mSteamIDRemote); } this._connectionStateMap[mSteamIDRemote] = NetSocialModule.ConnectionState.Authenticating; this._connectionAcceptedCallback(new SocialSocket(new SteamAddress(mSteamIDRemote))); }
// Event Handlers void OnP2PSessionRequest(P2PSessionRequest_t evt) { var myId = SteamUser.GetSteamID(); var remoteId = evt.m_steamIDRemote; foreach (var lobbyId in _connectedLobbies.Keys) { var count = SteamMatchmaking.GetNumLobbyMembers(lobbyId); bool hasMe = false; bool hasRemote = false; for (var i = 0; i < count; i++) { var memberId = SteamMatchmaking.GetLobbyMemberByIndex(lobbyId, i); hasMe |= memberId == myId; hasRemote |= memberId == remoteId; } if (hasMe && hasRemote) { Assert.IsTrue(SteamNetworking.AcceptP2PSessionWithUser(remoteId)); Debug.Log($"[Steam] Established connection with {remoteId}"); return; } } // Did not find a matching lobby close the session. Debug.LogError($"[Steam] Unexpected connection with {remoteId}"); Assert.IsTrue(SteamNetworking.CloseP2PSessionWithUser(remoteId)); }
protected override void OnNewConnection(P2PSessionRequest_t result) { #if UNITY_SERVER SteamGameServerNetworking.AcceptP2PSessionWithUser(result.m_steamIDRemote); #else SteamNetworking.AcceptP2PSessionWithUser(result.m_steamIDRemote); #endif }
void OnNewConnection(P2PSessionRequest_t result) { //Debug.Log("Wa"); if (Array.IndexOf(Sender.TOmb, result.m_steamIDRemote) != -1) { hassession = SteamNetworking.AcceptP2PSessionWithUser(result.m_steamIDRemote); return; } }
//----------------------------------------------------------------------------- // 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); } }
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); }
// Steam Callbacks void OnP2PSessionRequest(P2PSessionRequest_t evt) { var id = evt.m_steamIDRemote; Debug.Log($"[Steam] P2P Session requested by player: {id}"); if (!NewConnectionCheck(id)) { Debug.LogWarning("[Steam] Unexpected session request from " + id); } }
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; }
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); }
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); }
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); } }
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."); } }
void OnNewConnection(P2PSessionRequest_t result) { foreach (CSteamID id in lobby_members_) { if (id == result.m_steamIDRemote) { SteamNetworking.AcceptP2PSessionWithUser(result.m_steamIDRemote); return; } } }
//------------ 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}."); } }
// 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 + "."); } }
static void OnP2PSessionRequest(P2PSessionRequest_t callback) { // accept connection request to anyone if (connectedPlayer == callback.m_steamIDRemote) { SteamGameServerNetworking.AcceptP2PSessionWithUser(callback.m_steamIDRemote); } else { Console.WriteLine("Rejecting connection request."); } }
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); }