API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 19th, 2015
264
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 12.03 KB | None | 0 0
raw download clone embed print report
  1. #pragma comment(lib,"user32.lib")
  2. #pragma comment(lib,"gdiplus.lib")
  3.  
  4.  
  5. #include <windows.h>
  6. #include <stdio.h>
  7. #include <iostream>
  8. #include <string>
  9. #include <cmath>
  10. #include <math.h>
  11. #include <Gdiplus.h>
  12. using namespace Gdiplus;
  13. using std::string;
  14.  
  15. using namespace std;
  16.  
  17. #define PlayerPointer 0x746A18
  18.  
  19. #define angleXAddress 0x10569A8
  20.  
  21. #define angleYAddress 0x10569A4
  22.  
  23. #define enemyBaseAddress 0x746A18 + 24
  24.  
  25. #define onenemybase 0x1211F4
  26.  
  27. DWORD HWDLL;
  28.  
  29. DWORD HLEXE;
  30.  
  31. DWORD CLDLL;
  32. bool silent = false;
  33.  
  34. bool trigger = false;
  35.  
  36. bool crosshair = false;
  37.  
  38. bool tracers = false;
  39.  
  40. bool angle = false;
  41. //string tomsg = "x " + to_string(playerX());
  42.  
  43. //MessageBoxA(0, tomsg.c_str(), "Blah blah", 0);
  44.  
  45. const double PI = 3.141592653589793238463;
  46.  
  47. void LeftClick()
  48. {
  49. INPUT input = { 0 };
  50.  
  51. // left down
  52. input.type = INPUT_MOUSE;
  53. input.mi.dwFlags = MOUSEEVENTF_LEFTDOWN;
  54. ::SendInput(1, &input, sizeof(INPUT));
  55.  
  56. // left up
  57. ::ZeroMemory(&input, sizeof(INPUT)); // why zeroMemory? removing this code changes nothing that i can tell
  58. input.type = INPUT_MOUSE; // why reset this variable? is it not already set?
  59.  
  60. input.mi.dwFlags = MOUSEEVENTF_LEFTUP;
  61. ::SendInput(1, &input, sizeof(INPUT));
  62. }
  63.  
  64. string GetActiveWindowTitle()
  65. {
  66. char wnd_title[256];
  67. HWND hwnd = GetForegroundWindow(); // get handle of currently active window
  68. GetWindowText(hwnd, wnd_title, sizeof(wnd_title));
  69. return wnd_title;
  70. }
  71.  
  72. float playerX()
  73. {
  74. DWORD PlayerBase = (DWORD)(HWDLL + PlayerPointer - 4); //store the value
  75. return *(float*)PlayerBase;
  76. }
  77.  
  78. float playerY()
  79. {
  80. DWORD PlayerBase = (DWORD)(HWDLL + PlayerPointer - 8); //store the value
  81. return *(float*)PlayerBase;
  82. }
  83.  
  84. float playerZ()
  85. {
  86. DWORD PlayerBase = (DWORD)(HWDLL + PlayerPointer); //store the value
  87. return *(float*)PlayerBase;
  88. }
  89.  
  90. float angleX()
  91. {
  92. DWORD PlayerBase = (DWORD)(HWDLL + angleXAddress); //store the value
  93. return *(float*)PlayerBase;
  94. }
  95.  
  96. float angleY()
  97. {
  98. DWORD PlayerBase = (DWORD)(HWDLL + angleYAddress); //store the value
  99. return *(float*)PlayerBase;
  100. }
  101.  
  102. float enemyZ(int enemynum)
  103. {
  104. int singleadd = enemynum * 88;
  105. DWORD PlayerBase = (DWORD)(HWDLL + enemyBaseAddress + singleadd); //store the value
  106. return *(float*)PlayerBase;
  107. }
  108.  
  109. float enemyX(int enemynum)
  110. {
  111. int singleadd = enemynum * 88;
  112. DWORD PlayerBase = (DWORD)(HWDLL + enemyBaseAddress + singleadd - 4); //store the value
  113. return *(float*)PlayerBase;
  114. }
  115.  
  116. float enemyY(int enemynum)
  117. {
  118. int singleadd = enemynum * 88;
  119. DWORD PlayerBase = (DWORD)(HWDLL + enemyBaseAddress + singleadd - 8); //store the value
  120. return *(float*)PlayerBase;
  121. }
  122.  
  123. void changeAngleX(float a)
  124. {
  125. DWORD PlayerBase = (DWORD)(HWDLL + angleXAddress); //store the value
  126. *(float*)PlayerBase = a;
  127. }
  128.  
  129. void changeAngleY(float a)
  130. {
  131. DWORD PlayerBase = (DWORD)(HWDLL + angleYAddress); //store the value
  132. *(float*)PlayerBase = a;
  133. }
  134.  
  135. bool OnEnemy()
  136. {
  137.  
  138. DWORD PlayerBase = (DWORD)(CLDLL + onenemybase); //store the value
  139.  
  140.  
  141. if (*(byte*)PlayerBase == 2)
  142. return true;
  143. else
  144. return false;
  145.  
  146. }
  147.  
  148.  
  149. int findClosest(float pXi, float pYi, float pZi)
  150. {
  151. double min = 99999999999999;
  152. int minI = 999;
  153.  
  154.  
  155. float beforeXi = angleX();
  156. float beforeYi = angleY();
  157.  
  158. for (int i = 0; i < 32; i++)
  159. {
  160.  
  161.  
  162. float eXi = enemyX(i);
  163. float eYi = enemyY(i);
  164. float eZi = enemyZ(i);
  165.  
  166.  
  167. if (eXi == 0 && eYi == 0 && eZi == 0)
  168. continue;
  169.  
  170. if (pXi == eXi || eYi == pYi)
  171. continue;
  172.  
  173. double diffXi = std::abs(eXi - pXi);
  174. double diffYi = std::abs(eYi - pYi);
  175. double diffZi = std::abs(eZi - pZi);
  176.  
  177. double dist2di = sqrt(pow(diffXi, 2) + pow(diffYi, 2));
  178.  
  179. double dist3di = sqrt(pow(dist2di, 2) + pow(diffZi, 2));
  180.  
  181. double aXti = 90 - ((180 / PI) * atan(diffYi / diffXi));
  182.  
  183. double aYti = (180 / PI) * atan(diffZi / dist2di);
  184.  
  185. if (pZi < eZi)
  186. aYti = aYti * -1;
  187.  
  188.  
  189. double angtracx;
  190. double angtracy;
  191. if (eXi != 0 && eYi != 0 && eZi != 0)
  192. {
  193. angtracy = beforeYi - aYti;
  194. if (eXi < pXi && pYi < eYi)
  195. {
  196. angtracx = beforeXi - (360 - aXti);
  197. }
  198.  
  199. if (pXi < eXi && pYi < eYi)
  200. {
  201. angtracx = beforeXi - (aXti);
  202. }
  203.  
  204. if (eXi < pXi && eYi < pYi)
  205. {
  206. angtracx = beforeXi - (180 + aXti);
  207. }
  208.  
  209. if (pXi < eXi && eYi < pYi)
  210. {
  211. angtracx = beforeXi - (180 - aXti);
  212. }
  213.  
  214.  
  215.  
  216.  
  217. if (pYi < eYi && pXi > eXi)
  218. if (beforeXi > 0 && beforeXi < 180)
  219. angtracx = angtracx + 360;
  220.  
  221. if (pYi < eYi && pXi < eXi)
  222. if (beforeXi > 180 && beforeXi < 360)
  223. angtracx = angtracx - 360;
  224.  
  225. if (angle == true)
  226. {
  227. if (std::abs(angtracx) <= min)
  228. {
  229. min = std::abs(angtracx);
  230. minI = i;
  231. }
  232. }
  233. else
  234. {
  235. if (dist3di <= min)
  236. {
  237. min = dist3di;
  238. minI = i;
  239. }
  240. }
  241.  
  242. }
  243.  
  244. }
  245. return minI;
  246.  
  247. }
  248.  
  249.  
  250.  
  251.  
  252.  
  253.  
  254. void tracerloop() //this is the thread that we have started
  255. {
  256. DWORD pdwGduStartup;
  257. GdiplusStartupInput GdiStartupInp;
  258. GdiplusStartup(&pdwGduStartup, &GdiStartupInp, NULL);
  259. Pen pnPen_Green(Gdiplus::Color(255, 255, 0, 255), 2.0F);
  260.  
  261.  
  262. LPCSTR LGameWindow = "Counter-Strike";
  263. HWND hGameWindow = FindWindow(NULL, LGameWindow);
  264. HDC GDC = GetDC(hGameWindow);
  265. Graphics graphics(GDC);
  266.  
  267. int resx = 1280;
  268. double resxd = 1280;
  269. int resy = 720;
  270. double resyd = 720;
  271. int fovx = 90;
  272. double fovxd = 90;
  273. int fovy = 74;
  274. double fovyd = 74;
  275.  
  276. for (;;)
  277. {
  278.  
  279. float pXi = playerX();
  280. float pYi= playerY();
  281. float pZi = playerZ();
  282. float beforeXi = angleX();
  283. float beforeYi = angleY();
  284.  
  285. for (int i = 0; i < 32; i++)
  286. {
  287.  
  288.  
  289. float eXi = enemyX(i);
  290. float eYi = enemyY(i);
  291. float eZi = enemyZ(i);
  292.  
  293.  
  294. if (eXi == 0 && eYi == 0 && eZi == 0)
  295. continue;
  296.  
  297. if (pXi == eXi || eYi == pYi)
  298. continue;
  299.  
  300. double diffXi = std::abs(eXi - pXi);
  301. double diffYi = std::abs(eYi - pYi);
  302. double diffZi = std::abs(eZi - pZi);
  303.  
  304. double dist2di = sqrt(pow(diffXi, 2) + pow(diffYi, 2));
  305.  
  306. double dist3di = sqrt(pow(dist2di, 2) + pow(diffZi, 2));
  307.  
  308. double aXti = 90 - ((180 / PI) * atan(diffYi / diffXi));
  309.  
  310. double aYti = (180 / PI) * atan(diffZi / dist2di);
  311.  
  312. if (pZi < eZi)
  313. aYti = aYti * -1;
  314.  
  315.  
  316. double angtracx;
  317. double angtracy;
  318. if (eXi != 0 && eYi != 0 && eZi != 0)
  319. {
  320. angtracy = beforeYi - aYti;
  321. if (eXi < pXi && pYi < eYi)
  322. {
  323. angtracx = beforeXi - (360 - aXti);
  324.  
  325. }
  326.  
  327. if (pXi < eXi && pYi < eYi)
  328. {
  329. angtracx = beforeXi - (aXti);
  330. }
  331.  
  332. if (eXi < pXi && eYi < pYi)
  333. {
  334. angtracx = beforeXi - (180 + aXti);
  335. }
  336.  
  337. if (pXi < eXi && eYi < pYi)
  338. {
  339. angtracx = beforeXi - (180 - aXti);
  340. }
  341.  
  342.  
  343. if (tracers == true)
  344. {
  345. if (pYi < eYi && pXi > eXi)
  346. if (beforeXi > 0 && beforeXi < 180)
  347. angtracx = angtracx + 360;
  348.  
  349. if (pYi < eYi && pXi < eXi)
  350. if (beforeXi > 180 && beforeXi < 360)
  351. angtracx = angtracx - 360;
  352.  
  353.  
  354. double xdr = fovxd / resxd;
  355. double xdrc = angtracx / xdr;
  356. xdrc = xdrc*0.9;
  357. int tomovx = (int)floor(xdrc);
  358. tomovx = (resx / 2) + tomovx;
  359.  
  360. double ydr = fovyd / resyd;
  361. double ydrc = angtracy / ydr;
  362. ydrc = ydrc*1.1;
  363. int tomovy = (int)floor(ydrc);
  364. tomovy = tomovy*-1;
  365. tomovy = (resy / 2) + tomovy;
  366.  
  367.  
  368. //graphics.DrawLine(&pnPen_Green, (resx / 2), (resy / 2), tomovx, tomovy);
  369.  
  370. graphics.DrawLine(&pnPen_Green, (resx / 2), resy, tomovx, tomovy);
  371. }
  372.  
  373. }
  374.  
  375.  
  376.  
  377. }
  378.  
  379.  
  380. graphics.Flush();
  381. Sleep(10);
  382.  
  383. }
  384. }
  385.  
  386.  
  387. void loop() //this is the thread that we have started
  388. {
  389. int resx = 1280;
  390. double resxd = 1280;
  391. int resy = 720;
  392. double resyd = 720;
  393. int fovx = 90;
  394. double fovxd = 90;
  395. int fovy = 74;
  396. double fovyd = 74;
  397. DWORD pdwGduStartup;
  398. GdiplusStartupInput GdiStartupInp;
  399. GdiplusStartup(&pdwGduStartup, &GdiStartupInp, NULL);
  400. Pen pnPen_Blue(Gdiplus::Color(255, 0, 0, 255), 2.0F);
  401. Pen pnPen_Green(Gdiplus::Color(255, 255, 0, 255), 2.0F);
  402.  
  403.  
  404. LPCSTR LGameWindow = "Counter-Strike";
  405. HWND hGameWindow = FindWindow(NULL, LGameWindow);
  406. Graphics graphics(GetDC(hGameWindow));
  407.  
  408. for (;;) //for (;;) is a loop. So this continues until we close the tread or return the tread (what isn't possible rightnow because its a void)
  409. {
  410. graphics.Flush();
  411.  
  412. if (GetAsyncKeyState(VK_F1) & 1)
  413. {
  414. angle = false;
  415. MessageBoxA(0, "Angle mode disabled", "Blah blah", 0);
  416. }
  417.  
  418. if (GetAsyncKeyState(VK_F2) & 1)
  419. {
  420. angle = true;
  421. MessageBoxA(0, "Angle mode enabled", "Blah blah", 0);
  422. }
  423.  
  424.  
  425. if (GetAsyncKeyState(VK_F3) & 1)
  426. {
  427. tracers = false;
  428. MessageBoxA(0, "Tracers disabled", "Blah blah", 0);
  429. graphics.Flush();
  430. }
  431.  
  432. if (GetAsyncKeyState(VK_F4) & 1)
  433. {
  434. tracers = true;
  435. MessageBoxA(0, "Tracers enabled", "Blah blah", 0);
  436. }
  437.  
  438. if (GetAsyncKeyState(VK_F5) & 1)
  439. {
  440. crosshair = false;
  441. MessageBoxA(0, "Crosshair disabled", "Blah blah", 0);
  442. graphics.Flush();
  443. }
  444.  
  445. if (GetAsyncKeyState(VK_F6) & 1)
  446. {
  447. crosshair = true;
  448. MessageBoxA(0, "Crosshair enabled", "Blah blah", 0);
  449. }
  450.  
  451.  
  452. if (crosshair == true)
  453. {
  454.  
  455. graphics.DrawLine(&pnPen_Blue, (resx / 2), ((resy / 2) - 40), (resx / 2), ((resy / 2) + 40));
  456. graphics.DrawLine(&pnPen_Blue, ((resx / 2)-40), (resy / 2), ((resx / 2)+40), (resy / 2));
  457.  
  458. }
  459.  
  460. if (GetAsyncKeyState(VK_F7) & 1)
  461. {
  462. trigger = false;
  463. MessageBoxA(0, "Triggerbot disabled", "Blah blah", 0);
  464. }
  465.  
  466.  
  467. if (GetAsyncKeyState(VK_F8) & 1)
  468. {
  469. if (silent == true)
  470. {
  471. MessageBoxA(0, "Cant enable triggerbot,silentaim is enabled", "Blah blah", 0);
  472. }
  473. else
  474. {
  475. trigger = true;
  476. MessageBoxA(0, "Triggerbot enabled", "Blah blah", 0);
  477. }
  478. }
  479.  
  480.  
  481.  
  482.  
  483. if (GetAsyncKeyState(VK_F9) & 1)
  484. {
  485. silent = false;
  486. MessageBoxA(0, "Silentaim disabled", "Blah blah", 0);
  487. }
  488.  
  489. if (GetAsyncKeyState(VK_F10) & 1)
  490. {
  491. if (trigger == true)
  492. {
  493. MessageBoxA(0, "Cant enable silentaim,triggerbot is enabled", "Blah blah", 0);
  494. }
  495. else
  496. {
  497. silent = true;
  498. MessageBoxA(0, "Silentaim enabled", "Blah blah", 0);
  499. }
  500.  
  501.  
  502. }
  503.  
  504. float pX = playerX();
  505. float pY = playerY();
  506. float pZ = playerZ();
  507.  
  508. int close = findClosest(pX, pY, pZ);
  509.  
  510. float eX = enemyX(close);
  511. float eY = enemyY(close);
  512. float eZ = enemyZ(close);
  513.  
  514. double diffX = std::abs(eX - pX);
  515. double diffY = std::abs(eY - pY);
  516. double diffZ = std::abs(eZ - pZ);
  517.  
  518. double dist2d = sqrt(pow(diffX, 2) + pow(diffY, 2));
  519.  
  520. double dist3d = sqrt(pow(dist2d, 2) + pow(diffZ, 2));
  521.  
  522. double aXt = 90 - ((180 / PI) * atan(diffY / diffX));
  523.  
  524. double aYt = (180 / PI) * atan(diffZ / dist2d);
  525.  
  526. if (pZ < eZ)
  527. aYt = aYt * -1;
  528.  
  529. float beforeX = angleX();
  530. float beforeY = angleY();
  531.  
  532.  
  533. if ((GetAsyncKeyState(0x46) && silent == false) || (GetAsyncKeyState(VK_LBUTTON) && silent == true)) {
  534.  
  535. if (eX != 0 && eY != 0 && eZ != 0)
  536. {
  537.  
  538. if (eX < pX && pY < eY)
  539. {
  540. changeAngleX((float)(360 - aXt));
  541. }
  542.  
  543. if (pX < eX && pY < eY)
  544. {
  545. changeAngleX((float)(aXt));
  546. }
  547.  
  548. if (eX < pX && eY < pY)
  549. {
  550. changeAngleX((float)(180 + aXt));
  551. }
  552.  
  553. if (pX < eX && eY < pY)
  554. {
  555. changeAngleX((float)(180 - aXt));
  556. }
  557.  
  558.  
  559.  
  560.  
  561. changeAngleY((float)aYt);
  562.  
  563. if (silent == true)
  564. {
  565. Sleep(10);
  566. changeAngleX(beforeX);
  567. changeAngleY(beforeY);
  568. }
  569. }
  570.  
  571.  
  572. }
  573.  
  574.  
  575.  
  576.  
  577.  
  578. if (trigger)
  579. {
  580.  
  581. if (GetActiveWindowTitle() == "Counter-Strike")
  582. {
  583.  
  584. bool toshoot = OnEnemy();
  585. if (toshoot)
  586. {
  587. LeftClick();
  588. Sleep(50);
  589. }
  590.  
  591. }
  592. }
  593. Sleep(1);
  594. }
  595. }
  596.  
  597.  
  598.  
  599. BOOL WINAPI DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpvReserved) //dll starts here
  600. {
  601. if (dwReason == DLL_PROCESS_ATTACH) //once it attaches its gonna run this code
  602. {
  603. CreateThread(0, 0, (LPTHREAD_START_ROUTINE)loop, 0, 0, 0); //starts a new thread
  604. CreateThread(0, 0, (LPTHREAD_START_ROUTINE)tracerloop, 0, 0, 0); //starts a new thread
  605. HWDLL = (DWORD)GetModuleHandle("hw.dll");
  606. HLEXE = (DWORD)GetModuleHandle("hl.exe");
  607. CLDLL = (DWORD)GetModuleHandle("client.dll");
  608. MessageBoxA(0, "QUACK!", 0, 0); //showing the messagebox
  609.  
  610. }
  611. return TRUE;
  612. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!