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);
}
