internal void OnStateUpdated(SteamFriends.PersonaStateCallback callback)
{
if (callback == null)
{
Bot.ArchiLogger.LogNullError(nameof(callback));
return;
}
if ((callback.AvatarHash == null) || (callback.AvatarHash.Length == 0))
{
return;
}
string avatarHash = BitConverter.ToString(callback.AvatarHash).Replace("-", "").ToLowerInvariant();
if (string.IsNullOrEmpty(avatarHash))
{
return;
}
string avatarURL = "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/" + avatarHash.Substring(0, 2) + "/" + avatarHash + "_full.jpg";
AvatarPictureBox.ImageLocation = avatarURL;
AvatarPictureBox.LoadAsync();
}
private void personaStateCallback(SteamFriends.PersonaStateCallback callback)
{
if (this.core.ChatInterface.ChatIOMembers.Contains(callback.FriendID))
{
this.resetIOMemberList();
}
}
private static void OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
if (!JobManager.TryRemoveJob(new JobID(callback.FriendID), out var job))
{
return;
}
var command = job.Command;
if (callback.FriendID.IsClanAccount)
{
var clantag = string.IsNullOrEmpty(callback.ClanTag) ?
string.Empty :
$" {Colors.NORMAL}(Clan tag: {Colors.LIGHTGRAY}{callback.ClanTag}{Colors.NORMAL})";
command.Reply($"{Colors.BLUE}{callback.Name}{Colors.NORMAL} -{Colors.DARKBLUE} https://steamcommunity.com/gid/{callback.FriendID.ConvertToUInt64()}/{clantag}");
}
else if (callback.FriendID.IsIndividualAccount)
{
command.Reply($"{Colors.BLUE}{callback.Name}{Colors.NORMAL} -{Colors.DARKBLUE} https://steamcommunity.com/profiles/{callback.FriendID.ConvertToUInt64()}/");
}
else
{
command.Reply(callback.Name);
}
}
/// <summary>
/// Gets someone's name when joining a chatroom and fires off
/// OnFriendChatEnter module callbacks.
/// </summary>
/// <param name="callback"></param>
private void OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
var friendID = callback.FriendID;
var name = callback.Name;
var user = UserManager.GetUser(friendID);
if (!UserManager.UserExists(friendID))
{
user = UserManager.AddUser(friendID, name, callback.State);
}
if (callback.SourceSteamID.IsChatAccount)
{
var chatID = callback.SourceSteamID;
var chatRoom = ChatRoomManager.AddChatRoom(chatID, null);
// Add the user to this chat room.
chatRoom.AddUser(user);
// Trigger EnteredChat for each module.
ModuleManager.EnteredChat(chatRoom, user, callback);
}
// Update their persona state.
user.PersonaState = callback.State;
}
void OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
var req = GetRequest(r => r.SteamID == callback.FriendID);
if (req == null)
{
return; // not a sid we requested
}
if (req.SteamID.IsClanAccount)
{
IRC.Instance.Send(req.Channel, "{0}: {1} (http://steamcommunity.com/gid/{2}/)",
req.Requester.Nickname, callback.Name, req.SteamID.ConvertToUInt64()
);
}
else if (req.SteamID.IsIndividualAccount)
{
IRC.Instance.Send(req.Channel, "{0}: {1} (http://steamcommunity.com/profiles/{2}/) (Last Online = {3}, Last Offline = {4})",
req.Requester.Nickname, callback.Name, req.SteamID.ConvertToUInt64(), callback.LastLogOn, callback.LastLogOff
);
}
else
{
IRC.Instance.Send(req.Channel, "{0}: {1}", req.Requester.Nickname, callback.Name);
}
}
public override void OnFriendChatEnter(SteamFriends.PersonaStateCallback callback)
{
if (!_cooldowns.Keys.Contains(callback.FriendID))
{
_cooldowns[callback.FriendID] = new Stopwatch();
}
}
private void OnSteamFriendsPersonaChange(SteamFriends.PersonaStateCallback callback)
{
new Task(() =>
{
GetSteamProfile(callback.FriendID.ConvertToUInt64());
}).Start();
}
static void OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
// this callback is received when the persona state (friend information) of a friend changes
// for this sample we'll simply display the names of the friends
Console.WriteLine("State change: {0}", callback.Name);
}
private static void OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
JobAction job;
if (!JobManager.TryRemoveJob(new JobID(callback.FriendID), out job) || !job.IsCommand)
{
return;
}
var command = job.CommandRequest.Command;
if (callback.FriendID.IsClanAccount)
{
var clantag = string.IsNullOrEmpty(callback.ClanTag) ? string.Empty : string.Format(" {0}(Clan tag: {1}{2}{3})",
Colors.NORMAL, Colors.LIGHTGRAY, callback.ClanTag, Colors.NORMAL);
CommandHandler.ReplyToCommand(command, "{0}{1}{2} -{3} https://steamcommunity.com/gid/{4}/{5}",
Colors.BLUE, callback.Name, Colors.NORMAL,
Colors.DARKBLUE, callback.FriendID.ConvertToUInt64(), clantag
);
}
else if (callback.FriendID.IsIndividualAccount)
{
CommandHandler.ReplyToCommand(command, "{0}{1}{2} -{3} https://steamcommunity.com/profiles/{4}/ {5}(Last login: {6}, Last logoff: {7})",
Colors.BLUE, callback.Name, Colors.NORMAL,
Colors.DARKBLUE, callback.FriendID.ConvertToUInt64(),
Colors.DARKGRAY, callback.LastLogOn, callback.LastLogOff
);
}
else
{
CommandHandler.ReplyToCommand(command, callback.Name);
}
}
private static void OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
if (!JobManager.TryRemoveJob(new JobID(callback.FriendID), out var job))
{
return;
}
var command = job.Command;
if (callback.FriendID.IsClanAccount)
{
var clantag = string.IsNullOrEmpty(callback.ClanTag) ? string.Empty : string.Format(" {0}(Clan tag: {1}{2}{3})",
Colors.NORMAL, Colors.LIGHTGRAY, callback.ClanTag, Colors.NORMAL);
command.Reply("{0}{1}{2} -{3} https://steamcommunity.com/gid/{4}/{5}",
Colors.BLUE, callback.Name, Colors.NORMAL,
Colors.DARKBLUE, callback.FriendID.ConvertToUInt64(), clantag
);
}
else if (callback.FriendID.IsIndividualAccount)
{
command.Reply("{0}{1}{2} -{3} https://steamcommunity.com/profiles/{4}/",
Colors.BLUE, callback.Name, Colors.NORMAL,
Colors.DARKBLUE, callback.FriendID.ConvertToUInt64()
);
}
else
{
command.Reply(callback.Name);
}
}
public void HandleCallback(CallbackMsg msg)
{
if (msg.IsType <SteamFriends.PersonaStateCallback>())
{
SteamFriends.PersonaStateCallback callback = (SteamFriends.PersonaStateCallback)msg;
LoadFriendsList();
}
}
static void OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
// this callback is received when the persona state (friend information) of a friend changes
// for this sample we'll simply display the names of the friends
fObject.updateName(new Friend()
{
customName = callback.Name, steamFrindsID = callback.FriendID.ConvertToUInt64().ToString()
});
Console.WriteLine("State change: {0}", callback.Name);
}
static void OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
// this callback is received when the persona state (friend information) of a friend changes
// for this sample we'll simply display the names of the friends
AccountController.getAccount(user).setFriendsName(new Friend()
{
name = callback.Name, steamFrindsID = callback.FriendID.ConvertToUInt64().ToString()
});
Console.WriteLine("State change: {0}", callback.Name);
}
/// <summary>
/// When someone other than the bot enters the chat, signal the
/// modules.
/// </summary>
/// <param name="chatRoom"></param>
/// <param name="user"></param>
/// <param name="callback"></param>
public void EnteredChat(
ChatRoom chatRoom,
User user,
SteamFriends.PersonaStateCallback callback
)
{
foreach (var module in chatRoom.GetAllModules())
{
module.OnChatEnter(callback);
}
}
void OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
// this callback is received when the persona state (friend information) of a friend changes
// for this sample we'll simply display the names of the friends
Console.WriteLine("State change: {0} - {1}", callback.Name, callback.State);
new Task(() =>
{
Test(callback.FriendID.ConvertToUInt64(), callback.Name);
}).Start();
}
internal async Task OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
if (callback == null)
{
ASF.ArchiLogger.LogNullError(nameof(callback));
return;
}
string nickname = callback.Name ?? "";
string avatarHash = "";
if ((callback.AvatarHash != null) && (callback.AvatarHash.Length > 0) && callback.AvatarHash.Any(singleByte => singleByte != 0))
{
avatarHash = BitConverter.ToString(callback.AvatarHash).Replace("-", "").ToLowerInvariant();
if (avatarHash.Equals("0000000000000000000000000000000000000000"))
{
avatarHash = "";
}
}
if (!string.IsNullOrEmpty(LastNickname) && nickname.Equals(LastNickname) && !string.IsNullOrEmpty(LastAvatarHash) && avatarHash.Equals(LastAvatarHash))
{
return;
}
await Semaphore.WaitAsync().ConfigureAwait(false);
try {
if (!string.IsNullOrEmpty(LastNickname) && nickname.Equals(LastNickname) && !string.IsNullOrEmpty(LastAvatarHash) && avatarHash.Equals(LastAvatarHash))
{
return;
}
const string request = SharedInfo.StatisticsServer + "/api/PersonaState";
Dictionary <string, string> data = new Dictionary <string, string>(4)
{
{ "SteamID", Bot.SteamID.ToString() },
{ "Guid", Program.GlobalDatabase.Guid.ToString("N") },
{ "Nickname", nickname },
{ "AvatarHash", avatarHash }
};
// We don't need retry logic here
if (await Program.WebBrowser.UrlPost(request, data).ConfigureAwait(false))
{
LastNickname = nickname;
LastAvatarHash = avatarHash;
}
} finally {
Semaphore.Release();
}
}
private void OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
if (callback == null)
{
return;
}
SteamID steamID = callback.FriendID;
SteamID sourceSteamID = callback.SourceSteamID;
string steamNickname = callback.Name;
EPersonaState personaState = callback.State;
EClanRank clanRank = (EClanRank)callback.ClanRank;
}
public void HandleCallback(CallbackMsg msg)
{
if (msg.IsType <SteamClient.ConnectCallback>())
{
Logger.Get().Log("[Callback] Connected");
}
else if (msg.IsType <SteamClient.DisconnectCallback>())
{
Logger.Get().Log("[Callback] Disconnected");
IsAuthorized = false;
Send(Protocol.Server.LoggedOut);
}
else if (msg.IsType <SteamUser.LogOnCallback>())
{
SteamUser.LogOnCallback callback = (SteamUser.LogOnCallback)msg;
Logger.Get().Log("[Callback] Logon: " + callback.Result + "/" + callback.ExtendedResult);
if (callback.Result == EResult.AccountLogonDenied || callback.Result == EResult.InvalidLoginAuthCode)
{
Send(Protocol.Server.AuthRequest);
IsAuthorized = true;
}
if (callback.Result == EResult.OK)
{
IsAuthorized = true;
}
}
else if (msg.IsType <SteamUser.LoginKeyCallback>())
{
Logger.Get().Log("[Callback] Logged in, setting persona state to online");
steam.Friends.SetPersonaState(SteamKit2.EPersonaState.Online);
Send(Protocol.Server.LoggedIn);
}
else if (msg.IsType <SteamFriends.FriendMsgCallback>())
{
SteamFriends.FriendMsgCallback chat = (SteamFriends.FriendMsgCallback)msg;
if (chat.EntryType == EChatEntryType.ChatMsg)
{
Send(Protocol.Server.ChatReceived, chat.Sender.ToString(), chat.Message);
}
}
else if (msg.IsType <SteamFriends.PersonaStateCallback>())
{
SteamFriends.PersonaStateCallback friend = (SteamFriends.PersonaStateCallback)msg;
Send(Protocol.Server.FriendStateChanged, friend.FriendID.ToString(), friend.State.ToString(), friend.GameName);
}
}
public void OnChatEnter(SteamFriends.PersonaStateCallback callback)
{
if (ChatEnterCallback != null)
{
try
{
ChatEnterCallback(callback);
}
catch (Exception e)
{
ModuleManager.PrintStackFrame(e);
}
}
}
private void OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
/*
* If we already have the user saved, just update (all) values
* Otherwise, create a new entry for them
*/
if (friends.ContainsKey(callback.FriendID))
{
friends[callback.FriendID].UpdateValues(callback);
}
else
{
friends[callback.FriendID] = new FriendDetails(callback);
}
}
public void UpdateValues(SteamFriends.PersonaStateCallback callback)
{
Name = callback.Name;
FriendID = callback.FriendID;
State = callback.State;
StateFlags = callback.StateFlags;
GameID = callback.GameID;
GameName = callback.GameName;
GameServer = callback.GameServerIP;
GameServerPort = callback.GameServerPort;
QueryPort = callback.QueryPort;
LastLogOff = callback.LastLogOff;
LastLogOn = callback.LastLogOn;
}
private static void OnPersonaState(SteamFriends.PersonaStateCallback obj)
{
if (obj.State != EPersonaState.Offline)
{
ListPlayingGame.Add(obj.FriendID);
}
else
{
if (ListPlayingGame.Contains(obj.FriendID))
{
ListPlayingGame.Remove(obj.FriendID);
}
}
Console.WriteLine("State change: {0}", obj.Name);
}
internal static void OnStateUpdated(Bot bot, SteamFriends.PersonaStateCallback callback)
{
if ((bot == null) || (callback == null))
{
Logging.LogNullError(nameof(bot) + " || " + nameof(callback));
return;
}
BotStatusForm form;
if (!BotStatusForm.BotForms.TryGetValue(bot.BotName, out form))
{
return;
}
form.OnStateUpdated(callback);
}
static void OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
SteamID friendID = callback.FriendID;
SteamID sourceSteamID = callback.SourceSteamID.ConvertToUInt64();
EClanRank clanRank = (EClanRank)callback.ClanRank;
EPersonaState state = callback.State;
//ListFriends.UpdateName(friendId.ConvertToUInt64(), callback.Name); not yet
//ListFriends.UpdateStatus(friendId.ConvertToUInt64(), state.ToString()); not yet
if (friendID.ConvertToUInt64() == steamClient.SteamID)
{
if (sourceSteamID.IsClanAccount)
{
switch (clanRank)
{
case EClanRank.Owner:
// case EClanRank.Officer:
//case EClanRank.Moderator:
if (!OfficerClanDictionary.ContainsKey(sourceSteamID))
{
OfficerClanDictionary.Add(sourceSteamID, friendID.ConvertToUInt64());
}
break;
}
}
//
if (callback.GameID > 0)
{
UserPlaying = true;
}
else
{
UserPlaying = false;
}
if (steamFriends.GetPersonaState() != EPersonaState.Online) //detect when user goes afk
{
//isAwayState = true;
}
else
{
//isAwayState = false;
}
}
}
void OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
// this callback is received when the persona state (friend information) of a friend changes
// for this sample we'll simply display the names of the friends
Console.WriteLine("State change: {0}", callback.Name);
//lstLog.Items.Add(String.Format("상태 변경: {0}", callback.Name));
String strCurrFindID = callback.FriendID.AccountID.ToString();
String strCurrName = callback.Name.ToString();
int currIdx = lstFriendList.FindString(strCurrFindID);
if (currIdx != -1)
{
lstFriendList.Items[currIdx] = strCurrName;
}
//isRunning = false;
}
public void OnPersonaState(SteamFriends.PersonaStateCallback cb)
{
if (cb.FriendID.IsClanAccount)
{
Log.WriteLine("Found clan {0} <{1}>", cb.FriendID, steam_friends.GetClanName(cb.FriendID));
var c = ClanGroup.Active.FindOrCreate(cb.FriendID);
c.Id = cb.FriendID;
c.AvatarHash = steam_friends.GetClanAvatar(cb.FriendID);
c.Name = steam_friends.GetClanName(cb.FriendID);
}
Core.Util.Buffer b = new Core.Util.Buffer();
b.SetAlignment(4);
b.WriteULong(cb.FriendID);
b.WriteUInt((uint)cb.StatusFlags);
Instance.PostCallback(Common.CallbackId(Common.CallbackType.SteamFriends, 4), b);
}
private void OnPersonaStateChanged(SteamFriends.PersonaStateCallback personaStateCallback)
{
try
{
if (!personaStateCallback.FriendID.IsIndividualAccount)
{
return;
}
if (personaStateCallback.FriendID == _steamUser.SteamID)
{
return;
}
var steamId = personaStateCallback.FriendID.Render(true);
_coordinator.Consume(coordinator => coordinator.UpdateUser(steamId, personaStateCallback.Name));
}
catch (Exception e)
{
_logger.Fatal($"#{SequenceNumber} Fatal unhandled exception (OnPersonaStateChanged) : {e.Message}");
Restart();
}
}
internal static void OnPersonaState(Bot bot, SteamFriends.PersonaStateCallback callback)
{
if (bot == null)
{
ASF.ArchiLogger.LogNullError(nameof(bot));
return;
}
if (callback == null)
{
bot.ArchiLogger.LogNullError(nameof(callback));
return;
}
BotStatusForm form;
if (!BotStatusForm.BotForms.TryGetValue(bot.BotName, out form))
{
return;
}
form.OnStateUpdated(callback);
}
internal async Task OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
if (callback == null)
{
ASF.ArchiLogger.LogNullError(nameof(callback));
return;
}
if (DateTime.UtcNow < LastAnnouncementCheck.AddHours(MinAnnouncementCheckTTL))
{
return;
}
// Don't announce if we don't meet conditions
if (!Bot.HasMobileAuthenticator || !Bot.BotConfig.TradingPreferences.HasFlag(BotConfig.ETradingPreferences.SteamTradeMatcher) || !await Bot.ArchiWebHandler.HasValidApiKey().ConfigureAwait(false) || !await Bot.ArchiWebHandler.HasPublicInventory().ConfigureAwait(false))
{
LastAnnouncementCheck = DateTime.UtcNow;
ShouldSendHeartBeats = false;
return;
}
string nickname = callback.Name ?? "";
string avatarHash = "";
if ((callback.AvatarHash != null) && (callback.AvatarHash.Length > 0) && callback.AvatarHash.Any(singleByte => singleByte != 0))
{
avatarHash = BitConverter.ToString(callback.AvatarHash).Replace("-", "").ToLowerInvariant();
if (avatarHash.All(singleChar => singleChar == '0'))
{
avatarHash = "";
}
}
bool matchEverything = Bot.BotConfig.TradingPreferences.HasFlag(BotConfig.ETradingPreferences.MatchEverything);
await Semaphore.WaitAsync().ConfigureAwait(false);
try {
if (DateTime.UtcNow < LastAnnouncementCheck.AddHours(MinAnnouncementCheckTTL))
{
return;
}
await Trading.LimitInventoryRequestsAsync().ConfigureAwait(false);
HashSet <Steam.Item> inventory = await Bot.ArchiWebHandler.GetMySteamInventory(true, new HashSet <Steam.Item.EType> {
Steam.Item.EType.TradingCard
}).ConfigureAwait(false);
// This is actually inventory failure, so we'll stop sending heartbeats but not record it as valid check
if (inventory == null)
{
ShouldSendHeartBeats = false;
return;
}
// This is actual inventory
if (inventory.Count < MinCardsCount)
{
LastAnnouncementCheck = DateTime.UtcNow;
ShouldSendHeartBeats = false;
return;
}
string request = await GetURL().ConfigureAwait(false) + "/api/Announce";
Dictionary <string, string> data = new Dictionary <string, string>(6)
{
{ "SteamID", Bot.SteamID.ToString() },
{ "Guid", Program.GlobalDatabase.Guid.ToString("N") },
{ "Nickname", nickname },
{ "AvatarHash", avatarHash },
{ "MatchEverything", matchEverything ? "1" : "0" },
{ "CardsCount", inventory.Count.ToString() }
};
// We don't need retry logic here
if (await Program.WebBrowser.UrlPost(request, data).ConfigureAwait(false))
{
LastAnnouncementCheck = DateTime.UtcNow;
ShouldSendHeartBeats = true;
}
} finally {
Semaphore.Release();
}
}
public void OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
Console.WriteLine($"Friend state change: {callback.Name}, {callback.State}");
}
