public void HandleCallback(CallbackMsg msg)
{
if (!msg.IsType <SteamFriends.FriendMsgCallback>())
{
return;
}
msg.Handle <SteamFriends.FriendMsgCallback>(friendMsg =>
{
EChatEntryType type = friendMsg.EntryType;
if (type == EChatEntryType.ChatMsg || type == EChatEntryType.Emote || type == EChatEntryType.InviteGame)
{
ChatDialog cd = GetChat(friendMsg.Sender);
cd.HandleChat(friendMsg);
}
});
msg.Handle <SteamFriends.PersonaStateCallback>(personaState =>
{
if (personaState.FriendID == Steam3.SteamClient.SteamID)
{
return;
}
ChatDialog cd = GetChat(personaState.FriendID);
cd.HandleState(personaState);
});
}
void HandleSteamMessage(CallbackMsg msg)
{
log.Debug(msg.ToString());
#region Login
msg.Handle <SteamClient.ConnectedCallback> (callback =>
{
log.Debug("Connection Callback: " + callback.Result);
if (callback.Result == EResult.OK)
{
UserLogOn();
}
else
{
log.Error("Failed to connect to Steam Community, trying again...");
SteamClient.Connect();
}
});
msg.Handle <SteamUser.LoggedOnCallback> (callback =>
{
log.Debug("Logged On Callback: " + callback.Result);
if (callback.Result != EResult.OK)
{
log.Error("Login Error: " + callback.Result);
}
if (callback.Result == EResult.AccountLogonDenied)
{
log.Interface("This account is SteamGuard enabled. Enter the code via the `auth' command.");
// try to get the steamguard auth code from the event callback
var eva = new SteamGuardRequiredEventArgs();
FireOnSteamGuardRequired(eva);
if (!String.IsNullOrEmpty(eva.SteamGuard))
{
logOnDetails.AuthCode = eva.SteamGuard;
}
else
{
logOnDetails.AuthCode = Console.ReadLine();
}
}
if (callback.Result == EResult.InvalidLoginAuthCode)
{
log.Interface("The given SteamGuard code was invalid. Try again using the `auth' command.");
logOnDetails.AuthCode = Console.ReadLine();
}
});
msg.Handle <SteamUser.LoginKeyCallback> (callback =>
{
while (true)
{
bool authd = SteamWeb.Authenticate(callback, SteamClient, out sessionId, out token);
if (authd)
{
log.Success("User Authenticated!");
tradeManager = new TradeManager(apiKey, sessionId, token);
tradeManager.SetTradeTimeLimits(MaximumTradeTime, MaximiumActionGap, TradePollingInterval);
tradeManager.OnTimeout += OnTradeTimeout;
tradeManager.OnTradeEnded += OnTradeEnded;
break;
}
else
{
log.Warn("Authentication failed, retrying in 2s...");
Thread.Sleep(2000);
}
}
if (Trade.CurrentSchema == null)
{
log.Info("Downloading Schema...");
Trade.CurrentSchema = Schema.FetchSchema(apiKey);
log.Success("Schema Downloaded!");
}
SteamFriends.SetPersonaName(DisplayNamePrefix + DisplayName);
SteamFriends.SetPersonaState(EPersonaState.Online);
log.Success("Steam Bot Logged In Completely!");
IsLoggedIn = true;
GetUserHandler(SteamClient.SteamID).OnLoginCompleted();
});
// handle a special JobCallback differently than the others
if (msg.IsType <SteamClient.JobCallback <SteamUser.UpdateMachineAuthCallback> >())
{
msg.Handle <SteamClient.JobCallback <SteamUser.UpdateMachineAuthCallback> >(
jobCallback => OnUpdateMachineAuthCallback(jobCallback.Callback, jobCallback.JobID)
);
}
#endregion
#region Friends
msg.Handle <SteamFriends.FriendsListCallback> (callback =>
{
foreach (SteamFriends.FriendsListCallback.Friend friend in callback.FriendList)
{
if (!friends.Contains(friend.SteamID))
{
friends.Add(friend.SteamID);
if (friend.Relationship == EFriendRelationship.PendingInvitee &&
GetUserHandler(friend.SteamID).OnFriendAdd())
{
SteamFriends.AddFriend(friend.SteamID);
}
}
else
{
if (friend.Relationship == EFriendRelationship.None)
{
friends.Remove(friend.SteamID);
GetUserHandler(friend.SteamID).OnFriendRemove();
}
}
}
});
msg.Handle <SteamFriends.FriendMsgCallback> (callback =>
{
EChatEntryType type = callback.EntryType;
if (callback.EntryType == EChatEntryType.ChatMsg ||
callback.EntryType == EChatEntryType.Emote)
{
log.Info(String.Format("Chat Message from {0}: {1}",
SteamFriends.GetFriendPersonaName(callback.Sender),
callback.Message
));
GetUserHandler(callback.Sender).OnMessage(callback.Message, type);
}
});
#endregion
#region Group Chat
msg.Handle <SteamFriends.ChatMsgCallback>(callback =>
{
GetUserHandler(callback.ChatterID).OnChatRoomMessage(callback.ChatRoomID, callback.ChatterID, callback.Message);
});
#endregion
#region Trading
msg.Handle <SteamTrading.SessionStartCallback> (callback =>
{
bool started = HandleTradeSessionStart(callback.OtherClient);
if (!started)
{
log.Error("Could not start the trade session.");
}
else
{
log.Debug("SteamTrading.SessionStartCallback handled successfully. Trade Opened.");
}
});
msg.Handle <SteamTrading.TradeProposedCallback> (callback =>
{
try
{
tradeManager.InitializeTrade(SteamUser.SteamID, callback.OtherClient);
}
catch
{
SteamFriends.SendChatMessage(callback.OtherClient,
EChatEntryType.ChatMsg,
"Trade declined. Could not correctly fetch your backpack.");
SteamTrade.RespondToTrade(callback.TradeID, false);
return;
}
if (tradeManager.OtherInventory.IsPrivate)
{
SteamFriends.SendChatMessage(callback.OtherClient,
EChatEntryType.ChatMsg,
"Trade declined. Your backpack cannot be private.");
SteamTrade.RespondToTrade(callback.TradeID, false);
return;
}
if (CurrentTrade == null && GetUserHandler(callback.OtherClient).OnTradeRequest())
{
SteamTrade.RespondToTrade(callback.TradeID, true);
}
else
{
SteamTrade.RespondToTrade(callback.TradeID, false);
}
});
msg.Handle <SteamTrading.TradeResultCallback> (callback =>
{
if (callback.Response == EEconTradeResponse.Accepted)
{
log.Debug("Trade Status: " + callback.Response);
log.Info("Trade Accepted!");
}
else
{
log.Warn("Trade failed: " + callback.Response);
CloseTrade();
}
});
#endregion
#region Disconnect
msg.Handle <SteamUser.LoggedOffCallback> (callback =>
{
IsLoggedIn = false;
log.Warn("Logged Off: " + callback.Result);
});
msg.Handle <SteamClient.DisconnectedCallback> (callback =>
{
IsLoggedIn = false;
CloseTrade();
log.Warn("Disconnected from Steam Network!");
SteamClient.Connect();
});
#endregion
}
void HandleSteamMessage(CallbackMsg msg)
{
log.Debug(msg.ToString());
#region Login
msg.Handle <SteamClient.ConnectedCallback>(callback =>
{
log.Debug("Connection Callback: " + callback.Result);
if (callback.Result == EResult.OK)
{
UserLogOn();
}
else
{
log.Error("Failed to connect to Steam Community, trying again...");
SteamClient.Connect();
}
});
msg.Handle <SteamUser.LoggedOnCallback>(callback =>
{
log.Debug("Logged On Callback: " + callback.Result);
if (callback.Result == EResult.OK)
{
MyUserNonce = callback.WebAPIUserNonce;
}
else
{
log.Error("Login Error: " + callback.Result);
}
if (callback.Result == EResult.AccountLogonDenied)
{
log.Interface("This account is SteamGuard enabled. Enter the code via the `auth' command.");
// try to get the steamguard auth code from the event callback
var eva = new SteamGuardRequiredEventArgs();
FireOnSteamGuardRequired(eva);
if (!String.IsNullOrEmpty(eva.SteamGuard))
{
logOnDetails.AuthCode = eva.SteamGuard;
}
else
{
logOnDetails.AuthCode = Console.ReadLine();
}
}
if (callback.Result == EResult.InvalidLoginAuthCode)
{
log.Interface("The given SteamGuard code was invalid. Try again using the `auth' command.");
logOnDetails.AuthCode = Console.ReadLine();
}
});
msg.Handle <SteamUser.LoginKeyCallback>(callback =>
{
MyUniqueId = callback.UniqueID.ToString();
UserWebLogOn();
if (Trade.CurrentSchema == null)
{
log.Info("Downloading Schema...");
Trade.CurrentSchema = Schema.FetchSchema(apiKey);
log.Success("Schema Downloaded!");
}
SteamFriends.SetPersonaName(DisplayNamePrefix + DisplayName);
SteamFriends.SetPersonaState(EPersonaState.Online);
log.Success("Steam Bot Logged In Completely!");
IsLoggedIn = true;
GetUserHandler(SteamClient.SteamID).OnLoginCompleted();
});
msg.Handle <SteamClient.JobCallback <SteamUser.WebAPIUserNonceCallback> >(jobCallback =>
{
log.Debug("Received new WebAPIUserNonce.");
if (jobCallback.Callback.Result == EResult.OK)
{
MyUserNonce = jobCallback.Callback.Nonce;
UserWebLogOn();
}
else
{
log.Error("WebAPIUserNonce Error: " + jobCallback.Callback.Result);
}
});
// handle a special JobCallback differently than the others
if (msg.IsType <SteamClient.JobCallback <SteamUser.UpdateMachineAuthCallback> >())
{
msg.Handle <SteamClient.JobCallback <SteamUser.UpdateMachineAuthCallback> >(
jobCallback => OnUpdateMachineAuthCallback(jobCallback.Callback, jobCallback.JobID)
);
}
#endregion
#region Friends
msg.Handle <SteamFriends.FriendsListCallback>(callback =>
{
foreach (SteamFriends.FriendsListCallback.Friend friend in callback.FriendList)
{
switch (friend.SteamID.AccountType)
{
case EAccountType.Clan:
if (friend.Relationship == EFriendRelationship.RequestRecipient)
{
if (GetUserHandler(friend.SteamID).OnGroupAdd())
{
AcceptGroupInvite(friend.SteamID);
}
else
{
DeclineGroupInvite(friend.SteamID);
}
}
break;
default:
CreateFriendsListIfNecessary();
if (friend.Relationship == EFriendRelationship.None)
{
friends.Remove(friend.SteamID);
GetUserHandler(friend.SteamID).OnFriendRemove();
RemoveUserHandler(friend.SteamID);
}
else if (friend.Relationship == EFriendRelationship.RequestRecipient)
{
if (GetUserHandler(friend.SteamID).OnFriendAdd())
{
if (!friends.Contains(friend.SteamID))
{
friends.Add(friend.SteamID);
}
else
{
log.Error("Friend was added who was already in friends list: " + friend.SteamID);
}
SteamFriends.AddFriend(friend.SteamID);
}
else
{
SteamFriends.RemoveFriend(friend.SteamID);
RemoveUserHandler(friend.SteamID);
}
}
break;
}
}
});
msg.Handle <SteamFriends.FriendMsgCallback>(callback =>
{
EChatEntryType type = callback.EntryType;
if (callback.EntryType == EChatEntryType.ChatMsg)
{
log.Info(String.Format("Chat Message from {0}: {1}",
SteamFriends.GetFriendPersonaName(callback.Sender),
callback.Message
));
GetUserHandler(callback.Sender).OnMessage(callback.Message, type);
}
});
#endregion
#region Group Chat
//Begin KFBros stuff
msg.Handle <SteamFriends.ChatMsgCallback>(callback =>
{
GetUserHandler(callback.ChatterID).OnChatRoomMessage(callback.ChatRoomID, callback.ChatterID, callback.Message);
if (callback.Message == "hi")
{
SteamFriends.SendChatRoomMessage(callback.ChatRoomID, EChatEntryType.ChatMsg, "hi");
}
if (callback.Message.Contains("v="))
{
string coolresult;
string[] result = callback.Message.Split(' ');
for (int i = 0; i < result.Length; ++i)
{
if (result[i].Contains("v="))
{
coolresult = result[i];
log.Warn(coolresult.Substring(coolresult.IndexOf("v=") + 2));
string url = "https://www.googleapis.com/youtube/v3/videos?part=snippet&id=" + coolresult.Substring(coolresult.IndexOf("v=") + 2) + "&key=" + youtubeService.ApiKey;
WebRequest request = HttpWebRequest.Create(url);
WebResponse response = request.GetResponse();
StreamReader reader = new StreamReader(response.GetResponseStream());
string urlText = reader.ReadToEnd();
string final = "Youtube: " + urlText.Substring(urlText.IndexOf("\"title\": ") + 9, (urlText.IndexOf("\"description\":") - 6) - (urlText.IndexOf("\"title\": ") + 9));
log.Success(final);
if (final.Length > 9)
{
SteamFriends.SendChatRoomMessage(callback.ChatRoomID, EChatEntryType.ChatMsg, final);
}
}
}
}
});
//handle bot being kicked and other type of chat member state messages
msg.Handle <SteamFriends.ChatMemberInfoCallback>(callback =>
{
if (callback.StateChangeInfo.ChatterActedOn == 76561198119861272)
{
if (callback.StateChangeInfo.StateChange == EChatMemberStateChange.Kicked)
{
SteamFriends.JoinChat(callback.ChatRoomID);
}
}
});
#endregion
#region Trading
msg.Handle <SteamTrading.SessionStartCallback>(callback =>
{
bool started = HandleTradeSessionStart(callback.OtherClient);
if (!started)
{
log.Error("Could not start the trade session.");
}
else
{
log.Debug("SteamTrading.SessionStartCallback handled successfully. Trade Opened.");
}
});
msg.Handle <SteamTrading.TradeProposedCallback>(callback =>
{
if (CheckCookies() == false)
{
SteamTrade.RespondToTrade(callback.TradeID, false);
return;
}
try
{
tradeManager.InitializeTrade(SteamUser.SteamID, callback.OtherClient);
}
catch (WebException we)
{
SteamFriends.SendChatMessage(callback.OtherClient,
EChatEntryType.ChatMsg,
"Trade error: " + we.Message);
SteamTrade.RespondToTrade(callback.TradeID, false);
return;
}
catch (Exception)
{
SteamFriends.SendChatMessage(callback.OtherClient,
EChatEntryType.ChatMsg,
"Trade declined. Could not correctly fetch your backpack.");
SteamTrade.RespondToTrade(callback.TradeID, false);
return;
}
//if (tradeManager.OtherInventory.IsPrivate)
//{
// SteamFriends.SendChatMessage(callback.OtherClient,
// EChatEntryType.ChatMsg,
// "Trade declined. Your backpack cannot be private.");
// SteamTrade.RespondToTrade (callback.TradeID, false);
// return;
//}
if (CurrentTrade == null && GetUserHandler(callback.OtherClient).OnTradeRequest())
{
SteamTrade.RespondToTrade(callback.TradeID, true);
}
else
{
SteamTrade.RespondToTrade(callback.TradeID, false);
}
});
msg.Handle <SteamTrading.TradeResultCallback>(callback =>
{
if (callback.Response == EEconTradeResponse.Accepted)
{
log.Debug("Trade Status: " + callback.Response);
log.Info("Trade Accepted!");
GetUserHandler(callback.OtherClient).OnTradeRequestReply(true, callback.Response.ToString());
}
else
{
log.Warn("Trade failed: " + callback.Response);
CloseTrade();
GetUserHandler(callback.OtherClient).OnTradeRequestReply(false, callback.Response.ToString());
}
});
#endregion
#region Disconnect
msg.Handle <SteamUser.LoggedOffCallback>(callback =>
{
IsLoggedIn = false;
log.Warn("Logged Off: " + callback.Result);
});
msg.Handle <SteamClient.DisconnectedCallback>(callback =>
{
IsLoggedIn = false;
CloseTrade();
log.Warn("Disconnected from Steam Network!");
SteamClient.Connect();
});
#endregion
#region Notifications
msg.Handle <SteamBot.SteamNotifications.NotificationCallback>(callback =>
{
//currently only appears to be of trade offer
if (callback.Notifications.Count != 0)
{
foreach (var notification in callback.Notifications)
{
log.Info(notification.UserNotificationType + " notification");
}
}
// Get offers only if cookies are valid
if (CheckCookies())
{
tradeOfferManager.GetOffers();
}
});
msg.Handle <SteamBot.SteamNotifications.CommentNotificationCallback>(callback =>
{
//various types of comment notifications on profile/activity feed etc
//log.Info("received CommentNotificationCallback");
//log.Info("New Commments " + callback.CommentNotifications.CountNewComments);
//log.Info("New Commments Owners " + callback.CommentNotifications.CountNewCommentsOwner);
//log.Info("New Commments Subscriptions" + callback.CommentNotifications.CountNewCommentsSubscriptions);
});
#endregion
}
public void HandleCallback(CallbackMsg msg)
{
if (msg.IsType <SteamFriends.PersonaStateCallback>())
{
var perState = (SteamFriends.PersonaStateCallback)msg;
if (perState.FriendID == selfControl.Friend.SteamID)
{
selfControl.UpdateFriend(selfControl.Friend);
suppressStateMsg = true;
stateComboBox.SelectedIndex = GetIndexFromState(perState.State);
suppressStateMsg = false;
return;
}
nextSort = DateTime.Now + TimeSpan.FromSeconds(0.1);
sortTimer.Start();
}
if (msg.IsType <SteamUser.LoggedOffCallback>())
{
var callback = (SteamUser.LoggedOffCallback)msg;
Util.MsgBox(this, string.Format("Logged off from Steam3: {0}", callback.Result));
this.Relog = true;
this.Close();
return;
}
if (msg.IsType <SteamFriends.FriendsListCallback>())
{
selfControl.UpdateFriend(new Friend(Steam3.SteamUser.SteamID));
this.UpdateFriends();
}
if (msg.IsType <SteamUser.LoginKeyCallback>())
{
Steam3.SteamFriends.SetPersonaState(EPersonaState.Online);
this.Enabled = true;
}
if (msg.IsType <SteamUser.LoggedOnCallback>())
{
var logOnResp = (SteamUser.LoggedOnCallback)msg;
if (logOnResp.Result == EResult.AccountLogonDenied)
{
expectDisconnect = true;
SteamGuardDialog sgDialog = new SteamGuardDialog();
if (sgDialog.ShowDialog(this) != DialogResult.OK)
{
this.Relog = true;
this.Close();
return;
}
Steam3.AuthCode = sgDialog.AuthCode;
// if we got this logon response, we got disconnected, so lets reconnect
try
{
Steam3.Connect();
}
catch (Steam3Exception ex)
{
Util.MsgBox(this, string.Format("Unable to connect to Steam3: {0}", ex.Message));
this.Relog = true;
this.Close();
return;
}
}
else if (logOnResp.Result != EResult.OK)
{
Util.MsgBox(this, string.Format("Unable to login to Steam3. Result code: {0}", logOnResp.Result));
this.Relog = true;
this.Close();
return;
}
}
if (msg.IsType <SteamFriends.FriendAddedCallback>())
{
var friendAdded = (SteamFriends.FriendAddedCallback)msg;
if (friendAdded.Result != EResult.OK)
{
Util.MsgBox(this, "Unable to add friend! Result: " + friendAdded.Result);
}
}
msg.Handle <SteamClient.DisconnectedCallback>((callback) =>
{
// if we expected this disconnection (cause of steamguard), we do nothing
if (expectDisconnect)
{
expectDisconnect = false;
return;
}
Util.MsgBox(this, "Disconnected from Steam3!");
this.Relog = true;
this.Close();
return;
});
}
void HandleSteamMessage(CallbackMsg msg)
{
log.Debug(msg.ToString());
#region Login
msg.Handle <SteamClient.ConnectedCallback> (callback =>
{
log.Debug("Connection Callback: " + callback.Result);
if (callback.Result == EResult.OK)
{
UserLogOn();
}
else
{
log.Error("Failed to connect to Steam Community, trying again...");
main.Invoke((Action)(() =>
{
main.label_status.Text = "Failed to connect to Steam Community, trying again...";
}));
SteamClient.Connect();
}
});
msg.Handle <SteamUser.LoggedOnCallback> (callback =>
{
log.Debug("Logged On Callback: " + callback.Result);
if (callback.Result == EResult.OK)
{
main.Invoke((Action)(() =>
{
main.label_status.Text = "Logging in to Steam...";
log.Info("Logging in to Steam...");
}));
}
if (callback.Result != EResult.OK)
{
log.Error("Login Error: " + callback.Result);
main.Invoke((Action)(() =>
{
main.label_status.Text = "Login Error: " + callback.Result;
}));
}
if (callback.Result == EResult.InvalidPassword)
{
MessageBox.Show("Your password is incorrect. Please try again.",
"Invalid Password",
MessageBoxButtons.OK,
MessageBoxIcon.Error,
MessageBoxDefaultButton.Button1);
main.wrongAPI = true;
main.Invoke((Action)(main.Close));
return;
}
if (callback.Result == EResult.AccountLogonDenied)
{
log.Interface("This account is protected by Steam Guard. Enter the authentication code sent to the proper email: ");
SteamGuard SteamGuard = new SteamGuard();
SteamGuard.ShowDialog();
logOnDetails.AuthCode = SteamGuard.AuthCode;
main.Invoke((Action)(() =>
{
main.label_status.Text = "Logging in...";
}));
}
if (callback.Result == EResult.InvalidLoginAuthCode)
{
log.Interface("An Invalid Authorization Code was provided. Enter the authentication code sent to the proper email: ");
SteamGuard SteamGuard = new SteamGuard("An Invalid Authorization Code was provided.\nEnter the authentication code sent to the proper email: ");
SteamGuard.ShowDialog();
logOnDetails.AuthCode = SteamGuard.AuthCode;
main.Invoke((Action)(() =>
{
main.label_status.Text = "Logging in...";
}));
}
});
msg.Handle <SteamUser.LoginKeyCallback> (callback =>
{
log.Debug("Handling LoginKeyCallback...");
while (true)
{
try
{
log.Info("About to authenticate...");
bool authd = false;
try
{
authd = SteamWeb.Authenticate(callback, SteamClient, out sessionId, out token);
}
catch (Exception ex)
{
log.Error("Error on authentication:\n" + ex);
}
if (authd)
{
log.Success("User Authenticated!");
main.Invoke((Action)(() =>
{
main.label_status.Text = "User authenticated!";
}));
tradeManager = new TradeManager(apiKey, sessionId, token);
tradeManager.SetTradeTimeLimits(MaximumTradeTime, MaximiumActionGap, TradePollingInterval);
tradeManager.OnTimeout += OnTradeTimeout;
tradeManager.OnTradeEnded += OnTradeEnded;
break;
}
else
{
log.Warn("Authentication failed, retrying in 2s...");
main.Invoke((Action)(() =>
{
main.label_status.Text = "Authentication failed, retrying in 2s...";
}));
Thread.Sleep(2000);
}
}
catch (Exception ex)
{
log.Error(ex.ToString());
}
}
if (Trade.CurrentSchema == null)
{
log.Info("Downloading Schema...");
main.Invoke((Action)(() =>
{
main.label_status.Text = "Downloading schema...";
}));
try
{
Trade.CurrentSchema = Schema.FetchSchema(apiKey);
}
catch (Exception ex)
{
log.Error(ex.ToString());
MessageBox.Show("I can't fetch the schema! Your API key may be invalid or there may be a problem connecting to Steam. Please make sure you have obtained a proper API key at http://steamcommunity.com/dev/apikey",
"Schema Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error,
MessageBoxDefaultButton.Button1);
main.wrongAPI = true;
main.Invoke((Action)(main.Dispose));
return;
}
log.Success("Schema Downloaded!");
main.Invoke((Action)(() =>
{
main.label_status.Text = "Schema downloaded!";
}));
}
SteamFriends.SetPersonaName(SteamFriends.GetFriendPersonaName(SteamUser.SteamID));
SteamFriends.SetPersonaState(EPersonaState.Online);
log.Success("Account Logged In Completely!");
main.Invoke((Action)(() =>
{
main.label_status.Text = "Logged in completely!";
}));
IsLoggedIn = true;
displayName = SteamFriends.GetPersonaName();
ConnectToGC(13540830642081628378);
Thread.Sleep(500);
DisconnectFromGC();
try
{
main.Invoke((Action)(main.Hide));
}
catch (Exception)
{
Environment.Exit(1);
}
Thread.Sleep(2500);
CDNCache.Initialize();
});
// handle a special JobCallback differently than the others
if (msg.IsType <SteamClient.JobCallback <SteamUser.UpdateMachineAuthCallback> >())
{
msg.Handle <SteamClient.JobCallback <SteamUser.UpdateMachineAuthCallback> >(
jobCallback => OnUpdateMachineAuthCallback(jobCallback.Callback, jobCallback.JobID)
);
}
#endregion
#region Friends
msg.Handle <SteamFriends.FriendsListCallback>(callback =>
{
bool newFriend = false;
foreach (SteamFriends.FriendsListCallback.Friend friend in callback.FriendList)
{
if (!friends.Contains(friend.SteamID) && !friend.SteamID.ToString().StartsWith("1"))
{
new Thread(() =>
{
main.Invoke((Action)(() =>
{
if (showFriends == null && friend.Relationship == EFriendRelationship.RequestRecipient)
{
log.Info(SteamFriends.GetFriendPersonaName(friend.SteamID) + " has added you.");
friends.Add(friend.SteamID);
newFriend = true;
string name = SteamFriends.GetFriendPersonaName(friend.SteamID);
string status = SteamFriends.GetFriendPersonaState(friend.SteamID).ToString();
if (!ListFriendRequests.Find(friend.SteamID))
{
ListFriendRequests.Add(name, friend.SteamID, status);
}
}
if (showFriends != null && friend.Relationship == EFriendRelationship.RequestRecipient)
{
log.Info(SteamFriends.GetFriendPersonaName(friend.SteamID) + " has added you.");
friends.Add(friend.SteamID);
/*if (friend.Relationship == EFriendRelationship.RequestRecipient &&
* GetUserHandler(friend.SteamID).OnFriendAdd())
* {
* SteamFriends.AddFriend(friend.SteamID);
* }*/
newFriend = true;
string name = SteamFriends.GetFriendPersonaName(friend.SteamID);
string status = SteamFriends.GetFriendPersonaState(friend.SteamID).ToString();
if (!ListFriendRequests.Find(friend.SteamID))
{
try
{
showFriends.NotifyFriendRequest();
ListFriendRequests.Add(name, friend.SteamID, status);
log.Info("Notifying you that " + SteamFriends.GetFriendPersonaName(friend.SteamID) + " has added you.");
int duration = 5;
FormAnimator.AnimationMethod animationMethod = FormAnimator.AnimationMethod.Slide;
FormAnimator.AnimationDirection animationDirection = FormAnimator.AnimationDirection.Up;
Notification toastNotification = new Notification(name, "has sent you a friend request.", duration, animationMethod, animationDirection);
toastNotification.Show();
try
{
string soundsFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory);
string soundFile = Path.Combine(soundsFolder + "trade_message.wav");
using (System.Media.SoundPlayer player = new System.Media.SoundPlayer(soundFile))
{
player.Play();
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
showFriends.list_friendreq.SetObjects(ListFriendRequests.Get());
}
catch
{
Console.WriteLine("Friends list hasn't loaded yet...");
}
}
}
}));
}).Start();
}
else
{
if (friend.Relationship == EFriendRelationship.None)
{
friends.Remove(friend.SteamID);
GetUserHandler(friend.SteamID).OnFriendRemove();
}
}
}
if (!newFriend && ListFriendRequests.Get().Count == 0)
{
if (showFriends != null)
{
showFriends.HideFriendRequests();
}
}
});
msg.Handle <SteamFriends.PersonaStateCallback>(callback =>
{
var status = callback.State;
var sid = callback.FriendID;
GetUserHandler(sid).SetStatus(status);
ListFriends.UpdateStatus(sid, status.ToString());
});
msg.Handle <SteamFriends.FriendMsgCallback>(callback =>
{
EChatEntryType type = callback.EntryType;
if (callback.EntryType == EChatEntryType.Typing)
{
var name = SteamFriends.GetFriendPersonaName(callback.Sender);
GetUserHandler(callback.Sender).SetChatStatus(name + " is typing...");
}
else
{
GetUserHandler(callback.Sender).SetChatStatus("");
}
if (callback.EntryType == EChatEntryType.ChatMsg ||
callback.EntryType == EChatEntryType.Emote)
{
//log.Info (String.Format ("Chat Message from {0}: {1}",
// SteamFriends.GetFriendPersonaName (callback.Sender),
// callback.Message
//));
GetUserHandler(callback.Sender).OnMessage(callback.Message, type);
}
});
msg.Handle <SteamFriends.ChatMsgCallback>(callback =>
{
Console.WriteLine(SteamFriends.GetFriendPersonaName(callback.ChatterID) + ": " + callback.Message);
});
#endregion
#region Trading
msg.Handle <SteamTrading.SessionStartCallback>(callback =>
{
bool started = HandleTradeSessionStart(callback.OtherClient);
//if (!started)
//log.Info ("Could not start the trade session.");
//else
//log.Debug ("SteamTrading.SessionStartCallback handled successfully. Trade Opened.");
});
msg.Handle <SteamTrading.TradeProposedCallback>(callback =>
{
try
{
tradeManager.InitializeTrade(SteamUser.SteamID, callback.OtherClient);
}
catch
{
SteamFriends.SendChatMessage(callback.OtherClient,
EChatEntryType.ChatMsg,
"Trade declined. Could not correctly fetch your backpack.");
SteamTrade.RespondToTrade(callback.TradeID, false);
return;
}
if (tradeManager.OtherInventory.IsPrivate)
{
SteamFriends.SendChatMessage(callback.OtherClient,
EChatEntryType.ChatMsg,
"Trade declined. Your backpack cannot be private.");
SteamTrade.RespondToTrade(callback.TradeID, false);
return;
}
//if (CurrentTrade == null && GetUserHandler (callback.OtherClient).OnTradeRequest ())
if (CurrentTrade == null)
{
GetUserHandler(callback.OtherClient).SendTradeState(callback.TradeID);
}
else
{
SteamTrade.RespondToTrade(callback.TradeID, false);
}
});
msg.Handle <SteamTrading.TradeResultCallback>(callback =>
{
//log.Debug ("Trade Status: " + callback.Response);
if (callback.Response == EEconTradeResponse.Accepted)
{
//log.Info ("Trade Accepted!");
}
if (callback.Response == EEconTradeResponse.Cancel ||
callback.Response == EEconTradeResponse.ConnectionFailed ||
callback.Response == EEconTradeResponse.Declined ||
callback.Response == EEconTradeResponse.Error ||
callback.Response == EEconTradeResponse.InitiatorAlreadyTrading ||
callback.Response == EEconTradeResponse.TargetAlreadyTrading ||
callback.Response == EEconTradeResponse.Timeout ||
callback.Response == EEconTradeResponse.TooSoon ||
callback.Response == EEconTradeResponse.TradeBannedInitiator ||
callback.Response == EEconTradeResponse.TradeBannedTarget ||
callback.Response == EEconTradeResponse.NotLoggedIn) // uh...
{
if (callback.Response == EEconTradeResponse.Cancel)
{
TradeResponse(callback.OtherClient, "had asked to trade with you, but has cancelled their request.");
}
if (callback.Response == EEconTradeResponse.ConnectionFailed)
{
TradeResponse(callback.OtherClient, "Lost connection to Steam. Reconnecting as soon as possible...");
}
if (callback.Response == EEconTradeResponse.Declined)
{
TradeResponse(callback.OtherClient, "has declined your trade request.");
}
if (callback.Response == EEconTradeResponse.Error)
{
TradeResponse(callback.OtherClient, "An error has occurred in sending the trade request.");
}
if (callback.Response == EEconTradeResponse.InitiatorAlreadyTrading)
{
TradeResponse(callback.OtherClient, "You are already in a trade so you cannot trade someone else.");
}
if (callback.Response == EEconTradeResponse.TargetAlreadyTrading)
{
TradeResponse(callback.OtherClient, "You cannot trade the other user because they are already in trade with someone else.");
}
if (callback.Response == EEconTradeResponse.Timeout)
{
TradeResponse(callback.OtherClient, "did not respond to the trade request.");
}
if (callback.Response == EEconTradeResponse.TooSoon)
{
TradeResponse(callback.OtherClient, "It is too soon to send a new trade request. Try again later.");
}
if (callback.Response == EEconTradeResponse.TradeBannedInitiator)
{
TradeResponse(callback.OtherClient, "You are trade-banned and cannot trade.");
}
if (callback.Response == EEconTradeResponse.TradeBannedTarget)
{
TradeResponse(callback.OtherClient, "You cannot trade with this person because they are trade-banned.");
}
if (callback.Response == EEconTradeResponse.NotLoggedIn)
{
TradeResponse(callback.OtherClient, "Trade failed to initialize because you are not logged in.");
}
CloseTrade();
}
});
#endregion
#region Disconnect
msg.Handle <SteamUser.LoggedOffCallback> (callback =>
{
IsLoggedIn = false;
log.Warn("Logged Off: " + callback.Result);
});
msg.Handle <SteamClient.DisconnectedCallback> (callback =>
{
IsLoggedIn = false;
CloseTrade();
log.Warn("Disconnected from Steam Network!");
main.Invoke((Action)(() =>
{
main.label_status.Text = "Disconnected from Steam Network! Retrying...";
}));
SteamClient.Connect();
main.Invoke((Action)(() =>
{
main.label_status.Text = "Connecting to Steam...";
}));
});
#endregion
if (!hasrun && IsLoggedIn)
{
Thread main = new Thread(GUI);
main.Start();
hasrun = true;
}
}
static void Main(string[] args)
{
Console.ForegroundColor = ConsoleColor.DarkCyan;
System.Console.Title = "TradeBot";
System.Console.WriteLine("Welcome to TradeBot!\nCreated by Jessecar.\nTurn of Steam Guard before loggin in!\n\n");
Console.ForegroundColor = ConsoleColor.White;
printConsole("Steam Username:"******"jessecar96"; //Console.ReadLine();
System.Console.WriteLine("Steam Password: "******"Sorry, could not connect to Steam.");
}
steamUser.LogOn(new SteamUser.LogOnDetails
{
Username = username,
Password = password,
});
});
//Login Callback
msg.Handle <SteamUser.LoggedOnCallback>(callback =>
{
if (callback.Result != EResult.OK)
{
printConsole("Incorrect username or Password. Make sure you have disabled steam guard!");
}
else
{
printConsole("Connected to Steam!\nWelcome " + steamUser.SteamID);
steamFriends.SetPersonaName("ChatBot Beta (Say hi)");
steamFriends.SetPersonaState((EPersonaState)6);
}
});
//Chat Messages
msg.Handle <SteamFriends.FriendMsgCallback>(callback =>
{
EChatEntryType type = callback.EntryType;
if (type == EChatEntryType.ChatMsg)
{
SteamID sid = callback.Sender;
if (!clients.Contains(callback.Sender))
{
printConsole("[New Client]" + callback.Sender, ConsoleColor.Magenta);
clients.Add(callback.Sender);
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "Welcome to TradeBot created by Jessecar. To see a list of commands type /help");
}
if (callback.Message.StartsWith("/"))
{
string message = callback.Message.Replace("/", "");
printConsole("[Command]" + callback.Sender + " (" + steamFriends.GetFriendPersonaName(callback.Sender) + "): " + message, ConsoleColor.Magenta);
//string[] args = .Split(" ");
string[] words = message.Split(new char[] { ' ' }, 2);
switch (words[0])
{
case "trade":
//Send a trade
trade.RequestTrade(callback.Sender);
printConsole("Trade requested by " + callback.Sender + " (" + steamFriends.GetFriendPersonaName(callback.Sender) + ")", ConsoleColor.Green);
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.Emote, "initiated a trade request.");
break;
case "remove":
//Remove Friend
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "Thank you for using the Steam TradeBot BETA.");
steamFriends.RemoveFriend(callback.Sender);
printConsole("[Friend] Friend Removed: " + callback.Sender + " (" + steamFriends.GetFriendPersonaName(callback.Sender) + ")", ConsoleColor.Yellow);
break;
case "status":
//get status (nothing)
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.Emote, "is Online and working good.");
break;
case "hi":
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.Emote, "says hello.");
break;
case "help":
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "\nList Of Commands:\n/trade - Start a trade.\n/remove - Remove TradeBot from your friends.\n/hi - say hello");
break;
case "name":
if (checkAdmin(sid))
{
steamFriends.SetPersonaName(words[1]);
}
break;
case "send":
string[] wrds = message.Split(new char[] { ' ' }, 3);
int index = int.Parse(wrds[1]);
if (index < clients.Count() && index >= 0)
{
steamFriends.SendChatMessage(clients[index], EChatEntryType.ChatMsg, wrds[2]);
}
else
{
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.Emote, "Error: index out of bounds.");
}
break;
default:
printConsole("[Error]Unknown command from " + callback.Sender + ": " + callback.Message, ConsoleColor.Red);
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.Emote, "doesn't know that command.");
break;
}
}
else
{
printConsole("[Chat][" + getIndex(sid) + "]" + callback.Sender + ": " + " (" + steamFriends.GetFriendPersonaName(callback.Sender) + ")" + callback.Message, ConsoleColor.Magenta);
if ((callback.Message != "hi" || callback.Message != "hello") && clients.Contains(callback.Sender))
{
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "You Said: " + callback.Message);
}
}
}
else if (type == EChatEntryType.Emote)
{
printConsole("[Emote]" + callback.Sender + ": " + callback.Message, ConsoleColor.DarkMagenta);
}
});
msg.Handle <SteamTrading.TradeProposedCallback>(callback =>
{
SteamID sid = callback.Other;
//trade.RespondTradeRequest(callback.TradeRequestId, sid, true);
//trade.HandleMsg((IPacketMsg)EMsg.EconTrading_InitiateTradeProposed);
});
msg.Handle <SteamTrading.TradeRequestCallback>(callback =>
{
printConsole("[Trade] Trade Status with " + callback.Other + " (" + steamFriends.GetFriendPersonaName(callback.Other) + "): " + callback.Status.ToString(), ConsoleColor.Green);
if (callback.Status == ETradeStatus.Rejected)
{
printConsole("[Trade] Trade rejected by " + callback.Other + " (" + steamFriends.GetFriendPersonaName(callback.Other) + ")", ConsoleColor.DarkRed);
steamFriends.SendChatMessage(callback.Other, EChatEntryType.Emote, "detected that you rejected that trade.");
}
//trade.RespondTradeRequest(callback.TradeRequestId, callback.Other, true);
});
msg.Handle <SteamTrading.TradeStartSessionCallback>(callback =>
{
//callback.Other
});
msg.Handle <SteamFriends.PersonaStateCallback>(callback =>
{
if (callback.FriendID == steamUser.SteamID)
{
return;
}
EFriendRelationship relationship = steamFriends.GetFriendRelationship(callback.FriendID);
if (!(relationship == EFriendRelationship.RequestRecipient))
{
return;
}
printConsole("[Friend] Added Friend: " + callback.FriendID + "(" + steamFriends.GetFriendPersonaName(callback.FriendID) + ")", ConsoleColor.Yellow);
steamFriends.AddFriend(callback.FriendID);
});
}
}
void HandleSteamMessage(CallbackMsg msg)
{
log.Debug(msg.ToString());
#region Login
msg.Handle <SteamClient.ConnectedCallback>(callback =>
{
log.Debug("Connection Callback: " + callback.Result);
if (callback.Result == EResult.OK)
{
UserLogOn();
}
else
{
log.Error("Failed to connect to Steam Community, trying again...");
SteamClient.Connect();
}
});
msg.Handle <SteamUser.LoggedOnCallback>(callback =>
{
log.Debug("Logged On Callback: " + callback.Result);
if (callback.Result == EResult.OK)
{
MyUserNonce = callback.WebAPIUserNonce;
}
else
{
log.Error("Login Error: " + callback.Result);
}
if (callback.Result == EResult.AccountLogonDenied)
{
log.Interface("This account is SteamGuard enabled. Enter the code via the `auth' command.");
// try to get the steamguard auth code from the event callback
var eva = new SteamGuardRequiredEventArgs();
FireOnSteamGuardRequired(eva);
if (!String.IsNullOrEmpty(eva.SteamGuard))
{
logOnDetails.AuthCode = eva.SteamGuard;
}
else
{
logOnDetails.AuthCode = Console.ReadLine();
}
}
if (callback.Result == EResult.InvalidLoginAuthCode)
{
log.Interface("The given SteamGuard code was invalid. Try again using the `auth' command.");
logOnDetails.AuthCode = Console.ReadLine();
}
});
msg.Handle <SteamUser.LoginKeyCallback>(callback =>
{
MyUniqueId = callback.UniqueID.ToString();
UserWebLogOn();
if (Trade.CurrentSchema == null)
{
log.Info("Downloading Schema...");
Trade.CurrentSchema = Schema.FetchSchema(apiKey);
log.Success("Schema Downloaded!");
}
SteamFriends.SetPersonaName(DisplayNamePrefix + DisplayName);
SteamFriends.SetPersonaState(EPersonaState.Online);
log.Success("Steam Bot Logged In Completely!");
IsLoggedIn = true;
GetUserHandler(SteamClient.SteamID).OnLoginCompleted();
});
msg.Handle <SteamClient.JobCallback <SteamUser.WebAPIUserNonceCallback> >(jobCallback =>
{
log.Debug("Received new WebAPIUserNonce.");
if (jobCallback.Callback.Result == EResult.OK)
{
MyUserNonce = jobCallback.Callback.Nonce;
UserWebLogOn();
}
else
{
log.Error("WebAPIUserNonce Error: " + jobCallback.Callback.Result);
}
});
// handle a special JobCallback differently than the others
if (msg.IsType <SteamClient.JobCallback <SteamUser.UpdateMachineAuthCallback> >())
{
msg.Handle <SteamClient.JobCallback <SteamUser.UpdateMachineAuthCallback> >(
jobCallback => OnUpdateMachineAuthCallback(jobCallback.Callback, jobCallback.JobID)
);
}
#endregion
#region Friends
msg.Handle <SteamFriends.FriendsListCallback>(callback =>
{
foreach (SteamFriends.FriendsListCallback.Friend friend in callback.FriendList)
{
switch (friend.SteamID.AccountType)
{
case EAccountType.Clan:
if (friend.Relationship == EFriendRelationship.RequestRecipient)
{
if (GetUserHandler(friend.SteamID).OnGroupAdd())
{
AcceptGroupInvite(friend.SteamID);
}
else
{
DeclineGroupInvite(friend.SteamID);
}
}
break;
default:
CreateFriendsListIfNecessary();
if (friend.Relationship == EFriendRelationship.None)
{
friends.Remove(friend.SteamID);
GetUserHandler(friend.SteamID).OnFriendRemove();
RemoveUserHandler(friend.SteamID);
}
else if (friend.Relationship == EFriendRelationship.RequestRecipient)
{
if (GetUserHandler(friend.SteamID).OnFriendAdd())
{
if (!friends.Contains(friend.SteamID))
{
friends.Add(friend.SteamID);
}
else
{
log.Error("Friend was added who was already in friends list: " + friend.SteamID);
}
SteamFriends.AddFriend(friend.SteamID);
}
else
{
SteamFriends.RemoveFriend(friend.SteamID);
RemoveUserHandler(friend.SteamID);
}
}
break;
}
}
});
msg.Handle <SteamFriends.FriendMsgCallback>(callback =>
{
EChatEntryType type = callback.EntryType;
if (callback.EntryType == EChatEntryType.ChatMsg)
{
log.Info(String.Format("Chat Message from {0}: {1}",
SteamFriends.GetFriendPersonaName(callback.Sender),
callback.Message
));
GetUserHandler(callback.Sender).OnMessage(callback.Message, type);
}
});
#endregion
#region Group Chat
msg.Handle <SteamFriends.ChatMsgCallback>(callback =>
{
GetUserHandler(callback.ChatterID).OnChatRoomMessage(callback.ChatRoomID, callback.ChatterID, callback.Message);
});
#endregion
#region Trading
msg.Handle <SteamTrading.SessionStartCallback>(callback =>
{
bool started = HandleTradeSessionStart(callback.OtherClient);
if (!started)
{
log.Error("Could not start the trade session.");
}
else
{
log.Debug("SteamTrading.SessionStartCallback handled successfully. Trade Opened.");
}
});
msg.Handle <SteamTrading.TradeProposedCallback>(callback =>
{
if (CheckCookies() == false)
{
SteamTrade.RespondToTrade(callback.TradeID, false);
return;
}
try
{
tradeManager.InitializeTrade(SteamUser.SteamID, callback.OtherClient);
}
catch (WebException we)
{
SteamFriends.SendChatMessage(callback.OtherClient,
EChatEntryType.ChatMsg,
"Trade error: " + we.Message);
SteamTrade.RespondToTrade(callback.TradeID, false);
return;
}
catch (Exception)
{
SteamFriends.SendChatMessage(callback.OtherClient,
EChatEntryType.ChatMsg,
"Trade declined. Could not correctly fetch your backpack.");
SteamTrade.RespondToTrade(callback.TradeID, false);
return;
}
//if (tradeManager.OtherInventory.IsPrivate)
//{
// SteamFriends.SendChatMessage(callback.OtherClient,
// EChatEntryType.ChatMsg,
// "Trade declined. Your backpack cannot be private.");
// SteamTrade.RespondToTrade (callback.TradeID, false);
// return;
//}
if (CurrentTrade == null && GetUserHandler(callback.OtherClient).OnTradeRequest())
{
SteamTrade.RespondToTrade(callback.TradeID, true);
}
else
{
SteamTrade.RespondToTrade(callback.TradeID, false);
}
});
msg.Handle <SteamTrading.TradeResultCallback>(callback =>
{
if (callback.Response == EEconTradeResponse.Accepted)
{
log.Debug("Trade Status: " + callback.Response);
log.Info("Trade Accepted!");
GetUserHandler(callback.OtherClient).OnTradeRequestReply(true, callback.Response.ToString());
}
else
{
log.Warn("Trade failed: " + callback.Response);
CloseTrade();
GetUserHandler(callback.OtherClient).OnTradeRequestReply(false, callback.Response.ToString());
}
});
#endregion
#region Disconnect
msg.Handle <SteamUser.LoggedOffCallback>(callback =>
{
IsLoggedIn = false;
log.Warn("Logged Off: " + callback.Result);
});
msg.Handle <SteamClient.DisconnectedCallback>(callback =>
{
IsLoggedIn = false;
CloseTrade();
log.Warn("Disconnected from Steam Network!");
SteamClient.Connect();
});
#endregion
}
void HandleSteamMessage(CallbackMsg msg)
{
log.Debug(msg.ToString());
#region Login
msg.Handle <SteamClient.ConnectedCallback> (callback =>
{
log.Debug("Connection Callback: " + callback.Result);
if (callback.Result == EResult.OK)
{
UserLogOn();
}
else
{
log.Error("Failed to connect to Steam Community, trying again...");
SteamClient.Connect();
}
});
msg.Handle <SteamUser.LoggedOnCallback> (callback =>
{
log.Debug("Logged On Callback: " + callback.Result);
if (callback.Result != EResult.OK)
{
log.Error("Login Error: " + callback.Result);
}
if (callback.Result == EResult.AccountLogonDenied)
{
log.Interface("This account is protected by Steam Guard. Enter the authentication code sent to the proper email: ");
logOnDetails.AuthCode = Console.ReadLine();
}
if (callback.Result == EResult.InvalidLoginAuthCode)
{
log.Interface("An Invalid Authorization Code was provided. Enter the authentication code sent to the proper email: ");
logOnDetails.AuthCode = Console.ReadLine();
}
});
msg.Handle <SteamUser.LoginKeyCallback> (callback =>
{
while (true)
{
bool authd = SteamWeb.Authenticate(callback, SteamClient, out sessionId, out token);
if (authd)
{
log.Success("User Authenticated!");
break;
}
else
{
log.Warn("Authentication failed, retrying in 2s...");
Thread.Sleep(2000);
}
}
log.Info("Downloading Schema...");
if (Trade.CurrentSchema == null)
{
Trade.CurrentSchema = Schema.FetchSchema(apiKey);
}
log.Success("Schema Downloaded!");
SteamFriends.SetPersonaName(DisplayNamePrefix + DisplayName);
SteamFriends.SetPersonaState(EPersonaState.Online);
log.Success("Steam Bot Logged In Completely!");
IsLoggedIn = true;
});
// handle a special JobCallback differently than the others
if (msg.IsType <SteamClient.JobCallback <SteamUser.UpdateMachineAuthCallback> >())
{
msg.Handle <SteamClient.JobCallback <SteamUser.UpdateMachineAuthCallback> >(
jobCallback => OnUpdateMachineAuthCallback(jobCallback.Callback, jobCallback.JobID)
);
}
#endregion
#region Friends
msg.Handle <SteamFriends.FriendsListCallback> (callback =>
{
foreach (SteamFriends.FriendsListCallback.Friend friend in callback.FriendList)
{
if (!friends.Contains(friend.SteamID))
{
friends.Add(friend.SteamID);
if (friend.Relationship == EFriendRelationship.PendingInvitee &&
GetUserHandler(friend.SteamID).OnFriendAdd())
{
SteamFriends.AddFriend(friend.SteamID);
}
}
}
});
msg.Handle <SteamFriends.FriendMsgCallback> (callback =>
{
EChatEntryType type = callback.EntryType;
if (callback.EntryType == EChatEntryType.ChatMsg ||
callback.EntryType == EChatEntryType.Emote)
{
log.Info(String.Format("Chat Message from {0}: {1}",
SteamFriends.GetFriendPersonaName(callback.Sender),
callback.Message
));
GetUserHandler(callback.Sender).OnMessage(callback.Message, type);
}
});
#endregion
#region Trading
msg.Handle <SteamTrading.SessionStartCallback> (callback =>
{
OpenTrade(callback.OtherClient);
});
msg.Handle <SteamTrading.TradeProposedCallback> (callback =>
{
if (CurrentTrade == null && GetUserHandler(callback.OtherClient).OnTradeRequest())
{
SteamTrade.RespondToTrade(callback.TradeID, true);
}
else
{
SteamTrade.RespondToTrade(callback.TradeID, false);
}
});
msg.Handle <SteamTrading.TradeResultCallback> (callback =>
{
log.Debug("Trade Status: " + callback.Response);
if (callback.Response == EEconTradeResponse.Accepted)
{
log.Info("Trade Accepted!");
}
if (callback.Response == EEconTradeResponse.Cancel ||
callback.Response == EEconTradeResponse.ConnectionFailed ||
callback.Response == EEconTradeResponse.Declined ||
callback.Response == EEconTradeResponse.Error ||
callback.Response == EEconTradeResponse.InitiatorAlreadyTrading ||
callback.Response == EEconTradeResponse.TargetAlreadyTrading ||
callback.Response == EEconTradeResponse.Timeout ||
callback.Response == EEconTradeResponse.TooSoon ||
callback.Response == EEconTradeResponse.VacBannedInitiator ||
callback.Response == EEconTradeResponse.VacBannedTarget ||
callback.Response == EEconTradeResponse.NotLoggedIn) // uh...
{
CloseTrade();
}
});
#endregion
#region Disconnect
msg.Handle <SteamUser.LoggedOffCallback> (callback =>
{
IsLoggedIn = false;
log.Warn("Logged Off: " + callback.Result);
});
msg.Handle <SteamClient.DisconnectedCallback> (callback =>
{
IsLoggedIn = false;
CloseTrade();
log.Warn("Disconnected from Steam Network!");
SteamClient.Connect();
});
#endregion
}
void HandleSteamMessage(CallbackMsg msg, Interface gui)
{
//log.Debug(msg.ToString());
#region Login
msg.Handle <SteamClient.ConnectedCallback>(callback =>
{
//log.Debug("Connection Callback: " + callback.Result);
if (callback.Result == EResult.OK)
{
UserLogOn();
}
else
{
gui.UpdateLog("Failed to connect to Steam Community, trying again...");
SteamClient.Connect();
}
});
msg.Handle <SteamUser.LoggedOnCallback>(callback =>
{
//log.Debug("Logged On Callback: " + callback.Result);
if (callback.Result != EResult.OK)
{
gui.UpdateLog("\r\nLogin Error: " + callback.Result);
//log.Error("Login Error: " + callback.Result);
gui.Invoke((Action)(() => gui.text_username.Enabled = true));
gui.Invoke((Action)(() => gui.text_password.Enabled = true));
gui.Invoke((Action)(() => gui.button_login.Text = "Login"));
}
if (callback.Result == EResult.AccountLogonDenied)
{
////log.Interface("This account is protected by Steam Guard. Enter the authentication code sent to the proper email: ");
gui.Invoke((Action)(() => gui.SteamGuard()));
while (Application.OpenForms.Count > 1)
{
}
logOnDetails.AuthCode = SteamGuard.authCode;
}
if (callback.Result == EResult.InvalidLoginAuthCode)
{
gui.Invoke((Action)(() => gui.SteamGuard(true)));
while (Application.OpenForms.Count > 1)
{
}
logOnDetails.AuthCode = SteamGuard.authCode;
}
});
msg.Handle <SteamUser.LoginKeyCallback>(callback =>
{
while (true)
{
bool authd = SteamWeb.Authenticate(callback, SteamClient, out sessionId, out token);
if (authd)
{
gui.UpdateLog("\r\nUser authenticated!");
break;
}
else
{
gui.UpdateLog("\r\nAuthentication failed, retrying in 2s...");
Thread.Sleep(2000);
}
}
SteamFriends.SetPersonaState(EPersonaState.Snooze);
gui.UpdateLog("\r\nLogged in completely!\r\n");
gui.Invoke((Action)(() => gui.button_login.Text = "Logged in"));
IsLoggedIn = true;
while (true)
{
Console.ReadLine();
}
});
// handle a special JobCallback differently than the others
if (msg.IsType <SteamClient.JobCallback <SteamUser.UpdateMachineAuthCallback> >())
{
msg.Handle <SteamClient.JobCallback <SteamUser.UpdateMachineAuthCallback> >(
jobCallback => OnUpdateMachineAuthCallback(jobCallback.Callback, jobCallback.JobID)
);
}
#endregion
#region Friends
/*msg.Handle<SteamFriends.FriendsListCallback>(callback =>
* {
* foreach (SteamFriends.FriendsListCallback.Friend friend in callback.FriendList)
* {
* if (!friends.Contains(friend.SteamID))
* {
* friends.Add(friend.SteamID);
* if (friend.Relationship == EFriendRelationship.PendingInvitee &&
* GetUserHandler(friend.SteamID).OnFriendAdd())
* {
* SteamFriends.AddFriend(friend.SteamID);
* }
* }
* }
* });*/
msg.Handle <SteamFriends.FriendMsgCallback>(callback =>
{
EChatEntryType type = callback.EntryType;
if (callback.EntryType == EChatEntryType.ChatMsg ||
callback.EntryType == EChatEntryType.Emote)
{
//log.Info(String.Format("Chat Message from {0}: {1}",
//SteamFriends.GetFriendPersonaName(callback.Sender),
//callback.Message
//));
GetUserHandler(callback.Sender).OnMessage(callback.Message, type);
}
});
#endregion
#region Trading
msg.Handle <SteamTrading.SessionStartCallback>(callback =>
{
bool started = HandleTradeSessionStart(callback.OtherClient);
if (!started)
{
log.Error("Could not start the trade session.");
}
else
{
log.Debug("SteamTrading.SessionStartCallback handled successfully. Trade Opened.");
}
});
msg.Handle <SteamTrading.TradeProposedCallback>(callback =>
{
try
{
tradeManager.InitializeTrade(SteamUser.SteamID, callback.OtherClient);
}
catch
{
SteamFriends.SendChatMessage(callback.OtherClient,
EChatEntryType.ChatMsg,
"Trade declined. Could not correctly fetch your backpack.");
SteamTrade.RespondToTrade(callback.TradeID, false);
return;
}
if (tradeManager.OtherInventory.IsPrivate)
{
SteamFriends.SendChatMessage(callback.OtherClient,
EChatEntryType.ChatMsg,
"Trade declined. Your backpack cannot be private.");
SteamTrade.RespondToTrade(callback.TradeID, false);
return;
}
if (CurrentTrade == null && GetUserHandler(callback.OtherClient).OnTradeRequest())
{
SteamTrade.RespondToTrade(callback.TradeID, true);
}
else
{
SteamTrade.RespondToTrade(callback.TradeID, false);
}
});
msg.Handle <SteamTrading.TradeResultCallback>(callback =>
{
//log.Debug("Trade Status: " + callback.Response);
if (callback.Response == EEconTradeResponse.Accepted)
{
//log.Info("Trade Accepted!");
}
if (callback.Response == EEconTradeResponse.Cancel ||
callback.Response == EEconTradeResponse.ConnectionFailed ||
callback.Response == EEconTradeResponse.Declined ||
callback.Response == EEconTradeResponse.Error ||
callback.Response == EEconTradeResponse.InitiatorAlreadyTrading ||
callback.Response == EEconTradeResponse.TargetAlreadyTrading ||
callback.Response == EEconTradeResponse.Timeout ||
callback.Response == EEconTradeResponse.TooSoon ||
callback.Response == EEconTradeResponse.VacBannedInitiator ||
callback.Response == EEconTradeResponse.VacBannedTarget ||
callback.Response == EEconTradeResponse.NotLoggedIn) // uh...
{
CloseTrade();
}
});
#endregion
#region Disconnect
msg.Handle <SteamUser.LoggedOffCallback>(callback =>
{
IsLoggedIn = false;
gui.UpdateLog("\r\nLogged Off: " + callback.Result);
//log.Warn("Logged Off: " + callback.Result);
});
msg.Handle <SteamClient.DisconnectedCallback>(callback =>
{
IsLoggedIn = false;
CloseTrade();
gui.UpdateLog("\r\nDisconnected from Steam Network! Trying to reconnect...");
//log.Warn("Disconnected from Steam Network!");
SteamClient.Connect();
});
#endregion
}
void HandleSteamMessage(CallbackMsg msg)
{
log.Debug(msg.ToString());
msg.Handle <SteamGameCoordinator.MessageCallback>(callback =>
{
Console.WriteLine(callback.EMsg);
});
msg.Handle <ClientPlayerNicknameListHandler.ClientPlayerNicknameListCallback>(callback =>
{
foreach (var player in callback.Nicknames)
{
PlayerNicknames.Add(player.steamid, player.nickname);
}
});
#region Login
msg.Handle <SteamClient.ConnectedCallback> (callback =>
{
log.Debug("Connection Callback: " + callback.Result);
if (callback.Result == EResult.OK)
{
UserLogOn();
}
else
{
log.Error("Failed to connect to Steam Community, trying again...");
main.Invoke((Action)(() =>
{
main.label_status.Text = "Failed to connect to Steam Community, trying again...";
}));
SteamClient.Connect();
}
});
msg.Handle <SteamUser.LoggedOnCallback> (callback =>
{
log.Debug("Logged On Callback: " + callback.Result);
if (callback.Result == EResult.OK)
{
MyLoginKey = callback.WebAPIUserNonce;
main.Invoke((Action)(() =>
{
main.label_status.Text = "Logging in to Steam...";
log.Info("Logging in to Steam...");
}));
}
if (callback.Result != EResult.OK)
{
log.Error("Login Error: " + callback.Result);
main.Invoke((Action)(() =>
{
main.label_status.Text = "Login Error: " + callback.Result;
}));
}
if (callback.Result == EResult.InvalidPassword)
{
MetroFramework.MetroMessageBox.Show(main, "Your password is incorrect. Please try again.",
"Invalid Password",
MessageBoxButtons.OK,
MessageBoxIcon.Error,
MessageBoxDefaultButton.Button1);
main.wrongAPI = true;
main.Invoke((Action)(main.Close));
return;
}
if (callback.Result == EResult.AccountLogonDenied)
{
log.Interface("This account is protected by Steam Guard. Enter the authentication code sent to the proper email: ");
SteamGuard SteamGuard = new SteamGuard();
SteamGuard.ShowDialog();
logOnDetails.AuthCode = SteamGuard.AuthCode;
main.Invoke((Action)(() =>
{
main.label_status.Text = "Logging in...";
}));
SteamClient.Connect();
}
if (callback.Result == EResult.InvalidLoginAuthCode)
{
log.Interface("An Invalid Authorization Code was provided. Enter the authentication code sent to the proper email: ");
SteamGuard SteamGuard = new SteamGuard("An Invalid Authorization Code was provided.\nEnter the authentication code sent to the proper email: ");
SteamGuard.ShowDialog();
logOnDetails.AuthCode = SteamGuard.AuthCode;
main.Invoke((Action)(() =>
{
main.label_status.Text = "Logging in...";
}));
SteamClient.Connect();
}
});
msg.Handle <SteamUser.LoginKeyCallback> (callback =>
{
log.Debug("Handling LoginKeyCallback...");
while (true)
{
try
{
log.Info("About to authenticate...");
main.Invoke((Action)(() =>
{
main.label_status.Text = "Authenticating...";
}));
bool authd = false;
try
{
authd = SteamWeb.Authenticate(callback, SteamClient, out sessionId, out token, MyLoginKey);
}
catch (Exception ex)
{
log.Error("Error on authentication:\n" + ex);
}
if (authd)
{
log.Success("User authenticated!");
main.Invoke((Action)(() =>
{
main.label_status.Text = "User authenticated!";
}));
tradeManager = new TradeManager(apiKey, sessionId, token);
tradeManager.SetTradeTimeLimits(0, 0, TradePollingInterval);
tradeManager.OnTimeout += OnTradeTimeout;
break;
}
else
{
log.Warn("Authentication failed, retrying in 2s...");
main.Invoke((Action)(() =>
{
main.label_status.Text = "Authentication failed, retrying in 2s...";
}));
Thread.Sleep(2000);
}
}
catch (Exception ex)
{
log.Error(ex.ToString());
}
}
SteamFriends.SetPersonaName(SteamFriends.GetFriendPersonaName(SteamUser.SteamID));
SteamFriends.SetPersonaState(EPersonaState.Online);
log.Success("Account Logged In Completely!");
main.Invoke((Action)(() =>
{
main.label_status.Text = "Logged in completely!";
}));
botCookies = new CookieContainer();
botCookies.SetCookies(new Uri("http://steamcommunity.com"), string.Format("steamLogin={0}", token));
botCookies.SetCookies(new Uri("http://steamcommunity.com"), string.Format("sessionid={0}", sessionId));
GenericInventory.SetCookie(botCookies, SteamUser.SteamID);
IsLoggedIn = true;
try
{
main.Invoke((Action)(main.Hide));
}
catch (Exception)
{
Environment.Exit(1);
}
new Thread(() =>
{
CDNCache.Initialize();
#if !DEBUG
ConnectToGC(13540830642081628378);
System.Threading.Thread.Sleep(2000);
ConnectToGC(0);
#endif
while (true)
{
if (showFriends != null)
{
var numFriendsDisplayed = showFriends.GetNumFriendsDisplayed();
var numSteamFriendCount = SteamFriends.GetFriendCount();
if (numFriendsDisplayed != -1 && numFriendsDisplayed != ListFriends.Get().Count)
{
LoadFriends();
showFriends.UpdateFriendsHTML();
}
System.Threading.Thread.Sleep(10000);
}
}
}).Start();
});
// handle a special JobCallback differently than the others
if (msg.IsType <SteamClient.JobCallback <SteamUser.UpdateMachineAuthCallback> >())
{
msg.Handle <SteamClient.JobCallback <SteamUser.UpdateMachineAuthCallback> >(
jobCallback => OnUpdateMachineAuthCallback(jobCallback.Callback, jobCallback.JobID)
);
}
#endregion
msg.Handle <SteamUser.AccountInfoCallback>(callback =>
{
DisplayName = callback.PersonaName;
});
#region Friends
msg.Handle <SteamFriends.FriendsListCallback>(callback =>
{
foreach (SteamFriends.FriendsListCallback.Friend friend in callback.FriendList)
{
if (friend.SteamID.AccountType == EAccountType.Clan)
{
}
else
{
if (!friends.Contains(friend.SteamID))
{
new Thread(() =>
{
main.Invoke((Action)(() =>
{
if (showFriends == null && friend.Relationship == EFriendRelationship.RequestRecipient)
{
log.Info(SteamFriends.GetFriendPersonaName(friend.SteamID) + " has added you.");
friends.Add(friend.SteamID);
string name = SteamFriends.GetFriendPersonaName(friend.SteamID);
string status = SteamFriends.GetFriendPersonaState(friend.SteamID).ToString();
if (!ListFriendRequests.Find(friend.SteamID))
{
ListFriendRequests.Add(name, friend.SteamID, status);
}
}
if (showFriends != null && friend.Relationship == EFriendRelationship.RequestRecipient)
{
log.Info(SteamFriends.GetFriendPersonaName(friend.SteamID) + " has added you.");
friends.Add(friend.SteamID);
string name = SteamFriends.GetFriendPersonaName(friend.SteamID);
string status = SteamFriends.GetFriendPersonaState(friend.SteamID).ToString();
if (!ListFriendRequests.Find(friend.SteamID))
{
try
{
ListFriendRequests.Add(name, friend.SteamID, status);
log.Info("Notifying you that " + SteamFriends.GetFriendPersonaName(friend.SteamID) + " has added you.");
int duration = 5;
FormAnimator.AnimationMethod animationMethod = FormAnimator.AnimationMethod.Slide;
FormAnimator.AnimationDirection animationDirection = FormAnimator.AnimationDirection.Up;
Notification toastNotification = new Notification(name, Util.GetColorFromPersonaState(this, friend.SteamID), "has sent you a friend request.", duration, animationMethod, animationDirection);
toastNotification.Show();
try
{
string soundsFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory);
string soundFile = Path.Combine(soundsFolder + "trade_message.wav");
using (System.Media.SoundPlayer player = new System.Media.SoundPlayer(soundFile))
{
player.Play();
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
catch
{
Console.WriteLine("Friends list hasn't loaded yet...");
}
}
}
}));
}).Start();
}
else
{
if (friend.Relationship == EFriendRelationship.None)
{
friends.Remove(friend.SteamID);
GetUserHandler(friend.SteamID).OnFriendRemove();
RemoveUserHandler(friend.SteamID);
}
}
}
}
LoadFriends();
});
msg.Handle <SteamFriends.PersonaStateCallback>(callback =>
{
var status = callback.State;
var sid = callback.FriendID;
ListFriends.UpdateStatus(sid, status.ToString());
ListFriends.UpdateName(sid, SteamFriends.GetFriendPersonaName(sid));
GetUserHandler(sid).UpdatePersonaState();
if (showFriends != null)
{
showFriends.UpdateState();
showFriends.UpdateFriendHTML(sid);
}
});
msg.Handle <SteamFriends.FriendMsgCallback>(callback =>
{
EChatEntryType type = callback.EntryType;
if (type == EChatEntryType.Typing)
{
var name = SteamFriends.GetFriendPersonaName(callback.Sender);
GetUserHandler(callback.Sender).SetChatStatus(name + " is typing...");
System.Threading.Thread.Sleep(30000);
GetUserHandler(callback.Sender).SetChatStatus("");
}
if (type == EChatEntryType.ChatMsg)
{
GetUserHandler(callback.Sender).SetChatStatus("");
GetUserHandler(callback.Sender).OnMessage(callback.Message, type);
}
});
msg.Handle <SteamFriends.ChatMsgCallback>(callback =>
{
Console.WriteLine(SteamFriends.GetFriendPersonaName(callback.ChatterID) + ": " + callback.Message);
});
#endregion
#region Trading
msg.Handle <SteamTrading.SessionStartCallback>(callback =>
{
bool started = HandleTradeSessionStart(callback.OtherClient);
if (!started)
{
log.Error("Could not start the trade session.");
}
else
{
log.Debug("SteamTrading.SessionStartCallback handled successfully. Trade Opened.");
}
});
msg.Handle <SteamTrading.TradeProposedCallback>(callback =>
{
try
{
tradeManager.InitializeTrade(SteamUser.SteamID, callback.OtherClient);
}
catch
{
SteamTrade.RespondToTrade(callback.TradeID, false);
return;
}
//if (CurrentTrade == null && GetUserHandler (callback.OtherClient).OnTradeRequest ())
if (CurrentTrade == null)
{
GetUserHandler(callback.OtherClient).SendTradeState(callback.TradeID);
}
else
{
SteamTrade.RespondToTrade(callback.TradeID, false);
}
});
msg.Handle <SteamTrading.TradeResultCallback>(callback =>
{
//log.Debug ("Trade Status: " + callback.Response);
if (callback.Response == EEconTradeResponse.Accepted)
{
//log.Info ("Trade Accepted!");
}
else if (callback.Response == EEconTradeResponse.Cancel ||
callback.Response == EEconTradeResponse.ConnectionFailed ||
callback.Response == EEconTradeResponse.Declined ||
callback.Response == EEconTradeResponse.AlreadyHasTradeRequest ||
callback.Response == EEconTradeResponse.AlreadyTrading ||
callback.Response == EEconTradeResponse.TargetAlreadyTrading ||
callback.Response == EEconTradeResponse.NoResponse ||
callback.Response == EEconTradeResponse.TooSoon ||
callback.Response == EEconTradeResponse.TradeBannedInitiator ||
callback.Response == EEconTradeResponse.TradeBannedTarget ||
callback.Response == EEconTradeResponse.NotLoggedIn)
{
if (callback.Response == EEconTradeResponse.Cancel)
{
TradeResponse(callback.OtherClient, "had asked to trade with you, but has cancelled their request.");
}
if (callback.Response == EEconTradeResponse.ConnectionFailed)
{
TradeResponse(callback.OtherClient, "Lost connection to Steam. Reconnecting as soon as possible...");
}
if (callback.Response == EEconTradeResponse.Declined)
{
TradeResponse(callback.OtherClient, "has declined your trade request.");
}
if (callback.Response == EEconTradeResponse.AlreadyHasTradeRequest)
{
TradeResponse(callback.OtherClient, "An error has occurred in sending the trade request.");
}
if (callback.Response == EEconTradeResponse.AlreadyTrading)
{
TradeResponse(callback.OtherClient, "You are already in a trade so you cannot trade someone else.");
}
if (callback.Response == EEconTradeResponse.TargetAlreadyTrading)
{
TradeResponse(callback.OtherClient, "You cannot trade the other user because they are already in trade with someone else.");
}
if (callback.Response == EEconTradeResponse.NoResponse)
{
TradeResponse(callback.OtherClient, "did not respond to the trade request.");
}
if (callback.Response == EEconTradeResponse.TooSoon)
{
TradeResponse(callback.OtherClient, "It is too soon to send a new trade request. Try again later.");
}
if (callback.Response == EEconTradeResponse.TradeBannedInitiator)
{
TradeResponse(callback.OtherClient, "You are trade-banned and cannot trade.");
}
if (callback.Response == EEconTradeResponse.TradeBannedTarget)
{
TradeResponse(callback.OtherClient, "You cannot trade with this person because they are trade-banned.");
}
if (callback.Response == EEconTradeResponse.NotLoggedIn)
{
TradeResponse(callback.OtherClient, "Trade failed to initialize because you are not logged in.");
}
CloseTrade();
}
});
#endregion
#region Disconnect
msg.Handle <SteamUser.LoggedOffCallback> (callback =>
{
IsLoggedIn = false;
log.Warn("Logged Off: " + callback.Result);
});
msg.Handle <SteamClient.DisconnectedCallback> (callback =>
{
if (IsLoggedIn)
{
IsLoggedIn = false;
CloseTrade();
log.Warn("Disconnected from Steam Network!");
main.Invoke((Action)(() =>
{
main.label_status.Text = "Disconnected from Steam Network! Retrying...";
}));
SteamClient.Connect();
main.Invoke((Action)(() =>
{
main.label_status.Text = "Connecting to Steam...";
}));
}
});
#endregion
if (!hasrun && IsLoggedIn)
{
Thread main = new Thread(GUI);
main.Start();
hasrun = true;
}
}
public static void Main(string[] args)
{
#region SteamRE Init
AllArgs = args;
//Hacking around https
ServicePointManager.CertificatePolicy = new MainClass();
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine("\n\tSteamBot Beta\n\tCreated by Jessecar96.\n\n");
Console.ForegroundColor = ConsoleColor.White;
steamClient = new SteamClient();
steamTrade = steamClient.GetHandler <SteamTrading>();
SteamUser steamUser = steamClient.GetHandler <SteamUser> ();
steamFriends = steamClient.GetHandler <SteamFriends>();
steamClient.Connect();
#endregion
while (true)
{
CallbackMsg msg = steamClient.WaitForCallback(true);
//Console Debug
printConsole(msg.ToString(), ConsoleColor.Blue, true);
#region Logged Off Handler
msg.Handle <SteamUser.LoggedOffCallback> (callback =>
{
printConsole("Logged Off: " + callback.Result, ConsoleColor.Red);
});
#endregion
#region Steam Disconnect Handler
msg.Handle <SteamClient.DisconnectedCallback> (callback =>
{
printConsole("Disconnected.", ConsoleColor.Red);
});
#endregion
#region Steam Connect Handler
/**
* --Steam Connection Callback
*
* It's not needed to modify this section
*/
msg.Handle <SteamClient.ConnectedCallback> (callback =>
{
//Print Callback
printConsole("Steam Connected Callback: " + callback.Result, ConsoleColor.Cyan);
//Validate Result
if (callback.Result == EResult.OK)
{
//Get Steam Login Details
printConsole("Username: "******"Password: "******"Getting Web Cookies...", ConsoleColor.Yellow);
//Get Web Cookies
SteamWeb web = new SteamWeb();
WebCookies = web.DoLogin(user, pass);
if (WebCookies != null)
{
printConsole("SteamWeb Cookies retrived.", ConsoleColor.Green);
//Do Login
steamUser.LogOn(new SteamUser.LogOnDetails {
Username = user,
Password = pass
});
}
else
{
printConsole("Error while getting SteamWeb Cookies.", ConsoleColor.Red);
}
}
else
{
//Failure
printConsole("Failed to Connect to steam.", ConsoleColor.Red);
}
});
#endregion
#region Steam Login Handler
//Logged in (or not)
msg.Handle <SteamUser.LoggedOnCallback>(callback =>
{
printConsole("Logged on callback: " + callback.Result, ConsoleColor.Cyan);
if (callback.Result != EResult.OK)
{
printConsole("Login Failed!", ConsoleColor.Red);
}
else
{
printConsole("Successfulyl Logged In!\nWelcome " + steamUser.SteamID, ConsoleColor.Green);
//Set community status
steamFriends.SetPersonaName(BotPersonaName);
steamFriends.SetPersonaState(BotPersonaState);
}
});
#endregion
#region Steam Trade Start
/**
*
* Steam Trading Handler
*
*/
msg.Handle <SteamTrading.TradeStartSessionCallback>(call =>
{
//Trading
trade = null;
trade = new TradeSystem();
trade.initTrade(steamUser.SteamID, call.Other, WebCookies);
});
#endregion
#region Trade Requested Handler
//Don't modify this
msg.Handle <SteamTrading.TradeProposedCallback>(thing =>
{
//Trade Callback
printConsole("Trade Proposed Callback. Other: " + thing.Other + "\n");
//Accept It
steamTrade.RequestTrade(thing.Other);
});
#endregion
msg.Handle <SteamFriends.PersonaStateCallback>(callback =>
{
if (callback.FriendID == steamUser.SteamID)
{
return;
}
EFriendRelationship relationship = steamFriends.GetFriendRelationship(callback.FriendID);
if (!(relationship == EFriendRelationship.RequestRecipient))
{
return;
}
if (steamFriends.GetFriendRelationship(callback.FriendID) == EFriendRelationship.PendingInvitee)
{
printConsole("[Friend] Friend Request Pending: " + callback.FriendID + "(" + steamFriends.GetFriendPersonaName(callback.FriendID) + ") - Accepted", ConsoleColor.Yellow);
steamFriends.AddFriend(callback.FriendID);
}
});
#region Steam Chat Handler
/**
*
* Steam Chat Handler
*
*/
msg.Handle <SteamFriends.FriendMsgCallback>(callback =>
{
//Type (emote or chat)
EChatEntryType type = callback.EntryType;
if (type == EChatEntryType.ChatMsg)
{
//Message is a chat message
//Reply with the same message
steamFriends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, callback.Message);
//Chat API coming soon
}
else if (type == EChatEntryType.Emote)
{
//Message is emote
//Do nothing yet
}
});
#endregion
} //end while loop
} //end Main method
void HandleSteamMessage(CallbackMsg msg)
{
log.Debug(msg.ToString());
#region Login
msg.Handle <SteamClient.ConnectedCallback> (callback =>
{
log.Debug("Connection Callback: " + callback.Result);
if (callback.Result == EResult.OK)
{
UserLogOn();
}
else
{
log.Error("Failed to connect to Steam Community, trying again...");
SteamClient.Connect();
}
});
msg.Handle <SteamUser.LoggedOnCallback> (callback =>
{
log.Debug("Logged On Callback: " + callback.Result);
if (callback.Result == EResult.OK)
{
MyLoginKey = callback.WebAPIUserNonce;
}
else
{
log.Error("Login Error: " + callback.Result);
}
if (callback.Result == EResult.AccountLogonDenied)
{
log.Interface("This account is SteamGuard enabled. Enter the code via the `auth' command.");
// try to get the steamguard auth code from the event callback
var eva = new SteamGuardRequiredEventArgs();
FireOnSteamGuardRequired(eva);
if (!String.IsNullOrEmpty(eva.SteamGuard))
{
logOnDetails.AuthCode = eva.SteamGuard;
}
else
{
logOnDetails.AuthCode = Console.ReadLine();
}
}
if (callback.Result == EResult.InvalidLoginAuthCode)
{
log.Interface("The given SteamGuard code was invalid. Try again using the `auth' command.");
logOnDetails.AuthCode = Console.ReadLine();
}
});
msg.Handle <SteamUser.LoginKeyCallback> (callback =>
{
while (true)
{
bool authd = SteamWeb.Authenticate(callback, SteamClient, out sessionId, out token, MyLoginKey);
if (authd)
{
log.Success("User Authenticated!");
tradeManager = new TradeManager(apiKey, sessionId, token);
tradeManager.SetTradeTimeLimits(MaximumTradeTime, MaximiumActionGap, TradePollingInterval);
tradeManager.OnTimeout += OnTradeTimeout;
break;
}
else
{
log.Warn("Authentication failed, retrying in 2s...");
Thread.Sleep(2000);
}
}
if (Trade.CurrentSchema == null)
{
log.Info("Downloading Schema...");
Trade.CurrentSchema = Schema.FetchSchema(apiKey);
log.Success("Schema Downloaded!");
}
if (BotControlClass == "SteamBot.KeybankHandler")
{
//string newName = DisplayNamePrefix + DisplayName + " B>6 S>6.11";
string newName = DisplayNamePrefix + DisplayName + String.Format(" B>{0} S>{1}", Convert.ToString(clsFunctions.GetKeyBuyPrice()), Convert.ToString(clsFunctions.GetKeySellPrice()));
SteamFriends.SetPersonaName(newName);
}
else
{
SteamFriends.SetPersonaName(DisplayNamePrefix + DisplayName);
}
SteamFriends.SetPersonaState(EPersonaState.Online);
log.Success("Steam Bot Logged In Completely!");
IsLoggedIn = true;
this.SteamFriends.JoinChat(< GROUPCHATID >);//Gamem Tradeing Services
if (BotControlClass != "SteamBot.RaffleDonatoinUserHandler")
{
this.SteamFriends.JoinChat(< GROUPID >); //TF2 Exchange
this.SteamFriends.JoinChat(< GROUPID >); //TF2 Alliance
}
uid = < GROUPID >;
InGroupChat = true;
try
{
clsFunctions.AddBotToList(this, logOnDetails.Username);
GetInventory();
}
catch
{
}
GetUserHandler(SteamClient.SteamID).OnLoginCompleted();
});
// handle a special JobCallback differently than the others
if (msg.IsType <SteamClient.JobCallback <SteamUser.UpdateMachineAuthCallback> >())
{
msg.Handle <SteamClient.JobCallback <SteamUser.UpdateMachineAuthCallback> >(
jobCallback => OnUpdateMachineAuthCallback(jobCallback.Callback, jobCallback.JobID)
);
}
#endregion
#region Friends
msg.Handle <SteamFriends.FriendsListCallback>(callback =>
{
foreach (SteamFriends.FriendsListCallback.Friend friend in callback.FriendList)
{
if (friend.SteamID.AccountType == EAccountType.Clan)
{
if (!groups.Contains(friend.SteamID))
{
groups.Add(friend.SteamID);
if (friend.Relationship == EFriendRelationship.RequestRecipient)
{
if (GetUserHandler(friend.SteamID).OnGroupAdd())
{
AcceptGroupInvite(friend.SteamID);
}
else
{
DeclineGroupInvite(friend.SteamID);
}
}
}
else
{
if (friend.Relationship == EFriendRelationship.None)
{
groups.Remove(friend.SteamID);
}
}
}
else if (friend.SteamID.AccountType != EAccountType.Clan)
{
if (!friends.Contains(friend.SteamID))
{
friends.Add(friend.SteamID);
if (friend.Relationship == EFriendRelationship.RequestRecipient &&
GetUserHandler(friend.SteamID).OnFriendAdd())
{
CreateFriendFile(friend.SteamID);
if (friends.Count >= 200)
{
RemoveUnactiveFriends();
}
SteamFriends.AddFriend(friend.SteamID);
}
}
else
{
if (friend.Relationship == EFriendRelationship.None)
{
RemoveFriendFile(friend.SteamID);
friends.Remove(friend.SteamID);
GetUserHandler(friend.SteamID).OnFriendRemove();
}
}
}
}
});
msg.Handle <SteamFriends.FriendMsgCallback> (callback =>
{
EChatEntryType type = callback.EntryType;
if (callback.EntryType == EChatEntryType.ChatMsg)
{
log.Info(String.Format("Chat Message from {0}: {1}",
SteamFriends.GetFriendPersonaName(callback.Sender),
callback.Message
));
GetUserHandler(callback.Sender).OnMessage(callback.Message, type);
}
});
#endregion
#region Group Chat
msg.Handle <SteamFriends.ChatMsgCallback>(callback =>
{
GetUserHandler(callback.ChatterID).OnChatRoomMessage(callback.ChatRoomID, callback.ChatterID, callback.Message);
});
#endregion
#region Trading
msg.Handle <SteamTrading.SessionStartCallback> (callback =>
{
bool started = HandleTradeSessionStart(callback.OtherClient);
if (!started)
{
log.Error("Could not start the trade session.");
}
else
{
log.Debug("SteamTrading.SessionStartCallback handled successfully. Trade Opened.");
}
});
msg.Handle <SteamTrading.TradeProposedCallback> (callback =>
{
try
{
tradeManager.InitializeTrade(SteamUser.SteamID, callback.OtherClient);
}
catch (WebException we)
{
SteamFriends.SendChatMessage(callback.OtherClient,
EChatEntryType.ChatMsg,
"Trade error: " + we.Message);
SteamTrade.RespondToTrade(callback.TradeID, false);
return;
}
catch (Exception)
{
SteamFriends.SendChatMessage(callback.OtherClient,
EChatEntryType.ChatMsg,
"Trade declined. Could not correctly fetch your backpack.");
SteamTrade.RespondToTrade(callback.TradeID, false);
return;
}
//if (tradeManager.OtherInventory.IsPrivate)
//{
// SteamFriends.SendChatMessage(callback.OtherClient,
// EChatEntryType.ChatMsg,
// "Trade declined. Your backpack cannot be private.");
// SteamTrade.RespondToTrade (callback.TradeID, false);
// return;
//}
if (CurrentTrade == null && GetUserHandler(callback.OtherClient).OnTradeRequest())
{
SteamTrade.RespondToTrade(callback.TradeID, true);
}
else
{
SteamTrade.RespondToTrade(callback.TradeID, false);
}
});
msg.Handle <SteamTrading.TradeResultCallback> (callback =>
{
if (callback.Response == EEconTradeResponse.Accepted)
{
log.Debug("Trade Status: " + callback.Response);
log.Info("Trade Accepted!");
GetUserHandler(callback.OtherClient).OnTradeRequestReply(true, callback.Response.ToString());
}
else
{
log.Warn("Trade failed: " + callback.Response);
CloseTrade();
GetUserHandler(callback.OtherClient).OnTradeRequestReply(false, callback.Response.ToString());
}
});
#endregion
#region Disconnect
msg.Handle <SteamUser.LoggedOffCallback> (callback =>
{
IsLoggedIn = false;
log.Warn("Logged Off: " + callback.Result);
});
msg.Handle <SteamClient.DisconnectedCallback> (callback =>
{
IsLoggedIn = false;
CloseTrade();
log.Warn("Disconnected from Steam Network!");
SteamClient.Connect();
});
#endregion
}
