Esempio n. 1
0
        public static void Start()
        {
            while (true)
            {
                Thread.Sleep(50);

                if (!Properties.Settings.Default.doorspammer)
                {
                    continue;
                }
                if (!LocalPlayer.InGame)
                {
                    continue;
                }
                if (LocalPlayer.Health <= 0)
                {
                    continue;
                }

                while ((DllImport.GetAsyncKeyState(Properties.Hotkey.Default.doorspammerKey) & 0x8000) != 0)
                {
                    ClientCMD.Exec("+use");  // I did not add this to LocalPlayer to avoid delay. But i dont try, maybe this will not happen lol
                    Thread.Sleep(15);
                    ClientCMD.Exec("-use");
                    Thread.Sleep(15);
                }
            }
        }
Esempio n. 2
0
        public static void Start() //disabled
        {
            while (true)
            {
                Thread.Sleep(1);

                if (!Properties.Settings.Default.runboostbot)
                {
                    continue;
                }

                if (!LocalPlayer.InGame)
                {
                    continue;
                }

                if (LocalPlayer.Health <= 0)
                {
                    continue;
                }

                if (LocalPlayer.Dormant)
                {
                    continue;
                }

                Entity target = null;

                while ((DllImport.GetAsyncKeyState(Properties.Hotkey.Default.runboostbotKey) & 0x8000) != 0)
                {
                    Thread.Sleep(1);

                    if (target == null)
                    {
                        target = Aimbot.BestDistance();
                    }

                    boosting = true;

                    Vector3 position = target.Position;

                    if (target.Speed <= 0)
                    {
                        LocalPlayer.MoveClearX();
                    }
                    else
                    {
                        LocalPlayer.ViewAngleY = Aimbot.NormalizedAngle(Aimbot.CalcAngle(LocalPlayer.ViewPosition, position)).y;

                        LocalPlayer.MoveForward();
                    }
                }

                if (boosting)
                {
                    LocalPlayer.MoveClearX();
                    boosting = false;
                }
            }
        }
Esempio n. 3
0
 public void Free()
 {
     foreach (var key in AllocatedSize)
     {
         DllImport.VirtualFreeEx(Memory.pHandle, key.Key, 4096, (int)0x1000 | (int)0x2000);
     }
 }
Esempio n. 4
0
        public static void Start()
        {
            while (true)
            {
                Thread.Sleep(1);

                if (!Properties.Settings.Default.bhop)
                {
                    continue;
                }
                if (!LocalPlayer.InGame)
                {
                    continue;
                }
                if (LocalPlayer.Health <= 0)
                {
                    continue;
                }
                if (LocalPlayer.Speed <= 0)
                {
                    continue;
                }

                Vector3 oldAngle = LocalPlayer.ViewAngle;

                while ((DllImport.GetAsyncKeyState(0x20) & 0x8000) != 0)
                {
                    Thread.Sleep(1);

                    if (Properties.Settings.Default.autostrafe)
                    {
                        strafe = true;
                        Vector3 cuurentAngle = LocalPlayer.ViewAngle;
                        if (cuurentAngle.y > oldAngle.y)
                        {
                            LocalPlayer.MoveLeft();
                        }
                        else if (cuurentAngle.y < oldAngle.y)
                        {
                            LocalPlayer.MoveRight();
                        }
                    }

                    if (LocalPlayer.Flags == 257 || LocalPlayer.Flags == 263)
                    {
                        if (rnd.Next(100) < Properties.Settings.Default.bhopChoke)
                        {
                            Thread.Sleep(20);
                        }
                        LocalPlayer.Jump();
                    }
                    oldAngle = LocalPlayer.ViewAngle;
                }
                if (strafe)
                {
                    LocalPlayer.MoveClearY();
                    strafe = false;
                }
            }
        }
Esempio n. 5
0
        public static void Start()
        {
            while (Properties.Settings.Default.aimbot)
            {
                Thread.Sleep(1);

                if (!LocalPlayer.InGame)
                {
                    continue;
                }
                if (LocalPlayer.Health <= 0)
                {
                    continue;
                }
                if (LocalPlayer.Dormant)
                {
                    continue;
                }
                if (!((DllImport.GetAsyncKeyState(0x01) & 0x8000) != 0))
                {
                    continue;
                }

                Entity target = BestFOV(Properties.Settings.Default.fov, Properties.Settings.Default.boneid);

                if (target.Index == -1)
                {
                    continue;
                }

                LocalPlayer.ViewAngle = NormalizedAngle(Smooth(LocalPlayer.ViewAngle, RSC(CalcAngle(LocalPlayer.ViewPosition, target.BonePosition(Properties.Settings.Default.boneid)))));
            }
        }
Esempio n. 6
0
 private void controlPanel_MouseDown(object sender, MouseEventArgs e)
 {
     if (e.Button == MouseButtons.Left)
     {
         DllImport.ReleaseCapture();
         DllImport.SendMessage(Handle, WM_NCLBUTTONDOWN, HT_CAPTION, 0);
     }
 }
Esempio n. 7
0
        public IntPtr AlloacNewPage(IntPtr size)
        {
            var Address = DllImport.VirtualAllocEx(Memory.pHandle, IntPtr.Zero, (IntPtr)4096, (int)0x1000 | (int)0x2000, 0x40);

            AllocatedSize.Add(Address, size);

            return(Address);
        }
Esempio n. 8
0
        public static void Start()
        {
            while (true)
            {
                Thread.Sleep(10);

                if (!Properties.Settings.Default.perfectnade)
                {
                    continue;
                }
                if (!LocalPlayer.InGame)
                {
                    continue;
                }
                if (LocalPlayer.Health <= 0)
                {
                    continue;
                }
                if (LocalPlayer.ViewAngle.x != -89)
                {
                    continue;
                }
                if (LocalPlayer.ActiveWeapon != 44)
                {
                    continue;
                }
                if (LocalPlayer.Speed != 0)
                {
                    continue;
                }
                if ((DllImport.GetAsyncKeyState(0x02) & 0x8000) != 0)
                {
                    Thread.Sleep(800);
                    if (!((DllImport.GetAsyncKeyState(0x02) & 0x8000) != 0))
                    {
                        continue;
                    }
                    ClientCMD.Exec("+attack");
                    Thread.Sleep(80);
                    ClientCMD.Exec("-attack2");
                    Thread.Sleep(1);
                    ClientCMD.Exec("-attack");
                }
            }
        }
Esempio n. 9
0
        public static void Exec(string szCmd)
        {
            if (Address == IntPtr.Zero)
            {
                Allocator Alloc = new Allocator();
                Address = Alloc.Alloc(Size);
                if (Address == IntPtr.Zero)
                {
                    return;
                }
            }
            //if (szCmd.Length > 255)
            //    szCmd = szCmd.Substring(0, 255);

            var szCmd_bytes = Encoding.UTF8.GetBytes(szCmd + "\0");

            Memory.WriteProcessMemory(Memory.pHandle, Address, szCmd_bytes, szCmd_bytes.Length, 0);
            IntPtr Thread = DllImport.CreateRemoteThread(Memory.pHandle, (IntPtr)null, IntPtr.Zero, new IntPtr(Memory.Engine + ScannedOffsets.ClientCMD), Address, 0, (IntPtr)null);

            DllImport.CloseHandle(Thread);
            DllImport.WaitForSingleObject(Thread, 0xFFFFFFFF);
        }
Esempio n. 10
0
        private void Overlay_Load(object sender, EventArgs e)
        {
            int initialStyle = DllImport.GetWindowLong(this.Handle, -20);

            DllImport.SetWindowLong(this.Handle, -20, initialStyle | 0x80000 | 0x20);

            IntPtr hWnd = Process.GetProcessesByName("csgo")[0].MainWindowHandle;
            Rect   rect = new Rect();

            DllImport.GetWindowRect(hWnd, ref rect);

            this.Width  = 1000;
            this.Height = 500;
            this.Left   = ((rect.right - rect.left) - this.Width) / 2;
            this.Top    = ((rect.bottom - rect.top) - this.Height) / 2;

            lineWidth         = (int)((0.9 * this.Width) - (0.1 * this.Width));
            maxHeight         = (int)((0.9 * this.Height) - (0.1 * this.Height));
            pointsPerVelocity = maxHeight / (float)maxDisplayVel;

            g          = paintBox.CreateGraphics();
            pointsLine = new float[lineWidth].ToList();
        }
Esempio n. 11
0
        public static void Start()
        {
            while (true)
            {
                Thread.Sleep(1);

                if (!Properties.Settings.Default.blockbot)
                {
                    continue;
                }

                if (!LocalPlayer.InGame)
                {
                    continue;
                }

                if (LocalPlayer.Health <= 0)
                {
                    continue;
                }

                Entity target = null;

                while ((DllImport.GetAsyncKeyState(Properties.Hotkey.Default.blockbotKey) & 0x8000) != 0)
                {
                    Thread.Sleep(1);
                    if (target == null)
                    {
                        target = Aimbot.BestDistance();
                    }

                    blocking = true;
                    float speed = target.Speed;
                    if ((LocalPlayer.Position - target.BonePosition(8)).Length < 30)
                    {
                        if (LocalPlayer.Flags == 256)
                        {
                            continue;
                        }

                        if (bb)
                        {
                            LocalPlayer.MoveClearY();
                            bb = false;
                        }

                        hb = true;

                        if (target.Speed == 0 && (LocalPlayer.Position - target.ViewPosition).Length < 10)
                        {
                            LocalPlayer.MoveClearX();
                            continue;
                        }

                        LocalPlayer.ViewAngleY = Aimbot.NormalizedAngle(Aimbot.CalcAngle(LocalPlayer.ViewPosition, target.Position)).y;

                        LocalPlayer.MoveForward();
                    }
                    else
                    {
                        bb = true;
                        Vector3 angle = Aimbot.CalcAngle(LocalPlayer.ViewPosition, target.Position);
                        angle.y -= LocalPlayer.ViewAngle.y;
                        angle    = Aimbot.NormalizedAngle(angle);


                        if (speed > 1 || Math.Abs(angle.y) > 1)
                        {
                            if (angle.y < 0.0f)
                            {
                                LocalPlayer.MoveRight();
                            }

                            else if (angle.y > 0.0f)
                            {
                                LocalPlayer.MoveLeft();
                            }
                        }
                        else
                        {
                            LocalPlayer.MoveClearY();
                        }
                    }
                }
                if (blocking || hb || bb)
                {
                    if (hb)
                    {
                        LocalPlayer.MoveClearX();
                        hb = false;
                    }
                    Thread.Sleep(1);
                    if (bb)
                    {
                        LocalPlayer.MoveClearY();
                        bb = false;
                    }
                    blocking = false;
                }
            }
        }
Esempio n. 12
0
        public static void Start()
        {
            while (true)
            {
                Thread.Sleep(1);

                if (!Properties.Settings.Default.blockbot)
                {
                    continue;
                }

                if (!LocalPlayer.InGame)
                {
                    continue;
                }

                if (LocalPlayer.Health <= 0)
                {
                    continue;
                }

                Entity target = null;

                while ((DllImport.GetAsyncKeyState(Properties.Hotkey.Default.blockbotKey) & 0x8000) != 0)
                {
                    if (target == null)
                    {
                        target = Aimbot.BestDistance();
                    }

                    blocking = true;
                    float speed = target.Speed;



                    Vector3 angle = Aimbot.CalcAngle(LocalPlayer.ViewPosition, target.Position);
                    angle.y -= LocalPlayer.ViewAngle.y;
                    angle    = Aimbot.NormalizedAngle(angle);

                    if (speed > 10 || Math.Abs(angle.y) > 10)
                    {
                        if (angle.y < 0.0f)
                        {
                            LocalPlayer.MoveRight();
                        }

                        else if (angle.y > 0.0f)
                        {
                            LocalPlayer.MoveLeft();
                        }
                    }
                    else
                    {
                        LocalPlayer.MoveClearY();
                    }


                    Thread.Sleep(1);
                }
                if (blocking == true)
                {
                    LocalPlayer.MoveClearY();
                    blocking = false;
                }
            }
        }