private void UpdateLobby()
{
if (!CoopLobby.IsInLobby)
{
this.OnBack();
return;
}
if (CoopLobby.Instance == null || CoopLobby.Instance.Info == null || CoopLobby.Instance.Info.Destroyed)
{
this.SetErrorText(UiTranslationDatabase.TranslateKey("LOBBY_DESTROYED", "Lobby Destroyed", this._allCapsTexts));
this.OnBack();
CoopLobby.LeaveActive();
return;
}
if (!CoopLobby.Instance.Info.IsOwner && CoopLobby.Instance.Info.ServerId.IsValid())
{
if (!BoltNetwork.isClient && !base.gameObject.GetComponent <CoopSteamClientStarter>())
{
base.gameObject.AddComponent <CoopSteamClientStarter>().gui = this;
if (GameSetup.IsNewGame)
{
PlaneCrashAudioState.Spawn();
}
this.SetLoadingText(UiTranslationDatabase.TranslateKey("STARTING_CLIENT___", "Starting Client...", this._allCapsTexts));
}
}
else
{
bool foundHost = false;
ulong ownerId = SteamMatchmaking.GetLobbyOwner(CoopLobby.Instance.Info.LobbyId).m_SteamID;
this._lobbyScreen._playerCountLabel.text = StringEx.TryFormat(UiTranslationDatabase.TranslateKey("PLAYER_CURRENT_OVER_MAX", "PLAYERS: {0} / {1}", this._allCapsTexts), new object[]
{
CoopLobby.Instance.MemberCount,
CoopLobby.Instance.Info.MemberLimit
});
this._lobbyScreen._playerListLabel.text = CoopLobby.Instance.AllMembers.Select(delegate(CSteamID x)
{
string text = SteamFriends.GetFriendPersonaName(x);
bool flag = x.m_SteamID == ownerId;
if (flag)
{
text += " (Host)";
foundHost = true;
}
return(text);
}).Aggregate((string a, string b) => a + "\n" + b);
if (!foundHost)
{
this.OnBack();
}
}
}
public static string[] GetLobbyUsers()
{
var client = ServiceLocator.Get <IClient>();
var names = new string[client.RemoteUsers.Count];
for (var i = 0; i < names.Length; i++)
{
names[i] = SteamFriends.GetFriendPersonaName(client.RemoteUsers[i]);
Console.WriteLine(names[i]);
}
return(names);
}
/// <summary>
/// Gets the steam friendslist
/// </summary>
/// <returns>a list of friends list names</returns>
public string[] getfriendslist()
{
friendslisttemp.Clear();
int friendscount = SteamFriends.GetFriendCount(EFriendFlags.k_EFriendFlagAll);
string[] output = new string[friendscount];
for (int i = 0; i < friendscount; i++)
{
output[i] = SteamFriends.GetFriendPersonaName(SteamFriends.GetFriendByIndex(i, EFriendFlags.k_EFriendFlagAll));
friendslisttemp.Add(output[i]);
}
return(output);
}
IEnumerator SetNameWhenReady()
{
// Wait for client to get authority, then retrieve the player's Steam ID
var id = GetComponent <NetworkIdentity>();
while (id.clientAuthorityOwner == null)
{
yield return(null);
}
steamId = SteamNetworkManager.Instance.GetSteamIDForConnection(id.clientAuthorityOwner).m_SteamID;
username = SteamFriends.GetFriendPersonaName(new CSteamID(steamId));
}
public static String GetMemberName(int Index)
{
if (SteamCore.InOfflineMode())
{
return("Local player");
}
//REMOVE//if ( s_CurrentLobby.m_handle == null ) return "";
CSteamID steamIDLobbyMember = (CSteamID)SteamMatchmaking.GetLobbyMemberByIndex(s_CurrentLobby.m_handle, Index);
return(SteamFriends.GetFriendPersonaName(steamIDLobbyMember));
}
// Token: 0x06000005 RID: 5 RVA: 0x0000235C File Offset: 0x0000055C
private static void GetFriendList()
{
int friendCount = SteamFriends.GetFriendCount(EFriendFlags.k_EFriendFlagImmediate);
Console.WriteLine(friendCount);
for (int i = 0; i < friendCount; i++)
{
CSteamID friendByIndex = SteamFriends.GetFriendByIndex(i, EFriendFlags.k_EFriendFlagImmediate);
Console.WriteLine(friendByIndex);
Console.WriteLine(SteamFriends.GetFriendPersonaName(friendByIndex));
}
Program.finished = true;
}
private void OnPlayerChat(ChatEvent e)
{
var player = Scene.SceneTracker.allPlayerEntities.FirstOrDefault(ent => ent.networkId == e.Sender);
if (player == null)
{
return;
}
var steamId = player.source.RemoteEndPoint.SteamId.Id;
var name = SteamFriends.GetFriendPersonaName(new CSteamID(steamId));
Interface.Oxide.LogInfo($"{name}: {e.Message}");
}
private void OnLobbyChatMessage(LobbyChatMsg_t message)
{
byte[] messageData = new byte[32];
SteamMatchmaking.GetLobbyChatEntry(global.global_lobbyID, (int)message.m_iChatID, out CSteamID user, messageData, messageData.Length, out EChatEntryType type);
string messageString = System.Text.Encoding.UTF8.GetString(messageData);
chatBox.AddText("\n" + SteamFriends.GetFriendPersonaName((CSteamID)message.m_ulSteamIDUser) + ": " + messageString);
if (messageString.Contains("CONTINUE_SESSION") && (CSteamID)message.m_ulSteamIDUser == global.player1)
{
GetTree().ChangeScene("Scenes/game.tscn");
}
}
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]));
}
}
private void chatObjDropDownEvent(object sender, EventArgs e)
{
SteamFriends steamFriend = this.core.Steam.SteamFriends;
BindingList <string> chatObjSrc = new BindingList <string>();
this.userList.Clear();
this.userList.Add(null);
chatObjSrc.Add("######## Groups #######");
for (int i = 0; i < steamFriend.GetClanCount(); i++)
{
this.userList.Add(steamFriend.GetClanByIndex(i));
chatObjSrc.Add(steamFriend.GetClanName(steamFriend.GetClanByIndex(i)));
}
this.userList.Add(null);
chatObjSrc.Add("####### online friends #######");
for (int i = 0; i < this.core.Steam.SteamFriends.GetFriendCount(); i++)
{
if (this.core.Steam.SteamFriends.GetFriendPersonaState(steamFriend.GetFriendByIndex(i)) != EPersonaState.Offline)
{
this.userList.Add(steamFriend.GetFriendByIndex(i));
chatObjSrc.Add(steamFriend.GetFriendPersonaName(this.core.Steam.SteamFriends.GetFriendByIndex(i)));
}
}
if (this.showOfflineFriendCheck.Checked)
{
this.userList.Add(null);
chatObjSrc.Add("####### offline friends #######");
for (int i = 0; i < this.core.Steam.SteamFriends.GetFriendCount(); i++)
{
if (this.core.Steam.SteamFriends.GetFriendPersonaState(steamFriend.GetFriendByIndex(i)) == EPersonaState.Offline)
{
this.userList.Add(steamFriend.GetFriendByIndex(i));
chatObjSrc.Add(steamFriend.GetFriendPersonaName(this.core.Steam.SteamFriends.GetFriendByIndex(i)));
}
}
}
this.SelectChatObjCombo.DataSource = chatObjSrc;
}
private void OnFriendList(SteamFriends.FriendsListCallback obj)
{
// sometimes the info hasn't been cached yet, so we must wait for that
while (friends.GetFriendPersonaName(obj.FriendList[0].SteamID) == null)
{
}
Console.BackgroundColor = ConsoleColor.Cyan;
Console.ForegroundColor = ConsoleColor.Black;
Debug.WriteLine($"You have {obj.FriendList.Count} friends!");
Console.ResetColor();
Debug.WriteLine("Press any key to list them.");
Console.ReadKey();
foreach (var friend in obj.FriendList)
{
string name = friends.GetFriendPersonaName(friend.SteamID);
if (name == null)
{
name = friend.SteamID.Render();
}
Debug.WriteLine($"{name} ({friends.GetFriendPersonaState(friend.SteamID)})");
}
}
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");
}
}
}
public User(CSteamID id)
{
AvatarID = -1;
SteamID = id;
SteamUsername = SteamFriends.GetFriendPersonaName(id);
if (SteamUsername == "" || SteamUsername == "[unknown]")
{
LoadName();
}
else
{
DownloadAvatar();
}
}
/// <summary>
/// Called when the lobby receives a message.
/// </summary>
/// <param name="pCallback"></param>
private void OnLobbyMessaged(LobbyChatMsg_t pCallback)
{
if (NetLogFilter.logInfo)
{
Debug.Log($"Recieved message from {SteamFriends.GetFriendPersonaName(new CSteamID(pCallback.m_ulSteamIDUser))}. ({Time.time})");
}
byte[] msg = new byte[1024];
SteamMatchmaking.GetLobbyChatEntry(network.LocalConnection.LobbyID, (int)pCallback.m_iChatID, out CSteamID id, msg, msg.Length, out EChatEntryType type);
var segment = new ArraySegment <byte>(msg);
var incMsg = MessageHelper.FromBytes(segment, network.LocalConnection.connectedPeers[id]);
OnLobbyMessageReceived(incMsg);
}
private void OnPlayerChat(ChatEvent evt)
{
var player = Scene.SceneTracker.allPlayerEntities.FirstOrDefault(ent => ent.networkId == evt.Sender);
if (player == null)
{
return;
}
var id = player.source.RemoteEndPoint.SteamId.Id;
var name = SteamFriends.GetFriendPersonaName(new CSteamID(id));
Debug.Log($"[Chat] {name}: {evt.Message}");
}
public override void OnStartAuthority()
{
CmdSetDisplayName(SteamFriends.GetFriendPersonaName(this.UserSteamID));
CmdSetSteamID(SteamUser.GetSteamID());
for (int i = 0; i < playerNames.Length; i++)
{
playerNames[i].color = Color.grey;
}
if (hasAuthority)
{
lobbyUI.SetActive(true);
}
}
private void UpdateSteam()
{
if (Multiplayer.Clock.ElapsedMilliseconds - lastFriendUpdate < 2000)
{
return;
}
friends.Clear();
int friendCount = SteamFriends.GetFriendCount(EFriendFlags.k_EFriendFlagImmediate);
for (int i = 0; i < friendCount; i++)
{
CSteamID friend = SteamFriends.GetFriendByIndex(i, EFriendFlags.k_EFriendFlagImmediate);
SteamFriends.GetFriendGamePlayed(friend, out FriendGameInfo_t friendGame);
bool playingRimworld = friendGame.m_gameID.AppID() == SteamIntegration.RimWorldAppId;
if (!playingRimworld)
{
continue;
}
int avatar = SteamFriends.GetSmallFriendAvatar(friend);
string username = SteamFriends.GetFriendPersonaName(friend);
string connectValue = SteamFriends.GetFriendRichPresence(friend, "connect");
CSteamID serverHost = CSteamID.Nil;
if (connectValue != null &&
connectValue.Contains(SteamIntegration.SteamConnectStart) &&
ulong.TryParse(connectValue.Substring(SteamIntegration.SteamConnectStart.Length), out ulong hostId))
{
serverHost = (CSteamID)hostId;
}
friends.Add(new SteamPersona()
{
id = friend,
avatar = avatar,
username = username,
playingRimworld = playingRimworld,
serverHost = serverHost,
});
}
friends.SortByDescending(f => f.serverHost != CSteamID.Nil);
lastFriendUpdate = Multiplayer.Clock.ElapsedMilliseconds;
}
private void OnFriendMsg(SteamFriends.FriendMsgCallback callback)
{
if (callback.EntryType == EChatEntryType.ChatMsg)
{
var sender = callback.Sender;
Friend currentChatter = Chatters.FirstOrDefault(chatter => chatter.SteamID.AccountID == sender.AccountID);
if (currentChatter == null)
{
currentChatter = new Friend()
{
WelcomedDate = DateTime.Now,
ChatState = ChatState.NoInteraction,
SteamID = sender,
IsReceivingAdvInfo = false
};
Chatters.Add(currentChatter);
}
TimeSpan timeSpan = DateTime.Now - currentChatter.WelcomedDate;
if (timeSpan.Minutes >= 5)
{
currentChatter.ChatState = ChatState.NoInteraction;
}
string responseMessage = String.Empty;
if (BasicCommands.ContainsKey(callback.Message))
{
responseMessage = BasicCommands[callback.Message];
currentChatter.ChatState = ChatState.Welcomed;
}
else if (currentChatter.ChatState == ChatState.NoInteraction)
{
currentChatter.ChatState = ChatState.Welcomed;
responseMessage = WelcomeMessage;
}
else if (currentChatter.ChatState == ChatState.Welcomed)
{
responseMessage = CommandNotFoundMessage;
}
SteamFriends.SendChatMessage(sender, EChatEntryType.ChatMsg, responseMessage);
Console.WriteLine($"{SteamFriends.GetFriendPersonaName(sender)}: {callback.Message}");
Console.WriteLine($"BOT: {responseMessage}");
}
}
// LOGIC
public void Refresh()
{
if (!SteamManager.initializedMain)
{
return;
}
string personaName = SteamFriends.GetFriendPersonaName(m_SteamId);
Sprite icon = SteamUtilities.GetMediumAvatar(m_SteamId);
EPersonaState state = SteamFriends.GetFriendPersonaState(m_SteamId);
m_Name = personaName;
m_Icon = icon;
m_State = state;
}
private void HandleSteamIdUpdated(ulong oldSteamId, ulong newSteamId)
{
var cSteamId = new CSteamID(newSteamId);
displayNameText.text = SteamFriends.GetFriendPersonaName(cSteamId);
int imageId = SteamFriends.GetLargeFriendAvatar(cSteamId);
if (imageId == -1)
{
return;
}
profileImage.texture = GetSteamImageAsTexture(imageId);
}
private void OnPlayerDisconnected(BoltConnection connection)
{
if (connection == null)
{
return;
}
var userId = connection.RemoteEndPoint.SteamId.Id;
var name = SteamFriends.GetFriendPersonaName(new CSteamID(userId));
// Let covalence know
//Libraries.Covalence.TheForestCovalenceProvider.Instance.PlayerManager.NotifyPlayerDisconnect(connection);
Debug.Log($"{userId}/{name} quit");
}
public void OnGetUserStats(UserStatsReceived_t pCallback)
{
if (pCallback.m_steamIDUser == SteamUser.GetSteamID())
{
int score = 0;
SteamUserStats.GetStat("GAMESCORE", out score);
player1Rank.text = SteamFriends.GetPersonaName() + " (" + score + ")";
}
else if (pCallback.m_steamIDUser == otherUsr)
{
int score = 0;
SteamUserStats.GetUserStat(otherUsr, "GAMESCORE", out score);
player2Rank.text = SteamFriends.GetFriendPersonaName(otherUsr) + " (" + score + ")";
}
}
//Create a networked player given SteamID information.
//Pass in SteamUser.GetSteamID() for <id> if you want to
//construct your own player object.
public Player ConstructPlayer(CSteamID id)
{
Player p = new Player();
string name = SteamFriends.GetFriendPersonaName(id);
if (name.Equals(""))
{
Debug.LogError("Name request returned blank, (probably) lobby not ready");
return(null);
}
p.SetName(name);
p.SetUniqueID(id.m_SteamID);
p.SetPrivateKey("key");
return(p);
}
async void OnMessageReceivedAsync(SteamFriends.FriendMsgCallback callback)
{
var values = new Dictionary <string, string>
{
{ "sender", _steamFriends.GetFriendPersonaName(callback.Sender).ToString() },
{ "message", callback.Message },
{ "profile_url", "https://steamcommunity.com/profiles/" + callback.Sender.ConvertToUInt64() }
};
var content = new FormUrlEncodedContent(values);
var response = await client.PostAsync("https://pivasbot.appspot.com/api/receiveMessage", content);
var responseString = await response.Content.ReadAsStringAsync();
}
/// <summary>
/// Initialize the steam avatar display.
/// </summary>
/// <param name="steamId">The <see cref="CSteamID"/> of the user who's information to get</param>
/// <param name="size">The <see cref="AvatarSize"/> of the image to get</param>
public void Initialize(CSteamID steamId, AvatarSize size = AvatarSize.Medium)
{
if (SteamManager.Initialized)
{
avatarImage.texture = GetAvatar(steamId, size);
if (steamId != SteamUser.GetSteamID())
{
personaName.text = SteamFriends.GetFriendPersonaName(steamId);
}
else
{
personaName.text = SteamFriends.GetPersonaName();
}
}
}
void ReceiveChatMessage(LobbyChatMsg_t cb)
{
CSteamID user;
EChatEntryType chatType;
int dataLenght = SteamMatchmaking.GetLobbyChatEntry((CSteamID)cb.m_ulSteamIDLobby, (int)cb.m_iChatID, out user, chatData, chatData.Length, out chatType);
string name = SteamFriends.GetFriendPersonaName(user);
if (chatType == EChatEntryType.k_EChatEntryTypeChatMsg)
{
int n;
string message = ByteManipulator.ReadString(chatData, 0, encoder, out n);
Text.text += "\n" + name + " : " + message;
}
}
//Creating this callback handler allows us to respond to a message
//We can perform specific actions based on this message
//but for now we will just stick with responding to every message
//with "hello"
static void OnChatMessage(SteamFriends.FriendMsgCallback callback)
{
//This allows us to send a message, callback.sender is the steam ID
//of the friend who sent the message, therefore we can use it
//for the SendChatMessage function which requires a steam ID
//Then, chat entry type is set to chat message in order to
//inform steam we are sending a text based message
//and not a "x user is typing..." or something like that
//this if statement prevents the bot from saqying something every while you're typing
//because the "x user is typing..." is interperated as a steam message, so
//we need to check if it's an actual chat message
//we're going to create a switch statement to mass-check the arguements.
//before we start off, go to main() and work with the chat.txt
//we'll need two string variables, one to hold the trimed version of the message, and another to hold the read line.
Random rnd = new Random();
int ind = rnd.Next(rLine.Count);
string rand = rLine [ind];
Console.WriteLine(steamFriends.GetFriendPersonaName(callback.Sender));
if (callback.Message.Length > 0)
{
Console.WriteLine(callback.Message);
Console.WriteLine(rand);
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, rand); //if so, respond with the response listed in chat.txt
}
if (callback.Message.Length > 5)
{
rLine.Add(callback.Message);
}
return; //exit method
}
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));
}
/// <summary>
/// Sends a message to the target.
/// </summary>
/// <param name="msg"></param>
/// <param name="qos"></param>
public void Send(short opcode, ISerializablePacket packet, SteamNetworkingIdentity target)/* OutgoingMessage msg)*/
{
if (!IsConnected)
{
return;
}
if (!IsLocal)
{
return;
}
using (PooledNetWriter w = NetWriterPool.GetWriter())
{
MessageHelper.CreateAndFinalize(w, opcode, packet);
var segment = w.ToArray();
//if (NetLogFilter.messageDiagnostics) { NetDiagnostics.OnSend(opcode, segment.Count, 1); }
// Initialize unmanaged memory to hold the array.
int size = Marshal.SizeOf(segment[0]) * segment.Length;
IntPtr pnt = Marshal.AllocHGlobal(size);
try
{
// Copy the array to unmanaged memory.
Marshal.Copy(segment, 0, pnt, segment.Length);
EResult result = SteamNetworkingMessages.SendMessageToUser(ref target, pnt, (uint)size, Constants.k_nSteamNetworkingSend_ReliableNoNagle, 0);
if (NetLogFilter.logInfo)
{
Debug.Log($"Packet to {SteamFriends.GetFriendPersonaName(target.GetSteamID())} was sent with resilt: {result}. ({Time.time})");
}
}
finally
{
// Free the unmanaged memory.
Marshal.FreeHGlobal(pnt);
}
//if (SteamNetworking.SendP2PPacket(target, segment, (uint)segment.Length, EP2PSend.k_EP2PSendReliable))
//{
// if (NetLogFilter.logInfo) { Debug.Log($"Packet to {SteamFriends.GetFriendPersonaName(target)} was successfully sent. ({Time.time})"); }
//}
//else
//{
// if (NetLogFilter.logInfo) { Debug.Log($"Packet to {SteamFriends.GetFriendPersonaName(target)} failed to send. ({Time.time})"); }
//}
}
}
private void Start()
{
if (!SteamManager.Initialized)
{
return;
}
string myName = SteamFriends.GetPersonaName();
int friendCount = SteamFriends.GetFriendCount(EFriendFlags.k_EFriendFlagImmediate);
for (int i = 0; i < friendCount; i++)
{
CSteamID friend = SteamFriends.GetFriendByIndex(i, EFriendFlags.k_EFriendFlagImmediate);
string friendName = SteamFriends.GetFriendPersonaName(friend);
print(myName + " is friends with " + friendName);
}
}