void HandleSteamCallback(CallbackMsg msg)
{
var messageMap = new Dictionary <Type, Action <CallbackMsg> >
{
{ typeof(SteamClient.ConnectedCallback), HandleConnected },
{ typeof(SteamClient.DisconnectedCallback), HandleDisconnected },
{ typeof(SteamUser.LoggedOnCallback), HandleLoggedOn },
{ typeof(SteamUser.LoggedOffCallback), HandleLoggedOff },
{ typeof(SteamUser.LoginKeyCallback), HandleLoginKey },
{ typeof(SteamWeb.WebLoggedOnCallback), HandleWebLoggedOn },
{ typeof(SteamFriends.FriendMsgCallback), HandleFriendMessage },
{ typeof(SteamFriends.FriendAddedCallback), HandleFriendAdded },
{ typeof(SteamTrading.TradeRequestCallback), HandleTradeRequest },
{ typeof(SteamTrading.TradeProposedCallback), HandleTradeProposed },
{ typeof(SteamGameCoordinator.MessageCallback), HandleGCMessage },
};
Action <CallbackMsg> func;
if (!messageMap.TryGetValue(msg.GetType(), out func))
{
return;
}
func(msg);
}
/// <summary>
/// Pushes a callback to registered handlers
/// </summary>
/// <param name="msg">The callback to push</param>
private void Push(CallbackMsg msg)
{
for (int i = 0; i < callbackHandlers.Count; i++)
{
callbackHandlers[i].HandleCallback(msg);
}
}
void HandleDisconnected(CallbackMsg msg)
{
var details = msg as SteamClient.DisconnectedCallback;
Logger.WriteLine("Disconnected from the Steam network.");
IsRunning = false;
}
public static void Update()
{
CallbackMsg msg = SteamClient.GetCallback();
if (msg == null)
{
return;
}
SteamClient.FreeLastCallback();
if (msg.IsType <SteamClient.ConnectedCallback>())
{
SteamUser.LogOn(new SteamUser.LogOnDetails()
{
Username = Steam3.UserName,
Password = Steam3.Password,
AuthCode = Steam3.AuthCode,
});
}
List <ICallbackHandler> tempHandlers = new List <ICallbackHandler>(callbackHandlers);
// push it along to anyone who wants to handle this
foreach (ICallbackHandler handler in tempHandlers)
{
handler.HandleCallback(msg);
}
}
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);
});
}
public static void Update()
{
CallbackMsg Message = Client.GetCallback();
if (Message == null)
{
return;
}
Client.FreeLastCallback();
if (Message.IsType <SteamClient.ConnectedCallback>())
{
Console.WriteLine("Steam >> Logging in.");
User.LogOn(new SteamUser.LogOnDetails()
{
Username = Username,
Password = Password,
AuthCode = AuthCode
});
}
List <ICallbackHandler> Handlers = new List <ICallbackHandler>(Callbacks);
foreach (ICallbackHandler i in Handlers)
{
i.HandleCallback(Message);
}
}
void HandleLoggedOff(CallbackMsg msg)
{
var details = msg as SteamUser.LoggedOffCallback;
Logger.WriteLine("Logged off Steam network: " + details.Result);
IsRunning = false;
}
public void HandleCallback(CallbackMsg msg)
{
if (msg.IsType <SteamUser.LoginKeyCallback>())
{
HandleLogin((SteamUser.LoginKeyCallback)msg);
}
if (msg.IsType <SteamUser.LoggedOffCallback>())
{
HandleLogoff((SteamUser.LoggedOffCallback)msg);
}
if (msg.IsType <SteamFriends.ChatEnterCallback>())
{
HandleChatEnter((SteamFriends.ChatEnterCallback)msg);
}
if (msg.IsType <SteamFriends.ChatMsgCallback>())
{
HandleChatMessage((SteamFriends.ChatMsgCallback)msg);
}
if (msg.IsType <SteamFriends.PersonaStateCallback>())
{
HandlePersonaStateChange((SteamFriends.PersonaStateCallback)msg);
}
if (msg.IsType <SteamFriends.ChatMemberInfoCallback>())
{
HandleChatMemberInfoCallback((SteamFriends.ChatMemberInfoCallback)msg);
}
if (msg.IsType <SteamFriends.ChatActionResultCallback>())
{
HandleChatActionResultCallback((SteamFriends.ChatActionResultCallback)msg);
}
}
static void Main(string[] args)
{
sclient.Connect();
CallbackMsg msg = sclient.GetCallback();
Type a = msg.GetType();
msg = sclient.GetCallback();
msg.ToString();
var asdf = (SteamUser.LoggedOnCallback)msg;
if (asdf.Result == EResult.AccountLogonDenied)
{
Console.Write("Please enter the steam access code here: ");
string steamaccesscode = Console.ReadLine();
sUser.LogOn(new SteamUser.LogOnDetails()
{
Username = username, Password = password, AuthCode = steamaccesscode
});
msg = sclient.GetCallback();
asdf = (SteamUser.LoggedOnCallback)msg;
}
if (asdf.Result == EResult.OK)
{
sFriends.SendChatMessage(new SteamID("STEAM_0:1:16516144"), EChatEntryType.ChatMsg, "Fennecs :D");
Console.WriteLine(); Console.WriteLine("Logged in succesfully. Press any key to exit");
sclient.Disconnect();
}
}
void HandleGCMessage(CallbackMsg msg)
{
var details = msg as SteamGameCoordinator.MessageCallback;
var emsg = GetEMsgDisplayString(details.EMsg);
var messageMap = new Dictionary <uint, Action <IPacketGCMsg> >
{
{ EGCMsg.ClientWelcome, OnGCClientWelcome },
// SO messages
{ EGCMsg.SOCacheSubscriptionCheck, OnGCSOCacheSubscriptionCheck },
{ EGCMsg.SOCacheSubscribed, OnGCSOCacheSubscribed },
{ EGCMsg.SOCreate, OnGCSOCreate },
{ EGCMsg.SODestroy, OnGCSODestroy },
//{ EGCMsg.SOUpdate, OnGCSOUpdate },
{ EGCMsg.UpdateItemSchema, OnGCUpdateItemSchema },
{ EGCMsg.CraftResponse, OnGCCraftResponse },
};
Action <IPacketGCMsg> func;
if (!messageMap.TryGetValue(details.EMsg, out func))
{
Logger.WriteLine("Unhandled GC message: " + emsg);
return;
}
func(details.Message);
}
/// <summary>
/// Pushes a callback to registered handlers
/// </summary>
/// <param name="msg">The callback to push</param>
private void Push(CallbackMsg msg)
{
foreach (ICallbackHandler handler in callbackHandlers)
{
handler.HandleCallback(msg);
}
}
public void pollSteam()
{
while (true)
{
CallbackMsg msg = SteamClient.WaitForCallback(true);
HandleSteamMessage(msg);
}
}
public void HandleCallback(CallbackMsg msg)
{
if (msg.IsType <SteamFriends.PersonaStateCallback>())
{
SteamFriends.PersonaStateCallback callback = (SteamFriends.PersonaStateCallback)msg;
LoadFriendsList();
}
}
private void BackgroundWorkerOnDoWork(object sender, DoWorkEventArgs doWorkEventArgs)
{
while (!backgroundWorker.CancellationPending)
{
CallbackMsg msg = SteamClient.WaitForCallback(true);
HandleSteamMessage(msg);
}
}
void HandleTradeProposed(CallbackMsg msg)
{
var details = msg as SteamTrading.TradeProposedCallback;
string name = SteamFriends.GetFriendPersonaName(details.Other);
string log = String.Format("{0} is trying to start a trade...", name);
Logger.WriteLine(log);
}
void HandleLoginKey(CallbackMsg msg)
{
var details = msg as SteamUser.LoginKeyCallback;
//Logger.WriteLine("Login Key: " + details.LoginKey);
Logger.WriteLine("Logging to the Steam Web network...");
SteamWeb.LogOn(details);
}
void HandleLoggedOn(CallbackMsg msg)
{
var details = msg as SteamUser.LoggedOnCallback;
Logger.WriteLine("Logged on: " + details.Result);
Logger.WriteLine("Launching TF2...");
ConnectToGC(TF2App);
}
public void HandleCallback(CallbackMsg msg)
{
if (msg.IsType <SteamUser.LoginKeyCallback>())
{
GetClient().Friends.SetPersonaState(EPersonaState.Online);
Friend.Me = new Friend(GetClient().User.GetSteamID());
Friend.Me.Name = "me";
SteamAlerts.ShowToast("Connected to Steam");
}
else if (msg.IsType <SteamUser.LogOnCallback>())
{
SteamUser.LogOnCallback callback = (SteamUser.LogOnCallback)msg;
if (callback.Result == EResult.OK)
{
EnableAutoReconnect();
}
else
{
DisableAutoReconnect();
}
}
else if (msg.IsType <SteamFriends.FriendMsgCallback>())
{
SteamFriends.FriendMsgCallback callback = (SteamFriends.FriendMsgCallback)msg;
if (callback.EntryType == EChatEntryType.ChatMsg)
{
Friend friend = Friend.GetFriendBySteamId(callback.Sender.ToString());
if (friend != activeChat)
{
Intent intent = new Intent(SteamAlerts.GetContext(), typeof(Chat));
intent.SetAction("chat_notification_" + DateTime.Now.Ticks);
intent.PutExtra("steam_id", friend.SteamId.ToString());
SteamAlerts.Notification("Message from " + friend.Name, friend.Name + ": " + callback.Message, callback.Message, intent, "steam_id", friend.SteamId.ToString());
SteamAlerts.PlaySound();
SteamAlerts.Vibrate(400);
}
}
}
else if (msg.IsType <SteamClient.ConnectCallback>())
{
SteamAlerts.Notification("Steam Droid", "Connected to Steam", "Connected to Steam", new Intent(SteamAlerts.GetContext(), typeof(Main)), null, null);
}
else if (msg.IsType <SteamClient.DisconnectCallback>())
{
SteamAlerts.Notification("Steam Droid", "Disconnected from Steam", "Connected to Steam", new Intent(SteamAlerts.GetContext(), typeof(Main)), null, null);
SteamAlerts.ShowToast("Disconnected from Steam");
}
}
/// <summary>
/// Handles callbacks from steam.
/// </summary>
/// <param name='msg'>
/// Message.
/// </param>
public void HandleCallback(CallbackMsg msg)
{
if (msg.IsType <SteamFriends.ChatMsgCallback>())
{
SteamFriends.ChatMsgCallback callback = (SteamFriends.ChatMsgCallback)msg;
if (callback.ChatMsgType == EChatEntryType.ChatMsg)
{
ChatMessage message = new ChatMessage(this, callback.Message);
adapter.Add(message);
}
}
}
/// <summary>
/// Linked to <see cref="Client.GetCallback"/>
/// </summary>
/// <param name="pipe"></param>
/// <param name="c"></param>
/// <returns>Whether there is a new callback</returns>
public bool GetCallback(IntPtr _, int pipe_id, ref CallbackMsg c)
{
var new_callback = Client.Client.GetCallback(pipe_id);
if (new_callback == null)
{
return(false);
}
c = (CallbackMsg)new_callback;
return(true);
}
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 HandleCallback(CallbackMsg msg)
{
if (msg.IsType <SteamFriends.FriendMsgCallback>())
{
SteamFriends.FriendMsgCallback callback = (SteamFriends.FriendMsgCallback)msg;
if (callback.EntryType == EChatEntryType.ChatMsg && callback.Sender == friend.SteamId)
{
ChatMessage message = new ChatMessage(friend, callback.Message);
Add(message);
NotifyDataSetChanged();
}
}
}
void ProcessSteamEvents()
{
CallbackMsg msg = SteamClient.GetCallback();
SteamClient.FreeLastCallback();
while (msg != null)
{
HandleSteamCallback(msg);
msg = SteamClient.GetCallback();
SteamClient.FreeLastCallback();
}
}
void HandleWebLoggedOn(CallbackMsg msg)
{
var details = msg as SteamWeb.WebLoggedOnCallback;
if (details.Result != EResult.OK)
{
Logger.WriteLine("Could not login to Web.");
return;
}
Logger.WriteLine("Logged in to web successfully.");
if (OnWebLoggedOn != null)
{
OnWebLoggedOn(this);
}
}
public Bot(Configuration.BotInfo config, string apiKey, UserHandlerCreator handlerCreator, Interface gui, bool debug = false)
{
while (Interface.loginClicked == false)
{
// Wait for user to login
}
logOnDetails = new SteamUser.LogOnDetails
{
Username = Interface.username,
Password = Interface.password
};
Admins = new ulong[1];
Admins[0] = 123456789;
this.apiKey = apiKey;
LogLevel = Log.LogLevel.Info;
//log = new Log(config.LogFile, this.DisplayName, LogLevel);
CreateHandler = handlerCreator;
BotControlClass = config.BotControlClass;
// Hacking around https
ServicePointManager.ServerCertificateValidationCallback += SteamWeb.ValidateRemoteCertificate;
////log.Debug("Initializing Steam Bot...");
SteamClient = new SteamClient();
SteamTrade = SteamClient.GetHandler <SteamTrading>();
SteamUser = SteamClient.GetHandler <SteamUser>();
SteamFriends = SteamClient.GetHandler <SteamFriends>();
gui.UpdateLog("\r\nConnecting, please wait...");
////log.Info("Connecting...");
SteamClient.Connect();
Thread CallbackThread = new Thread(() => // Callback Handling
{
while (true)
{
CallbackMsg msg = SteamClient.WaitForCallback(true);
HandleSteamMessage(msg, gui);
}
});
CallbackThread.Start();
////log.Success("Done Loading Bot!");
CallbackThread.Join();
}
static void HandleCallbacks()
{
while (handlestuff)
{
CallbackMsg msg = sclient.GetCallback();
if (msg == null)
{
return;
}
if (msg.IsType <SteamClient.ConnectedCallback>())
{
sUser.LogOn(new SteamUser.LogOnDetails()
{
Username = username, Password = password
});
}
}
}
/// <summary>
/// Updates the Steam client and passes any pending callbacks
/// </summary>
public void Update()
{
while (true)
{
CallbackMsg msg = client.WaitForCallback(true);
if (msg == null)
{
return;
}
client.FreeLastCallback();
if (msg.IsType <SteamClient.ConnectCallback>())
{
user.LogOn(new SteamUser.LogOnDetails()
{
Username = username,
Password = password,
AuthCode = authcode
});
}
if (msg.IsType <SteamClient.DisconnectCallback>())
{
loggedIn = false;
}
if (msg.IsType <SteamUser.LogOnCallback>())
{
SteamUser.LogOnCallback callback = (SteamUser.LogOnCallback)msg;
if (callback.Result == EResult.OK)
{
this.loggedIn = true;
this.authcode = null;
}
Friends.SetPersonaState(EPersonaState.Online);
}
Push(msg);
}
}
public void HandleCallback(CallbackMsg msg)
{
if (msg.IsType <SteamFriends.PersonaStateCallback>())
{
var perState = (SteamFriends.PersonaStateCallback)msg;
if (this.Friend == null)
{
return;
}
if (perState.FriendID != this.Friend.SteamID)
{
return;
}
this.UpdateFriend(this.Friend);
}
}
void HandleFriendMessage(CallbackMsg msg)
{
var details = msg as SteamFriends.FriendMsgCallback;
if (details.EntryType != EChatEntryType.ChatMsg)
{
return;
}
string name = SteamFriends.GetFriendPersonaName(details.Sender);
string log = String.Format("{0} says: {1}", name, details.Message);
Logger.WriteLine(log);
HandleCommand(details.Message, details.Sender, (sender, entry, text) =>
{
SteamFriends.SendChatMessage(sender, entry, text);
});
}
void HandleTradeRequest(CallbackMsg msg)
{
var details = msg as SteamTrading.TradeRequestCallback;
string name = SteamFriends.GetFriendPersonaName(details.Other);
string log = String.Format("Trade request to {0} status: {1}",
name, details.Status.ToString());
Logger.WriteLine(log);
ResetPendingTrade();
if (details.Status != EEconTradeResponse.Accepted)
{
return;
}
CurrentTrade = details.Trade;
CurrentTrade.Initialize();
}
