public static int GetLobbyMemberCount()
{
if (SteamCore.InOfflineMode())
{
return(1);
}
//REMOVE//if ( s_CurrentLobby.m_handle == null ) return -1;
return(SteamMatchmaking.GetNumLobbyMembers(s_CurrentLobby.m_handle));
}
bool LobbyHasUser()
{
for (int i = 0; i < SteamMatchmaking.GetNumLobbyMembers(Listener.CLobbyID); i++)
{
if (SteamMatchmaking.GetLobbyMemberByIndex(Listener.CLobbyID, i).m_SteamID == RemoteID.m_SteamID)
{
return(true);
}
}
return(false);
}
public void UpdateLobbyInformation()
{
RemoteUsers.Clear();
var num = SteamMatchmaking.GetNumLobbyMembers(Lobby);
for (var i = 0; i < num; i++)
{
var id = SteamMatchmaking.GetLobbyMemberByIndex(Lobby, i);
RemoteUsers.Add(id);
}
}
/// <summary>
/// Generates string message with premade team members' IDs to be posted in game lobby.
/// Necessary for host to process premade teams
/// </summary>
public string GeneratePremadeMessage()
{
string msg = "";
for (int i = 0; i < SteamMatchmaking.GetNumLobbyMembers(teambuilderLobbyId); i++)
{
msg += SteamMatchmaking.GetLobbyMemberByIndex(teambuilderLobbyId, i).m_SteamID.ToString();
msg += ".";
}
return(msg);
}
public static void SetOtherLobbyData(ulong lobbyId, LobbyInfo info, bool refresh = true)
{
string version = SteamMatchmaking.GetLobbyData(new CSteamID(lobbyId), "version");
info.UsedSlots = SteamMatchmaking.GetNumLobbyMembers(new CSteamID(lobbyId));
if (info.UsedSlots > 0 && info.HostName != "" && version == PACKET_VERSION)
{
LobbyData.Add(lobbyId, info);
MultiplayerListing.refreshLobbyList();
}
}
public static void SendToAllInLobby(byte[] bytes)
{
int numMembers = SteamMatchmaking.GetNumLobbyMembers(_lobbyInfo.LobbyID);
for (int i = 0; i < numMembers; i++)
{
CSteamID member = SteamMatchmaking.GetLobbyMemberByIndex(_lobbyInfo.LobbyID, i);
if (member.m_SteamID != SteamAPI.GetUserID())
{
SteamNetworking.SendP2PPacket(member, bytes, (uint)bytes.Length, EP2PSend.k_EP2PSendReliable);
}
}
}
private static void OnLobbyChatUpdate(LobbyChatUpdate_t result)
{
Console.WriteLine("Lobby chat update");
int lobbyMemberCount = SteamMatchmaking.GetNumLobbyMembers(new CSteamID(LobbyId));
PlayerList.Clear();
_playerNames.Clear();
for (int i = 0; i < lobbyMemberCount; i++)
{
PlayerList.Add(SteamMatchmaking.GetLobbyMemberByIndex(new CSteamID(LobbyId), i));
_playerNames.Add(SteamFriends.GetFriendPersonaName(PlayerList[i]));
}
}
public void OnLobbyChatUpdate(LobbyChatUpdate_t pCallback)
{
if (C.LOG_INVITE)
{
Debug.Log("Premade lobby: OnLobbyChatUpdate");
}
UpdateTeammatesPresence();
CheckLock();
/// If someone left
if (pCallback.m_ulSteamIDLobby == teambuilderLobbyId.m_SteamID &&
(pCallback.m_rgfChatMemberStateChange == (uint)EChatMemberStateChange.k_EChatMemberStateChangeLeft ||
pCallback.m_rgfChatMemberStateChange == (uint)EChatMemberStateChange.k_EChatMemberStateChangeDisconnected))
{
if (C.LOG_INVITE)
{
Debug.LogWarning(SteamFriends.GetFriendPersonaName(new CSteamID(pCallback.m_ulSteamIDUserChanged)) + " left lobby");
}
/// Leave lobby if left only this player
if (SteamMatchmaking.GetNumLobbyMembers(teambuilderLobbyId) <= 1)
{
LeaveTeambuilderLobby();
}
/// Update 'premade' message
var snm = SteamNetworkManager.Instance;
if (snm.steamLobbyId != CSteamID.Nil)
{
SteamMatchmaking.SetLobbyMemberData(snm.steamLobbyId, "premade", GeneratePremadeMessage());
}
/// If became new lobby owner - start pinging chat
if (IsLobbyOwner() && _pingCoroutine == null)
{
_pingCoroutine = StartCoroutine(PingChat());
}
}
/// If user enters lobby
else if (pCallback.m_rgfChatMemberStateChange == (uint)EChatMemberStateChange.k_EChatMemberStateChangeEntered &&
pCallback.m_ulSteamIDLobby == teambuilderLobbyId.m_SteamID)
{
if (C.LOG_INVITE)
{
Debug.LogWarning(SteamFriends.GetFriendPersonaName(new CSteamID(pCallback.m_ulSteamIDUserChanged)) + " joined lobby");
}
}
}
/// <summary>
/// Loads the lobby and its related data
/// </summary>
/// <param name="lobbyId">The lobby to load data for</param>
/// <remarks>
/// <see cref="SteamLobby"/> should only be initalized for a lobby that the user is a member of e.g. on create or join of a lobby.
/// Constructing a <see cref="SteamLobby"/> for a lobby you are not a member of will cause some data to be missing due to security on Valve's side.
/// </remarks>
public SteamLobby(CSteamID lobbyId)
{
id = lobbyId;
var memberCount = SteamMatchmaking.GetNumLobbyMembers(id);
for (int i = 0; i < memberCount; i++)
{
var memberId = SteamMatchmaking.GetLobbyMemberByIndex(id, i);
members.Add(new SteamworksLobbyMember(id, memberId));
}
previousOwner = Owner;
}
public virtual bool ShouldAcceptSteamId(CSteamID id)
{
int count = SteamMatchmaking.GetNumLobbyMembers(steamLobbyId);
for (int i = 0; i < count; i++)
{
if (SteamMatchmaking.GetLobbyMemberByIndex(steamLobbyId, i) == id)
{
return(true);
}
}
return(false);
}
private bool IsMemberInSteamLobby(CSteamID steamUser)
{
if (SteamManager.Initialized)
{
int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(this.m_LobbyId);
for (int i = 0; i < numLobbyMembers; i++)
{
if (SteamMatchmaking.GetLobbyMemberByIndex(this.m_LobbyId, i).m_SteamID == steamUser.m_SteamID)
{
return(true);
}
}
}
return(false);
}
public void LobbyEntered(LobbyEnter_t enterLobby)
{
connectedPlayers.Clear();
otherPlayers.Clear();
ResetManagers();
lobbyID = (CSteamID)enterLobby.m_ulSteamIDLobby;
int playerCount = SteamMatchmaking.GetNumLobbyMembers(lobbyID);
MultiplayerChat.AddChat("Entered Lobby!");
//Send packets to all players, to establish P2P connections with them
if (playerCount > 1)
{
for (int i = 0; i < playerCount; i++)
{
CSteamID lobbyMember = SteamMatchmaking.GetLobbyMemberByIndex(lobbyID, i);
SteamNetworking.SendP2PPacket(lobbyMember, new byte[] { 255 }, 1, EP2PSend.k_EP2PSendReliable, 0);
SteamNetworking.SendP2PPacket(lobbyMember, new byte[] { 255 }, 1, EP2PSend.k_EP2PSendReliable, 1);
SteamNetworking.SendP2PPacket(lobbyMember, new byte[] { 255 }, 1, EP2PSend.k_EP2PSendReliable, 2);
if (!connectedPlayers.Contains(lobbyMember.m_SteamID))
{
connectedPlayers.Add(lobbyMember.m_SteamID);
PlayerJoinedManagers(lobbyMember.m_SteamID);
}
if (lobbyMember != SteamUser.GetSteamID())
{
otherPlayers.Add(lobbyMember.m_SteamID);
}
}
}
//Set up network data
NetworkGameManager.managerID = ulong.Parse(SteamMatchmaking.GetLobbyData(lobbyID, MANAGER_ID));
NetworkGameManager.playerID = SteamUser.GetSteamID().m_SteamID;
if (!connectedPlayers.Contains(SteamUser.GetSteamID().m_SteamID))
{
connectedPlayers.Add(SteamUser.GetSteamID().m_SteamID);
PlayerJoinedManagers(SteamUser.GetSteamID().m_SteamID);
}
MultiplayerChat.AddChat("This game's manager is " + SteamFriends.GetFriendPersonaName((CSteamID)NetworkGameManager.managerID));
isInGame = true;
Log("Entered Lobby! \nThis game's manager is " + SteamFriends.GetFriendPersonaName((CSteamID)NetworkGameManager.managerID));
}
public void Update()
{
if (!Patches.patch_SteamManager.Initialized)
{
return;
}
timer -= Time.deltaTime;
if (timer <= 0)
{
timer = 5f;
int newMembers = SteamMatchmaking.GetNumLobbyMembers(lobbyID);
DiscordManager.instance.SetPartyNumber(newMembers);
}
}
void CloseAllConnections()
{
if (currentLobbyId == CSteamID.Nil)
{
return;
}
SteamMatchmaking.LeaveLobby(currentLobbyId);
var playerCount = SteamMatchmaking.GetNumLobbyMembers(currentLobbyId);
for (var i = 0; i < playerCount; i++)
{
var id = SteamMatchmaking.GetLobbyMemberByIndex(currentLobbyId, i);
SteamNetworking.CloseP2PSessionWithUser(id);
}
Debug.Log($"[Steam] Left lobby {currentLobbyId}");
currentLobbyId = CSteamID.Nil;
}
void OnLobbyEntered(LobbyEnter_t result)
{
current_lobbyID = result.m_ulSteamIDLobby;
if (result.m_EChatRoomEnterResponse == 1)
{
main_menu_canvas.enabled = false;
lobby_canvas.enabled = true;
Debug.Log("Lobby joined!");
lobbyID = (Steamworks.CSteamID)current_lobbyID;
players_in_lobby = SteamMatchmaking.GetNumLobbyMembers(lobbyID);
update_lobby_labels();
}
else
{
Debug.Log("Failed to join lobby.");
}
}
public bool IsMemberInSteamLobby(CSteamID steamUser)
{
if (SteamManager.Initialized)
{
int numMembers = SteamMatchmaking.GetNumLobbyMembers(steamLobbyId);
for (int i = 0; i < numMembers; i++)
{
var member = SteamMatchmaking.GetLobbyMemberByIndex(steamLobbyId, i);
if (member.m_SteamID == steamUser.m_SteamID)
{
return(true);
}
}
}
return(false);
}
public static Dictionary <CSteamID, string> GetMembersInLobby()
{
Dictionary <CSteamID, string> members = new Dictionary <CSteamID, string>();
if (!SteamManager.Initialized)
{
Logger.Error("CONNECTION FAILED");
return(members);
}
int numMembers = SteamMatchmaking.GetNumLobbyMembers(_lobbyInfo.LobbyID);
for (int i = 0; i < numMembers; i++)
{
CSteamID member = SteamMatchmaking.GetLobbyMemberByIndex(_lobbyInfo.LobbyID, i);
members.Add(member, SteamFriends.GetFriendPersonaName(member));
}
return(members);
}
private void HandleWaiting()
{
if (lobbyCursor.back())
{
SetText("lefthost");
myMesh.gameObject.SetActive(true);
SteamMatchmaking.LeaveLobby((CSteamID)current_lobbyID);
initializedStatus = -2;
current_lobbyID = 0;
return;
}
int numusers = SteamMatchmaking.GetNumLobbyMembers((CSteamID)current_lobbyID);
if (numusers == 1)
{
return;
}
SteamMatchmaking.SetLobbyData((CSteamID)current_lobbyID, "status", "full");
SetUpReadyButtons();
otherUsr = SteamMatchmaking.GetLobbyMemberByIndex((CSteamID)current_lobbyID, 1);
lastTimeMessageReceived = Time.time;
int score = 0;
SteamUserStats.GetUserStat(otherUsr, "GAMESCORE", out score);
if (player2Rank == null)
{
FontData f = PD.mostCommonFont.Clone(); f.color = Color.white;
player2Rank = GetMeshText(new Vector3(0.745f, 1.8f), SteamFriends.GetFriendPersonaName(otherUsr), f);
SteamUserStats.RequestUserStats(otherUsr);
}
string p2 = SteamMatchmaking.GetLobbyMemberData((CSteamID)current_lobbyID, otherUsr, "player");
if (string.IsNullOrEmpty(p2))
{
return;
}
parent.ForcePlayer2(int.Parse(p2));
initializedStatus = 6;
myMesh.gameObject.SetActive(false);
}
void UpdateLobbyInfo( CSteamID steamIDLobby, ref Lobby outLobby )
{
outLobby.m_SteamID = steamIDLobby;
outLobby.m_Owner = SteamMatchmaking.GetLobbyOwner( steamIDLobby );
outLobby.m_Members = new LobbyMembers[SteamMatchmaking.GetNumLobbyMembers(steamIDLobby)];
outLobby.m_MemberLimit = SteamMatchmaking.GetLobbyMemberLimit(steamIDLobby);
int nDataCount = SteamMatchmaking.GetLobbyDataCount(steamIDLobby);
outLobby.m_Data = new LobbyMetaData[nDataCount];
for (int i = 0; i < nDataCount; ++i)
{
bool lobbyDataRet = SteamMatchmaking.GetLobbyDataByIndex(steamIDLobby, i, out outLobby.m_Data[i].m_Key, Constants.k_nMaxLobbyKeyLength, out outLobby.m_Data[i].m_Value, Constants.k_cubChatMetadataMax);
if (!lobbyDataRet)
{
Debug.LogError("SteamMatchmaking.GetLobbyDataByIndex returned false.");
continue;
}
}
}
private void UpdateLobby()
{
if (!m_IsInLobby)
{
return;
}
var membernum = SteamMatchmaking.GetNumLobbyMembers(m_LobbyId);
Debug.Log("房间更新，当前人数为：" + membernum);
List <string> members = new List <string>();
for (int i = 0; i < membernum; i++)
{
var memberId = SteamMatchmaking.GetLobbyMemberByIndex(m_LobbyId, i);
members.Add(SteamFriends.GetFriendPersonaName(memberId));
GameObject.Find("LobbyPanel").GetComponent <LobbyPanel>().updateMember(members.ToArray());
}
}
// Callback for Matchmaking JoinLobby
private void OnLobbyJoin(LobbyEnter_t lobbyEnter)
{
m_lobbyID = new CSteamID(lobbyEnter.m_ulSteamIDLobby);
EChatRoomEnterResponse response = (EChatRoomEnterResponse)lobbyEnter.m_EChatRoomEnterResponse;
print("joined lobby waiting to test 3secs...");
string hostSteamID = SteamMatchmaking.GetLobbyData(m_lobbyID, "Host");
ulong steamid = ulong.Parse(hostSteamID);
int neededPlayers = int.Parse(SteamMatchmaking.GetLobbyData(m_lobbyID, "NeededPlayers"));
int playerCount = SteamMatchmaking.GetNumLobbyMembers(m_lobbyID);
SteamMatchmaking.SetLobbyMemberData(m_lobbyID, "cid", ClientPlayer.Singleton.Cid.ToString());
Match.InitMatch();
Match.NetworkLobby.SetSteamIDToConnect(steamid);
Match.MatchSettings = new MatchSettings(BallersGamemode.SP_BOTS, 5, 60.0f * 6.0f, 4);
Match.PlayersNeeded = int.Parse(SteamMatchmaking.GetLobbyData(m_lobbyID, "NeededPlayers"));;
Match.MatchID = 1;
if (steamid == ClientPlayer.Singleton.SteamID)
{
Match.HostServer = true;
//Match.AddPlayer(steamid, ClientPlayer.Singleton.Cid);
//StartCoroutine(Test());
}
// Debug.Log($"{playerCount} / {neededPlayers}");
// if (playerCount >= neededPlayers)
// {
// Debug.Log($"Required players met. Starting...");
// m_matchSetup.Setup(Match.HostID);
// }
ClientPlayer.Singleton.State = ServerPlayerState.JOINED;
// FOR DEBUGGING
//m_matchSetup.Setup(lobbyEnter, steamid);
}
public void OnP2PSessionRequest(P2PSessionRequest_t pCallback)
{
try
{
Logger.Debug($"{pCallback.m_steamIDRemote} requested a P2P session");
int numMembers = SteamMatchmaking.GetNumLobbyMembers(SteamAPI.getLobbyID());
for (int i = 0; i < numMembers; i++)
{
var member = SteamMatchmaking.GetLobbyMemberByIndex(SteamAPI.getLobbyID(), i);
if (member.m_SteamID == pCallback.m_steamIDRemote.m_SteamID)
{
Logger.Debug($"{pCallback.m_steamIDRemote} is in our lobby, lets accept their P2P session");
bool ret = SteamNetworking.AcceptP2PSessionWithUser(pCallback.m_steamIDRemote);
}
}
} catch (Exception e)
{
Logger.Error(e);
}
}
private void UpdateLobbyMembers()
{
if (this.m_LobbyId == CSteamID.Nil)
{
this.m_LobbyMembers.Clear();
return;
}
int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(this.m_LobbyId);
this.m_LobbyMembers.Resize(numLobbyMembers);
for (int i = 0; i < numLobbyMembers; i++)
{
CSteamID lobbyMemberByIndex = SteamMatchmaking.GetLobbyMemberByIndex(this.m_LobbyId, i);
P2PLobbyMemberInfo p2PLobbyMemberInfo = this.m_LobbyMembers[i];
p2PLobbyMemberInfo.m_Address = new P2PAddressSteam
{
m_SteamID = lobbyMemberByIndex
};
p2PLobbyMemberInfo.m_Name = SteamMatchmaking.GetLobbyMemberData(this.m_LobbyId, lobbyMemberByIndex, "member_name");
}
}
public static bool IsMemberInSteamLobby(CSteamID steamUser)
{
if (!SteamManager.Initialized)
{
Logger.Error("CONNECTION FAILED");
return(false);
}
int numMembers = SteamMatchmaking.GetNumLobbyMembers(_lobbyInfo.LobbyID);
for (int i = 0; i < numMembers; i++)
{
var member = SteamMatchmaking.GetLobbyMemberByIndex(_lobbyInfo.LobbyID, i);
if (member.m_SteamID == steamUser.m_SteamID)
{
return(true);
}
}
return(false);
}
private void OnLobbyChatUpdate(LobbyDataUpdate_t lobbyDataUpdate)
{
ulong steamid = lobbyDataUpdate.m_ulSteamIDMember;
print("Player joining... " + steamid);
string joinedCID = SteamMatchmaking.GetLobbyMemberData(
m_lobbyID,
new CSteamID(steamid),
"cid");
if (joinedCID == null)
{
return;
}
if (lobbyDataUpdate.m_bSuccess == 1)
{
Match.AddPlayer(steamid, int.Parse(joinedCID));
int neededPlayers = int.Parse(SteamMatchmaking.GetLobbyData(m_lobbyID, "NeededPlayers"));
int playerCount = SteamMatchmaking.GetNumLobbyMembers(m_lobbyID);
if (new CSteamID(steamid) == Match.HostID)
{
Match.HostServer = true;
Match.AddPlayer(steamid, ClientPlayer.Singleton.Cid);
}
Debug.Log($"{playerCount} / {neededPlayers}");
if (playerCount >= neededPlayers)
{
Debug.Log($"Required players met. Starting...");
m_matchSetup.Setup(Match.HostID);
}
}
else
{
Match.RemovePlayer(steamid);
}
}
protected void OnSessionRequest(P2PSessionRequest_t pCallback)
{
if (lobby.Equals(CSteamID.Nil))
{
Debug.Log("User trying to send packet to us, and our lobby doesn't exist!");
return;
}
bool flag = false;
for (int i = 0; i < SteamMatchmaking.GetNumLobbyMembers(lobby); i++)
{
if (SteamMatchmaking.GetLobbyMemberByIndex(lobby, i) == pCallback.m_steamIDRemote)
{
flag = true;
}
}
if (flag)
{
SteamNetworking.AcceptP2PSessionWithUser(pCallback.m_steamIDRemote);
}
}
// Token: 0x06000003 RID: 3 RVA: 0x000022A8 File Offset: 0x000004A8
private static void OnLobbyEnter(LobbyEnter_t result)
{
int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers((CSteamID)result.m_ulSteamIDLobby);
CSteamID lobbyOwner = SteamMatchmaking.GetLobbyOwner((CSteamID)result.m_ulSteamIDLobby);
Console.WriteLine(Math.Max(0, numLobbyMembers - 1));
Console.WriteLine(lobbyOwner);
Console.WriteLine(SteamFriends.GetFriendPersonaName(lobbyOwner));
CSteamID steamID = SteamUser.GetSteamID();
for (int i = 0; i < numLobbyMembers; i++)
{
CSteamID lobbyMemberByIndex = SteamMatchmaking.GetLobbyMemberByIndex((CSteamID)result.m_ulSteamIDLobby, i);
if (lobbyMemberByIndex != steamID)
{
Console.WriteLine(lobbyMemberByIndex);
Console.WriteLine(SteamFriends.GetFriendPersonaName(lobbyMemberByIndex));
}
}
SteamMatchmaking.LeaveLobby((CSteamID)result.m_ulSteamIDLobby);
Program.finished = true;
}
void OnLobbyEnter(LobbyEnter_t pCallback, bool bIOFailure) {
if (bIOFailure) {
ESteamAPICallFailure reason = SteamUtils.GetAPICallFailureReason(m_LobbyEnterCallResult.Handle);
Debug.LogError("OnLobbyEnter encountered an IOFailure due to: " + reason);
return; // TODO: Recovery
}
Debug.Log("[" + LobbyEnter_t.k_iCallback + " - LobbyEnter] - " + pCallback.m_ulSteamIDLobby + " -- " + pCallback.m_rgfChatPermissions + " -- " + pCallback.m_bLocked + " -- " + (EChatRoomEnterResponse)pCallback.m_EChatRoomEnterResponse);
m_LobbyEnterResponse = (EChatRoomEnterResponse)pCallback.m_EChatRoomEnterResponse;
if(m_LobbyEnterResponse != EChatRoomEnterResponse.k_EChatRoomEnterResponseSuccess) {
ChangeState(EChatClientState.FailedToJoin);
return;
}
m_CurrentLobby.m_SteamID = (CSteamID)pCallback.m_ulSteamIDLobby;
m_CurrentLobby.m_Members = new LobbyMembers[SteamMatchmaking.GetNumLobbyMembers(m_CurrentLobby.m_SteamID)];
m_CurrentLobby.m_MemberLimit = SteamMatchmaking.GetLobbyMemberLimit(m_CurrentLobby.m_SteamID);
ChangeState(EChatClientState.InLobby);
}
/// <summary>
/// Handle the RequestLobbyData Steam API callback
/// </summary>
/// <param name="result">The <see cref="LobbyDataUpdate_t"/> result set</param>
private void OnLobbyDataUpdated(LobbyDataUpdate_t result)
{
for (int i = 0; i < serverList.Count; i++)
{
if (serverList[i].SteamId.m_SteamID == result.m_ulSteamIDLobby)
{
// Lobby no longer exists so remove it from the list
if (result.m_bSuccess == 0)
{
RemoveServer(i);
return;
}
serverList[i].ListItem.serverName.text = SteamMatchmaking.GetLobbyData(serverList[i].SteamId, "name");
serverList[i].ListItem.gameType.text = SteamMatchmaking.GetLobbyData(serverList[i].SteamId, "fnr_gameType");
serverList[i].ListItem.gameMode.text = SteamMatchmaking.GetLobbyData(serverList[i].SteamId, "fnr_gameMode");
var maxPlayers = SteamMatchmaking.GetLobbyMemberLimit(serverList[i].SteamId);
var currPlayers = SteamMatchmaking.GetNumLobbyMembers(serverList[i].SteamId);
serverList[i].ListItem.playerCount.text = $"{currPlayers}/{maxPlayers}";
return;
}
}
}
// User Started Communication
void OnP2PSessionRequest(P2PSessionRequest_t pCallback)
{
for (int i = 0; i < SteamMatchmaking.GetNumLobbyMembers(CLobbyID); i++)
{
if (SteamMatchmaking.GetLobbyMemberByIndex(CLobbyID, i).m_SteamID == pCallback.m_steamIDRemote.m_SteamID)
{
if (SteamNetworking.AcceptP2PSessionWithUser(pCallback.m_steamIDRemote))
{
WriteEvent($"Accepted P2P Connection With User: {pCallback.m_steamIDRemote.m_SteamID}", LogType.Info);
long fakeAddress = 0;
SteamServerConnection NewClient = new SteamServerConnection(pCallback.m_steamIDRemote.m_SteamID, this, Interlocked.Increment(ref currentEndPointCount), out fakeAddress);
SteamMatchmaking.SetLobbyData(CLobbyID, fakeAddress.ToString(), pCallback.m_steamIDRemote.m_SteamID.ToString());
RegisterUser(NewClient);
RegisterConnection(NewClient);
}
else
{
WriteEvent($"Failed P2P Connection With User: {pCallback.m_steamIDRemote.m_SteamID}", LogType.Info);
}
return;
}
}
}