SHARE
TWEET

Everybody Edits - Dig bot

capasha Apr 12th, 2017 177 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 PlayerIOClient;
  7. namespace digbotpro
  8. {
  9.     class Program
  10.     {
  11.         public static uint[,,] roomData = new uint[2, 3000, 3000]; //The worlds blocks
  12.         public static int width = 1;
  13.         public static int height = 1;
  14.         public static Dictionary<int, picks> pickAxes = new Dictionary<int, picks>(); //Add pickaxes and how many taps to dig
  15.         public static Dictionary<int, PlayerData> players = new Dictionary<int, PlayerData>(); //Store player data
  16.         public static Dictionary<int, System.Threading.Timer> checkAfk = new Dictionary<int, System.Threading.Timer>(); //Timer for checking if a user is afk or not
  17.         public static int cantMineLowerThanThisPositionY = 21; //How much space between the digging part
  18.         public static int replaceDiggedBlockWithID = 4; //Replace the digged block with x
  19.         public static Connection con1;
  20.         static void Main(string[] args)
  21.         {
  22.             pickAxes.Add(16, new picks() { totalTaps = 2 }); //Brick brown
  23.             pickAxes.Add(20, new picks() { totalTaps = 3 }); //Brick red
  24.             PlayerIO.QuickConnect.SimpleConnect("everybody-edits-su9rn58o40itdbnw69plyw", "capashaa@gmail.com", "01234567890", null,
  25.                 delegate (Client client)
  26.                 {
  27.                     Console.WriteLine("Login: Logged in");
  28.                     client.Multiplayer.CreateJoinRoom("PWqZEmXsNEcEI", "Everybodyedits" + client.BigDB.Load("config", "config")["version"], false, null, null,
  29.                         delegate (Connection con)
  30.                         {
  31.                             con1 = con;
  32.                             con.Send("init");
  33.                             con.OnMessage += delegate (object sender, PlayerIOClient.Message m)
  34.                             {
  35.                                 switch (m.Type)
  36.                                 {
  37.  
  38.                                     case "init":
  39.                                         width = m.GetInt(18);
  40.                                         height = m.GetInt(19);
  41.                                         roomData = new uint[2, m.GetInt(18), m.GetInt(19)];
  42.                                         var chunks = InitParse.Parse(m);
  43.                                         foreach (var chunk in chunks)
  44.                                             foreach (var pos in chunk.Locations)
  45.                                                 roomData[chunk.Layer, pos.X, pos.Y] = chunk.Type;
  46.  
  47.                                         con.Send("init2");
  48.                                         break;
  49.                                     case "init2":
  50.                                         Console.WriteLine("Connection: Connected");
  51.                                         break;
  52.                                     case "add":
  53.                                         if (!players.ContainsKey(m.GetInt(0)))
  54.                                         {
  55.                                             players.Add(m.GetInt(0),
  56.                                                 new PlayerData() {
  57.                                                     nick = m.GetString(1), //the players nickname
  58.                                                     afkTime = DateTime.Now, //The time since the user joined
  59.                                                     movementX = Convert.ToInt32(m.GetDouble(4)), //The users movement X
  60.                                                     movementY = Convert.ToInt32(m.GetDouble(5)), //The users movement Y
  61.                                                     blockDigging = DateTime.Now, //Detect if the user dig too fast
  62.                                                     totalMoveMents = 0, //Detect how many movements a user can send
  63.                                                     canDig = true, //Enable/Disable the digging for people
  64.                                                     taps = 0, //How many taps a user need to tap
  65.                                                     pickAxe = new Dictionary<int, bool>() { { 16, true }, { 20, true } } //Pickaxes for each block
  66.                                                 });
  67.                                             checkAfk[m.GetInt(0)] = new System.Threading.Timer(delegate { isUserAfk(m.GetInt(0), m.GetString(1)); }, null,1000,1000); //Check if the user is afk
  68.                                         }
  69.                                         break;
  70.                                     case "m":
  71.                                         if (players.ContainsKey(m.GetInt(0)))
  72.                                         {
  73.                                             int x = 0, y = 0, xx = 0, yy = 0;
  74.                                             if (m.GetInt(7) == 1) x++;
  75.                                             if (m.GetInt(7) == -1) x--;
  76.                                             if (m.GetInt(8) == 1) y++;
  77.                                             if (m.GetInt(8) == -1) y--;
  78.                                             xx = (int)((double)m.GetDouble(1)) / 16 + x;
  79.                                             yy = (int)((double)m.GetDouble(2)) / 16 + y;
  80.                                             players[m.GetInt(0)].afkTime = DateTime.Now;
  81.                                             players[m.GetInt(0)].afk = false;
  82.                                             players[m.GetInt(0)].movementX = xx;
  83.                                             players[m.GetInt(0)].movementY = yy;
  84.                                            
  85.                                             if (players[m.GetInt(0)].totalMoveMents >= 50)
  86.                                             {
  87.                                                 Console.WriteLine(players[m.GetInt(0)].nick + " Sending too many movements");
  88.                                             }
  89.                                             if (players[m.GetInt(0)].totalMoveMents < 50)
  90.                                             {
  91.                                                 if (players[m.GetInt(0)].movementX == Convert.ToInt32(((double)m.GetDouble(1) / 16)) && players[m.GetInt(0)].movementY == Convert.ToInt32(((double)m.GetDouble(2) / 16)))
  92.                                                 {
  93.                                                     players[m.GetInt(0)].totalMoveMents += 1;
  94.                                                 }
  95.                                             }
  96.                                             /* If movement xx is lower than width
  97.                                              * If movement yy is lower than height
  98.                                              * If movement yy is higher or equal to the digging space
  99.                                              * If the player can dig
  100.                                              */
  101.                                             if (xx < width && yy < height && yy >= cantMineLowerThanThisPositionY && players[m.GetInt(0)].canDig)
  102.                                             {
  103.                                                 //If pickaxes contains the block id
  104.                                                 if (pickAxes.ContainsKey((int)roomData[0, xx, yy]))
  105.                                                 {
  106.                                                     //If player have used x taps as the pickaxe
  107.                                                     if (players[m.GetInt(0)].taps == pickAxes[(int)roomData[0, xx, yy]].totalTaps)
  108.                                                     {
  109.                                                         //If user have the pickaxe and it's enabled
  110.                                                         if (players[m.GetInt(0)].pickAxe.ContainsKey((int)roomData[0, xx, yy]) && players[m.GetInt(0)].pickAxe[(int)roomData[0, xx, yy]]) {
  111.                                                             players[m.GetInt(0)].blockDigging = DateTime.Now;
  112.                                                             players[m.GetInt(0)].taps = 1;
  113.                                                             con1.Send("b", 0, xx, yy, replaceDiggedBlockWithID);
  114.                                                         }
  115.                                                     }
  116.                                                     else if (players[m.GetInt(0)].taps < pickAxes[(int)roomData[0, xx, yy]].totalTaps)
  117.                                                     {
  118.                                                         players[m.GetInt(0)].taps += 1;
  119.                                                     }
  120.                                                 }
  121.                                             }
  122.                                         }
  123.  
  124.                                         break;
  125.  
  126.                                     case "b":
  127.                                         roomData[0, m.GetInt(1), m.GetInt(2)] = (uint)m.GetInt(3);
  128.                                         foreach(var value in players)
  129.                                         {
  130.                                             if (players[value.Key].movementX == m.GetInt(1) && players[value.Key].movementY == m.GetInt(2))
  131.                                             {
  132.                                                 TimeSpan ts = DateTime.Now - players[value.Key].blockDigging;
  133.                                                 if (ts.Milliseconds < 116)
  134.                                                 {
  135.                                                    
  136.                                                     if (players[value.Key].digWarnings <= 30)
  137.                                                     {
  138.                                                         players[value.Key].digWarnings += 1;
  139.                                                         if (players[value.Key].digWarnings == 30) players[value.Key].canDig = false;
  140.                                                     }
  141.                                                 }
  142.                                                 Console.WriteLine("Nick: " + players[value.Key].nick + " Time: " + ts.Milliseconds);
  143.                                             }
  144.                                         }
  145.                                         break;
  146.                                     case "reset":
  147.                                         var chunks1 = InitParse.Parse(m);
  148.                                         foreach (var chunk in chunks1)
  149.                                             foreach (var pos in chunk.Locations)
  150.                                                 roomData[chunk.Layer, pos.X, pos.Y] = chunk.Type;
  151.                                         break;
  152.                                     case "left":
  153.                                         if (players.ContainsKey(m.GetInt(0)))
  154.                                         {
  155.                                             checkAfk[m.GetInt(0)].Dispose();
  156.                                             players.Remove(m.GetInt(0));
  157.                                         }
  158.                                         break;
  159.                                 }
  160.                             };
  161.                             con.OnDisconnect += delegate (object sender, string reason)
  162.                             {
  163.                                 Console.WriteLine("Disconnected");
  164.                             };
  165.                         },
  166.                         delegate (PlayerIOError error)
  167.                         {
  168.                             Console.WriteLine("Connection: " + error.Message);
  169.                         });
  170.                 },
  171.                 delegate (PlayerIOError error)
  172.                 {
  173.                     Console.WriteLine("Login: " + error.Message);
  174.                 });
  175.             Console.ReadKey();
  176.         }
  177.  
  178.         public static void isUserAfk(int id,string name)
  179.         {
  180.             if (players.ContainsKey(id))
  181.             {
  182.                 TimeSpan diff = DateTime.Now - players[id].afkTime;
  183.                 if (!players[id].afk)
  184.                 {
  185.                     if (diff.Seconds >= 10)
  186.                     {
  187.                         players[id].afk = true;
  188.                         //con1.Send("say", "/pm " + name + " [DigBotPro] You are now automatic afk");
  189.                     }
  190.                 }
  191.             }
  192.         }
  193.         public static class InitParse
  194.         {
  195.             public static DataChunk[] Parse(Message m)
  196.             {
  197.                 if (m == null) throw new ArgumentNullException("m");
  198.                 if (m.Type != "init" && m.Type != "reset") throw new ArgumentException("Invalid message type.", "m");
  199.  
  200.                 // Get world data
  201.                 var p = 0u;
  202.                 var data = new Stack<object>();
  203.                 while (m[p++] as string != "ws") { }
  204.                 while (m[p] as string != "we") { data.Push(m[p++]); }
  205.  
  206.                 // Parse world data
  207.                 var chunks = new List<DataChunk>();
  208.                 while (data.Count > 0)
  209.                 {
  210.                     var args = new Stack<object>();
  211.                     while (!(data.Peek() is byte[]))
  212.                         args.Push(data.Pop());
  213.  
  214.                     var ys = (byte[])data.Pop();
  215.                     var xs = (byte[])data.Pop();
  216.                     var layer = (int)data.Pop();
  217.                     var type = (uint)data.Pop();
  218.  
  219.                     chunks.Add(new DataChunk(layer, type, xs, ys, args.ToArray()));
  220.                 }
  221.  
  222.                 return chunks.ToArray();
  223.             }
  224.         }
  225.  
  226.         public class DataChunk
  227.         {
  228.             public int Layer { get; set; }
  229.             public uint Type { get; set; }
  230.             public Point[] Locations { get; set; }
  231.             public object[] Args { get; set; }
  232.  
  233.             public DataChunk(int layer, uint type, byte[] xs, byte[] ys, object[] args)
  234.             {
  235.                 this.Layer = layer;
  236.                 this.Type = type;
  237.                 this.Args = args;
  238.                 this.Locations = GetLocations(xs, ys);
  239.             }
  240.  
  241.             private static Point[] GetLocations(byte[] xs, byte[] ys)
  242.             {
  243.                 var points = new List<Point>();
  244.                 for (var i = 0; i < xs.Length; i += 2)
  245.                     points.Add(new Point(
  246.                         (xs[i] << 8) | xs[i + 1],
  247.                         (ys[i] << 8) | ys[i + 1]));
  248.                 return points.ToArray();
  249.             }
  250.         }
  251.  
  252.         public struct Point
  253.         {
  254.             public int X { get; set; }
  255.             public int Y { get; set; }
  256.  
  257.             public Point(int x, int y) : this()
  258.             {
  259.                 this.X = x;
  260.                 this.Y = y;
  261.             }
  262.         }
  263.         public class PlayerData
  264.         {
  265.             public string nick { get; set; }
  266.             public DateTime afkTime { get; set; }
  267.             public bool afk { get; set; }
  268.             public int totalMoveMents { get; set; }
  269.             public int movementX { get; set; }
  270.             public int movementY { get; set; }
  271.             public DateTime blockDigging { get; set; }
  272.             public bool canDig { get; set; }
  273.             public int digWarnings { get; set; }
  274.             public int taps { get; set; }
  275.             public Dictionary<int,bool> pickAxe { get; set; }
  276.         }
  277.         public class picks
  278.         {
  279.             public int totalTaps { get; set; }
  280.         }
  281.     }
  282. }
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