daily pastebin goal
52%
SHARE
TWEET

Source

a guest Dec 29th, 2016 97 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using SteamKit2;
  7. using System.IO;
  8. using System.Threading;
  9.  
  10. namespace _1703_Bot
  11. {
  12.     class Program
  13.     {
  14.         static bool is_running = false;
  15.         static string user_name, pass;
  16.         static string auth_code;
  17.  
  18.         static SteamClient steam_client;
  19.         static CallbackManager callback_manager;
  20.         static SteamUser steam_user;
  21.         static SteamFriends steam_friends;
  22.  
  23.         static void Main(string[] args)
  24.         {
  25.             if (!File.Exists("chat.txt"))
  26.             {
  27.                 File.Create("chat.txt").Close();
  28.                 File.WriteAllText("chat.txt", "Hello | <MSG> Hello. Use '!help' to view commands.");
  29.             }
  30.             if (!File.Exists("admin.txt"))
  31.             {
  32.                 File.Create("admin.txt").Close();
  33.                 File.WriteAllText("admin.txt", "76561198053054477");
  34.             }
  35.  
  36.             Console.Title = "1703 Bot Console";
  37.             Console.Write("Username: ");
  38.             user_name = Console.ReadLine();
  39.             Console.Write("Password: ");
  40.             pass = Console.ReadLine();
  41.  
  42.             SteamLogIn();
  43.         }
  44.  
  45.         static void SteamLogIn()
  46.         {
  47.             steam_client = new SteamClient();
  48.             callback_manager = new CallbackManager(steam_client);
  49.             steam_user = steam_client.GetHandler<SteamUser>();
  50.             steam_friends = steam_client.GetHandler<SteamFriends>();
  51.  
  52.             callback_manager.Subscribe<SteamClient.ConnectedCallback>(OnConnected);
  53.             callback_manager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected);
  54.             callback_manager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn);
  55.             callback_manager.Subscribe<SteamUser.LoggedOffCallback>(OnLoggedOff);
  56.             callback_manager.Subscribe<SteamUser.AccountInfoCallback>(OnAccountInfo);
  57.             callback_manager.Subscribe<SteamFriends.FriendMsgCallback>(OnChatMessage);
  58.             callback_manager.Subscribe<SteamFriends.FriendsListCallback>(OnFriendsList);
  59.             callback_manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
  60.  
  61.             is_running = true;
  62.  
  63.             Console.Write("Connecting to Steam...");
  64.             steam_client.Connect();
  65.  
  66.             while (is_running)
  67.             {
  68.                 callback_manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
  69.             }
  70.             Console.ReadKey();
  71.         }
  72.  
  73.         static void OnConnected(SteamClient.ConnectedCallback callback)
  74.         {
  75.             if (callback.Result != EResult.OK)
  76.             {
  77.                 Console.WriteLine("Unable to connect to Steam: {0}", callback.Result);
  78.                 is_running = false;
  79.                 return;
  80.             }
  81.             Console.WriteLine("Connected to Steam! Logging in '{0}'", callback.Result);
  82.  
  83.             byte[] sentry_hash = null;
  84.             if (File.Exists("sentry.bin"))
  85.             {
  86.                 byte[] sentry_file = File.ReadAllBytes("sentry.bin");
  87.                 sentry_hash = CryptoHelper.SHAHash(sentry_file);
  88.             }
  89.  
  90.             steam_user.LogOn(new SteamUser.LogOnDetails
  91.             {
  92.                 Username = user_name,
  93.                 Password = pass,
  94.                 AuthCode = auth_code,
  95.                 SentryFileHash = sentry_hash,
  96.             });
  97.         }
  98.  
  99.         static void OnLoggedOn(SteamUser.LoggedOnCallback callback)
  100.         {
  101.             if (callback.Result == EResult.AccountLogonDenied)
  102.             {
  103.                 Console.WriteLine("This account is SteamGuard protected.");
  104.                 Console.WriteLine("Please enter the authorization code sent ot the email at {0}: ", callback.EmailDomain);
  105.                 auth_code = Console.ReadLine();
  106.                 return;
  107.             }
  108.  
  109.             if (callback.Result != EResult.OK)
  110.             {
  111.                 Console.WriteLine("Unable to log in to Steam: {0}\n", callback.Result);
  112.                 is_running = false;
  113.                 return;
  114.             }
  115.             Console.WriteLine("{0} Successfully Logged in to Steam!", user_name);
  116.         }
  117.  
  118.         static void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback)
  119.         {
  120.             Console.WriteLine("Updating Sentryfile...");
  121.             byte[] sentry_hash = CryptoHelper.SHAHash(callback.Data);
  122.             File.WriteAllBytes("sentry.bin", callback.Data);
  123.             steam_user.SendMachineAuthResponse(new SteamUser.MachineAuthDetails
  124.             {
  125.                 JobID = callback.JobID,
  126.                 FileName = callback.FileName,
  127.                 BytesWritten = callback.BytesToWrite,
  128.                 FileSize = callback.Data.Length,
  129.                 Offset = callback.Offset,
  130.                 Result = EResult.OK,
  131.                 LastError = 0,
  132.                 OneTimePassword = callback.OneTimePassword,
  133.                 SentryFileHash = sentry_hash,
  134.             });
  135.             Console.WriteLine("Done!");
  136.         }
  137.  
  138.         static void OnDisconnected(SteamClient.DisconnectedCallback callback)
  139.         {
  140.             Console.WriteLine("\n{0} Disconnected from Steam, reconnecting...\n", user_name);
  141.             Thread.Sleep(TimeSpan.FromSeconds(5));
  142.             steam_client.Connect();
  143.         }
  144.  
  145.         static void OnLoggedOff(SteamUser.LoggedOffCallback callback)
  146.         {
  147.             Console.WriteLine("Logged off of Steam: {0}", callback.Result);
  148.         }
  149.  
  150.         static void OnAccountInfo(SteamUser.AccountInfoCallback callback)
  151.         {
  152.             steam_friends.SetPersonaState(EPersonaState.Online);
  153.         }
  154.  
  155.         static void OnFriendsList(SteamFriends.FriendsListCallback callback)
  156.         {
  157.             Thread.Sleep(2500);
  158.             foreach (var friend in callback.FriendList)
  159.             {
  160.                 if (friend.Relationship == EFriendRelationship.RequestRecipient)
  161.                 {
  162.                     steam_friends.AddFriend(friend.SteamID);
  163.                     Thread.Sleep(500);
  164.                     steam_friends.SendChatMessage(friend.SteamID, EChatEntryType.ChatMsg, "<MSG> hello, I am 1703 bot. I will notify you of any 1703 outfit events. Use '!help' to view my commands.");
  165.                 }
  166.             }
  167.         }
  168.  
  169.         static void OnChatMessage(SteamFriends.FriendMsgCallback callback)
  170.         {
  171.             string[] args;
  172.             if (callback.EntryType == EChatEntryType.ChatMsg)
  173.             {
  174.                 if (callback.Message.Length > 1)
  175.                 {
  176.                     if (callback.Message.Remove(1) == "!")
  177.                     {
  178.                         string command = callback.Message;
  179.  
  180.                         if (callback.Message.Contains(" "))
  181.                         {
  182.                             command = callback.Message.Remove(callback.Message.IndexOf(' '));
  183.                         }
  184.  
  185.                         switch (command)
  186.                         {
  187.                             #region send
  188.                             case "!send":
  189.                                 if (!isBotAdmin(callback.Sender))
  190.                                     break;
  191.  
  192.                                 args = seperate(2, ' ', callback.Message);
  193.                                 Console.WriteLine("!send '" + args[1] + "' '" + args[2] + "'Command Recieved: User: " + steam_friends.GetFriendPersonaName(callback.Sender));
  194.                                 if (args[0] == "-1")
  195.                                 {
  196.                                     steam_friends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "<ERROR> Incorrect Syntax. Use '!send [friend] [message]'.");
  197.                                     return;
  198.                                 }
  199.                                 for (int i = 0; i < steam_friends.GetFriendCount(); i++)
  200.                                 {
  201.                                     SteamID friend = steam_friends.GetFriendByIndex(i);
  202.                                     if (steam_friends.GetFriendPersonaName(friend).ToLower().Contains(args[1].ToLower()))
  203.                                     {
  204.                                         steam_friends.SendChatMessage(friend, EChatEntryType.ChatMsg, "<MSG> " + args[2]);
  205.                                     }
  206.                                 }
  207.                                 break;
  208.                             #endregion
  209.                             #region broadcast
  210.                             case "!broadcast":
  211.                                 if (!isBotAdmin(callback.Sender))
  212.                                     break;
  213.  
  214.                                 args = seperate(1, ' ', callback.Message);
  215.                                 Console.WriteLine("!broadcast '" + args[1] + "' Command Recieved: User: " + steam_friends.GetFriendPersonaName(callback.Sender));
  216.                                 if (args[0] == "-1")
  217.                                 {
  218.                                     steam_friends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "<ERROR> Inccorect syntax. Use '!broadcast [message]'.");
  219.                                 }
  220.                                 for (int i = 0; i < steam_friends.GetFriendCount(); i++)
  221.                                 {
  222.                                     SteamID friend = steam_friends.GetFriendByIndex(i);
  223.                                     if (friend > 0)
  224.                                     {
  225.                                         steam_friends.SendChatMessage(friend, EChatEntryType.ChatMsg, "<BROADCAST> " + args[1]);
  226.                                     }
  227.                                 }
  228.                                 break;
  229.                             #endregion
  230.                             #region friends
  231.                             case "!friends":
  232.                                 Console.WriteLine("!friends Command Recieved: User: " + steam_friends.GetFriendPersonaName(callback.Sender));
  233.                                 steam_friends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "<INFO> List of bot friends: ");
  234.                                 for (int i = 0; i < steam_friends.GetFriendCount(); i++)
  235.                                 {
  236.                                     SteamID friend = steam_friends.GetFriendByIndex(i);
  237.                                     steam_friends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "<INFO> Friend: " + steam_friends.GetFriendPersonaName(friend) + " State: " + steam_friends.GetFriendPersonaState(friend));
  238.                                 }
  239.                                 break;
  240.                             #endregion
  241.                             #region help
  242.                             case "!help":
  243.                                 Console.Write("!help Command Recieved: User: " + steam_friends.GetFriendPersonaName(callback.Sender));
  244.                                 steam_friends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "<INFO> List of User Commands:");
  245.                                 steam_friends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "<INFO> '!help' : Lists all Available Commands");
  246.                                 steam_friends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "<INFO> '!friends' : Lists all the friends of the 1703 Bot");
  247.                                 steam_friends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "<INFO> List of Admin Commands:");
  248.                                 steam_friends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "<INFO> '!broadcast [message]' : Broadcasts a message to all 1703 Bot Friends");
  249.                                 steam_friends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "<INFO> '!send [friend] [message]' : sends a message to specified 1703 Bot Friend");
  250.                                 steam_friends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "<INFO> '!pester [friend] [message] [message ammount]' : sends a message to a specified 1703 Bot Friend a specified number of times");
  251.                                 break;
  252.                             #endregion
  253.                             #region pester
  254.                             case "!pester":
  255.                                 int counter = 0;
  256.                                 if (!isBotAdmin(callback.Sender))
  257.                                     break;
  258.                                 args = seperate(3, ' ', callback.Message);
  259.                                 Console.WriteLine("!pester '" + args[1] + "' '" + args[2] + "'Command Recieved: User: " + steam_friends.GetFriendPersonaName(callback.Sender));
  260.                                 if (args[0] == "-1")
  261.                                 {
  262.                                     steam_friends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "<ERROR> Incorrect Syntax. Use '!pester [friend] [message'.");
  263.                                     return;
  264.                                 }
  265.                                 for (int i = 0; i < steam_friends.GetFriendCount(); i++)
  266.                                 {
  267.                                     SteamID friend = steam_friends.GetFriendByIndex(i);
  268.                                     if (steam_friends.GetFriendPersonaName(friend).ToLower().Contains(args[1].ToLower()))
  269.                                     {
  270.                                         while (counter < int.Parse(args[3]))
  271.                                         {
  272.                                             steam_friends.SendChatMessage(friend, EChatEntryType.ChatMsg, "<MSG> " + args[2]);
  273.                                             counter++;
  274.                                         }
  275.                                     }
  276.                                 }
  277.                                 break;
  278.                             #endregion
  279.                         }
  280.                     }
  281.                 }
  282.                 string rLine;
  283.                 string trimmed = callback.Message;
  284.                 char[] trim = { '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '-', '_', '=', '+', '[', ']', '{', '}', '\\', '|', ';', ':', '"', '\'', ',', '<', '.', '>', '/', '?' };
  285.                 for (int i = 0; i < 30; i++)
  286.                 {
  287.                     trimmed = trimmed.Replace(trim[i].ToString(), "");
  288.                 }
  289.  
  290.                 StreamReader stream_reader = new StreamReader("chat.txt");
  291.  
  292.                 while ((rLine = stream_reader.ReadLine()) != null)
  293.                 {
  294.                     string text = rLine.Remove(rLine.IndexOf('|') - 1);
  295.                     string response = rLine.Remove(0, rLine.IndexOf('|') + 2);
  296.  
  297.                     if (callback.Message.Contains(text))
  298.                     {
  299.                         Console.WriteLine("Cat reply Sent: User: " + steam_friends.GetFriendPersonaName(callback.Sender));
  300.                         steam_friends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, response);
  301.                         stream_reader.Close();
  302.                         return;
  303.                     }
  304.                 }
  305.             }
  306.         }
  307.  
  308.         public static bool isBotAdmin(SteamID sid)
  309.         {
  310.             string[] lines = null;
  311.             try
  312.             {
  313.                 lines = File.ReadAllLines("admin.txt");
  314.                 foreach (string i in lines)
  315.                 {
  316.                     if (sid.ConvertToUInt64() == Convert.ToUInt64(i))
  317.                     {
  318.                         return true;
  319.                     }
  320.                 }
  321.                 steam_friends.SendChatMessage(sid, EChatEntryType.ChatMsg, "<ERROR> You do not have sufficient permission to use that command. If this is an error, and you are an admin, please contact D3i (Dei) or Infilze (Koolbade)");
  322.                 Console.WriteLine(steam_friends.GetFriendPersonaName(sid) + " attemted to use an administrator command while not an administrator.");
  323.                 return false;
  324.             }
  325.  
  326.                 catch (Exception e)
  327.             {
  328.                 Console.WriteLine(e.Message);
  329.                 return false;
  330.             }
  331.         }
  332.  
  333.         public static string[] seperate(int number, char seperator, string thestring)
  334.         {
  335.             string[] returned = new string[4];
  336.             int i = 0;
  337.             int error = 0;
  338.             int length = thestring.Length;
  339.  
  340.             foreach (char c in thestring)
  341.             {
  342.                 if (i != number)
  343.                 {
  344.                     if (error > length || number > 5)
  345.                     {
  346.                         returned[0] = "-1";
  347.                         return returned;
  348.                     }
  349.                     else if (c == seperator)
  350.                     {
  351.                         returned[i] = thestring.Remove(thestring.IndexOf(c));
  352.                         thestring = thestring.Remove(0, thestring.IndexOf(c) + 1);
  353.                         i++;
  354.                     }
  355.                     error++;
  356.                     if (error == length && i != number)
  357.                     {
  358.                         returned[0] = "-1";
  359.                         return returned;
  360.                     }
  361.                 }
  362.                 else
  363.                 {
  364.                     returned[i] = thestring;
  365.                 }
  366.             }
  367.             return returned;
  368.         }
  369.     }
  370. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top