Steam Bot Template

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using SteamKit2;

namespace BotTemplate
{
    public class Program
    {
        private static string _authCode;

        public static SteamClient SteamClient;
        public static CallbackManager Manager;
        public static SteamUser SteamUser;
        public static SteamFriends SteamFriends;

        private static bool _isRunning;

        private static string _twoFactorCode;

        private static string _user;
        private static string _pass;

        private static void Main()
        {
            Console.Write("Please enter bot username: ");
            _user = Console.ReadLine();

            Console.Write("Please enter bot password: ");
            _pass = Console.ReadLine();

            SteamClient = new SteamClient();
            Manager = new CallbackManager(SteamClient);
            SteamUser = SteamClient.GetHandler<SteamUser>();
            SteamFriends = SteamClient.GetHandler<SteamFriends>();

            Manager.Subscribe<SteamClient.ConnectedCallback>(OnConnected);
            Manager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn);
            Manager.Subscribe<SteamUser.LoggedOffCallback>(OnLoggedOff);
            Manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
            Manager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected);
            Manager.Subscribe<SteamUser.AccountInfoCallback>(OnAccountInfo);
            Manager.Subscribe<SteamFriends.FriendMsgCallback>(OnChatMessage);
            Manager.Subscribe<SteamFriends.FriendsListCallback>(OnFriendsList);

            _isRunning = true;
            Console.WriteLine("Attempting client connection...");
            SteamClient.Connect();

            while (_isRunning)
            {
                Manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
            }
            Console.ReadKey();
        }


        private static void OnConnected(SteamClient.ConnectedCallback callback)
        {
            if (callback.Result != EResult.OK)
            {
                Console.WriteLine("Unable to connect to Steam: " + callback.Result);
                _isRunning = false;
                return;
            }

            Console.WriteLine("Client connection was successful!");
            Console.WriteLine("Logging into \"" + _user + "\"...");

            byte[] sentryHash = null;
            if (File.Exists("sentry.bin"))
            {
                byte[] sentryFile = File.ReadAllBytes("sentry.bin");
                sentryHash = CryptoHelper.SHAHash(sentryFile);
            }

            SteamUser.LogOn(new SteamUser.LogOnDetails
            {
                Username = _user,
                Password = _pass,
                AuthCode = _authCode,
                TwoFactorCode = _twoFactorCode,
                SentryFileHash = sentryHash
            });

        }

        private static void OnDisconnected(SteamClient.DisconnectedCallback callback)
        {
            Console.WriteLine(_user + " disconnected from Steam, reconnecting in 1 second...");
            Thread.Sleep(TimeSpan.FromSeconds(1));
            SteamClient.Connect();
        }

        private static void OnLoggedOn(SteamUser.LoggedOnCallback callback)
        {
            bool isSteamGuard = callback.Result == EResult.AccountLogonDenied;
            bool is2Fa = callback.Result == EResult.AccountLoginDeniedNeedTwoFactor;

            if (isSteamGuard || is2Fa)
            {
                if (is2Fa)
                {
                    Console.Write("Please enter 2FA code: ");
                    _twoFactorCode = Console.ReadLine();
                }
                else
                {
                    Console.Write("Please enter the auth code sent to the email at {0}: ", callback.EmailDomain);
                    _authCode = Console.ReadLine();
                }
                return;
            }

            if (callback.Result != EResult.OK)
            {
                Console.WriteLine("Unable to log in to Steam: " + callback.Result + " / " + callback.ExtendedResult);

                if (callback.Result != EResult.ServiceUnavailable)
                    _isRunning = false;

                return;
            }

            Console.WriteLine(_user + " successfully logged in!");
        }

        private static void OnLoggedOff(SteamUser.LoggedOffCallback callback)
        {
            Console.WriteLine("Logged off of Steam: " + callback.Result);
        }

        private static void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback)
        {
            Console.WriteLine("Updating sentry file...");
            byte[] sentryHash = CryptoHelper.SHAHash(callback.Data);
            File.WriteAllBytes("sentry.bin", callback.Data);

            SteamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails
            {
                JobID = callback.JobID,
                FileName = callback.FileName,
                BytesWritten = callback.BytesToWrite,
                FileSize = callback.Data.Length,
                Offset = callback.Offset,
                Result = EResult.OK,
                LastError = 0,
                OneTimePassword = callback.OneTimePassword,
                SentryFileHash = sentryHash
            });

            Console.WriteLine("Update successful!");
        }

        private static void OnAccountInfo(SteamUser.AccountInfoCallback callback)
        {
            SteamFriends.SetPersonaState(EPersonaState.Online);
            SteamFriends.SetPersonaName("Nanobot ᴮᴱᵀᴬ");
        }

        private static void OnFriendsList(SteamFriends.FriendsListCallback callback)
        {
            foreach (
                var friend in
                    callback.FriendList.Where(friend => friend.Relationship == EFriendRelationship.RequestRecipient)
                        .TakeWhile(friend => !friend.SteamID.IsClanAccount))
            {
                SteamFriends.AddFriend(friend.SteamID);
                Console.WriteLine("Accepted " + SteamFriends.GetFriendPersonaName(friend.SteamID) + "'s friend request.");
                Thread.Sleep(500);
            }
        }

        private static void OnChatMessage(SteamFriends.FriendMsgCallback callback)
        {
            if (callback.EntryType != EChatEntryType.ChatMsg) return;

            if (callback.Message.Length <= 1 || callback.Message.Remove(1) != "!")
            {
                SendMsg(callback.Sender, "This is where I respond to chat messages!");
                return;
            }

            string commandstring = callback.Message.Remove(0, 1);
            List<string> args = Seperate(commandstring);
            Console.Write(callback.Sender + " attempted to use command:");
            foreach (string s in args)
            {
                Console.Write(" " + s);
            }
        }

        public static List<string> Seperate(string toSeperate)
        {
            var toReturn = new List<string>();
            var builder = new StringBuilder();
            bool inQuotes = false;
            bool skipCharacter = false;
            //command abc 123 "come with me"

            foreach (char t in toSeperate)
            {
                if (skipCharacter)
                {
                    skipCharacter = false;
                    continue;
                }

                if (t == '\"')
                {
                    inQuotes = !inQuotes;
                    if (inQuotes == false)
                    {
                        skipCharacter = true;
                        toReturn.Add(builder.ToString());
                        builder.Clear();
                    }
                    continue;
                }

                if (t == ' ' && !inQuotes)
                {
                    toReturn.Add(builder.ToString());
                    builder.Clear();
                    continue;
                }

                builder.Append(t);
            }
            if (builder.Length > 0) toReturn.Add(builder.ToString());
            return toReturn;
        }

        public static string GetName(SteamID steamid)
        {
            return SteamFriends.GetFriendPersonaName(steamid);
        }

        public static EPersonaState GetState(SteamID steamid)
        {
            return SteamFriends.GetFriendPersonaState(steamid);
        }

        public static void SendMsg(SteamID user, string msg)
        {
            SteamFriends.SendChatMessage(user, EChatEntryType.ChatMsg, msg);
        }
    }
}