API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 2nd, 2014
184
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 15.77 KB | None | 0 0
raw download clone embed print report
  1. #include <Windows.h>
  2. #include <iostream>
  3. #include <math.h>
  4. #include "HackProcess.h"
  5. #include <vector>
  6. #include <algorithm>
  7. CHackProcess fProcess;
  8. using namespace std;
  9. #define F6_Key 0x75
  10. #define RIGHT_MOUSE 0x02
  11. int NumOfPlayers = 15;
  12. const DWORD dw_PlayerCountOffs = 0x6F4020;//Engine.dll //Tirar //////engine.dll+6F4020
  13.  
  14. const DWORD GameBasePtr = 0xC000;
  15. const DWORD GameBase = 0x00A15F68;
  16.  
  17. DWORD MeuPlayerBase;
  18. int localizado = 0;
  19. int localizadoang = 0;
  20. int contador = 0;
  21. const DWORD Player_Base = GameBase-0x198;//0x00574560;
  22. const DWORD dw_MyTeamOffset = 0xD8;//client // + vai virar -
  23. const DWORD dw_mTeamOffset = 0xD8;//client // -
  24. const DWORD dw_MyHealth = 0x198;//client //+
  25. const DWORD dw_Health = 0x00;//client //+
  26. const DWORD dw_Pos = 0x48;//client //0134 //-
  27. const DWORD dw_MyPos = 0x150;//client //+
  28. const CHAR mname = 0x4;//+
  29. const DWORD EntityPlayer_Base = GameBase;
  30. const DWORD EntityLoopDistance = 0x1E0;
  31. const DWORD waller = 0x9A8320;
  32.  
  33. DWORD dw_m_angRotationFINAL = 0x09B23760;
  34. //const DWORD dw_m_angRotationFINAL = 0x00;
  35.  
  36. /*
  37. void EncontraAngulo()
  38. {
  39.  
  40. float angulo;
  41. float angulocompare;
  42. DWORD compareptr;
  43.  
  44. for(int i = 0; i < 3300;i++) {
  45. if(localizadoang == 0) {
  46. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + 0xA00EB8), &angulo, sizeof(float), 0);
  47. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordEngine + 0xi), &compareptr, sizeof(DWORD), 0);
  48. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(compareptr), &angulocompare, sizeof(DWORD), 0);
  49. printf("contador = %d \n", i);
  50. printf("Angulo encontrado addr %x \n", compareptr);
  51. printf("Angulo encontrado %f \n", angulocompare);
  52. if(angulo == angulocompare)
  53. {
  54. dw_m_angRotationFINAL = compareptr;
  55. printf("Angulo encontrado addr %x \n", compareptr);
  56. printf("Angulo encontrado %f \n", angulocompare);
  57. localizadoang = 1;
  58. }
  59. }
  60. }
  61.  
  62.  
  63.  
  64. }*/
  65.  
  66.  
  67. struct MyPlayer_t
  68. {
  69. DWORD CLocalPlayer;
  70. DWORD ggGameBase;
  71. DWORD ggGameBaseB;
  72. DWORD ggGameBaseC;
  73. int Team;
  74. int Health;
  75. float Position[3];
  76.  
  77. float poscomparer;
  78. float posfinder;
  79.  
  80. DWORD TeamPtr;
  81. DWORD HealthPtr;
  82. DWORD PositionPtr;
  83.  
  84. DWORD poscomparerptr;
  85.  
  86. DWORD BaseOffsA, BaseOffsB,BaseOffsC,BaseOffsD,BaseOffsE,BaseOffsF,BaseOffsG,BaseOffsH;
  87. DWORD BaseOffsAptr, BaseOffsBptr,BaseOffsCptr,BaseOffsDptr,BaseOffsEptr,BaseOffsFptr,BaseOffsGptr,BaseOffsHptr;
  88. DWORD TeamGambiarra;
  89. void ReadInformation()
  90. {
  91.  
  92.  
  93. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + GameBase), &ggGameBase, sizeof(DWORD), 0);
  94.  
  95. BaseOffsA = ggGameBase+0x4FC;
  96. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsA), &BaseOffsAptr, sizeof(DWORD), 0);
  97. BaseOffsB = BaseOffsAptr+0x504;
  98. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsB), &BaseOffsBptr, sizeof(DWORD), 0);
  99. BaseOffsC = BaseOffsBptr+0xD4;
  100. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsC), &BaseOffsCptr, sizeof(DWORD), 0);
  101. BaseOffsD = BaseOffsCptr+0x0;
  102. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsD), &BaseOffsDptr, sizeof(DWORD), 0);
  103. BaseOffsE = BaseOffsDptr+0x90;
  104. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsE), &BaseOffsEptr, sizeof(DWORD), 0);
  105. BaseOffsF = BaseOffsEptr+0x7C;
  106. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsF), &BaseOffsFptr, sizeof(DWORD), 0);
  107. BaseOffsG = BaseOffsFptr+0x120;
  108. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsG), &BaseOffsGptr, sizeof(DWORD), 0);
  109. BaseOffsH = BaseOffsGptr+0x200;
  110. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsH), &BaseOffsHptr, sizeof(DWORD), 0);
  111.  
  112.  
  113.  
  114. // ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(gggGameBaseB + (Player * EntityLoopDistance)),&CBaseEntity, sizeof(DWORD), 0);
  115.  
  116.  
  117. for(int i = 0; i < 32; i++) {
  118. if(localizado == 0) {
  119. CLocalPlayer = BaseOffsH + (i * EntityLoopDistance);
  120. poscomparerptr = CLocalPlayer - dw_Pos;
  121. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + 0x9B8960), &posfinder, sizeof(float), 0);
  122. //ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(Nameptr), &Nameptrb, sizeof(DWORD), 0);
  123. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(poscomparerptr), &poscomparer, sizeof(float), 0);
  124. printf("posfinder: %f \n", posfinder);
  125. printf("poscomparer: %f \n", poscomparer);
  126. if(posfinder == poscomparer) {
  127. CLocalPlayer = BaseOffsH + (i * EntityLoopDistance);
  128. localizado = 1;
  129. contador = i;
  130. printf("Localizado ;p");
  131. }else {
  132. localizado = 0;
  133. }
  134. //printf("i = %d", i);
  135. }
  136. }
  137.  
  138.  
  139.  
  140.  
  141. //ggGameBaseB = BaseOffsH;
  142. //ggGameBaseC = BaseOffsH-0x198;
  143. // printf("BaseOffsH = %x", BaseOffsH);
  144.  
  145. // ###############CLocalPlayer = ggGameBaseC; ******************************************/
  146.  
  147.  
  148.  
  149.  
  150.  
  151. CLocalPlayer = BaseOffsH + (contador * EntityLoopDistance);
  152. //printf("Localizado %d", localizado);
  153. //CLocalPlayer = MeuPlayerBase-0x4;
  154.  
  155.  
  156. HealthPtr = CLocalPlayer+dw_Health;
  157. PositionPtr = CLocalPlayer-dw_Pos;
  158. TeamPtr = CLocalPlayer-dw_mTeamOffset;
  159. //printf("Team: %x", TeamPtr);
  160. // Reading CLocalPlayer Pointer to our "CLocalPlayer" DWORD.
  161. //ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(ggGameBaseC), &CLocalPlayer, sizeof(DWORD), 0);
  162.  
  163.  
  164.  
  165.  
  166.  
  167. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(HealthPtr), &Health, sizeof(int), 0);
  168.  
  169.  
  170. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(TeamPtr), &Team, sizeof(int), 0);//Tirar
  171.  
  172.  
  173. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(PositionPtr), &Position, sizeof(float[3]), 0);
  174.  
  175.  
  176. //ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordEngine + dw_PlayerCountOffs), &NumOfPlayers, sizeof(int), 0); //Tirar
  177.  
  178. //DWORD PosX = 0x9B8960;
  179. //DWORD PosZ = 0x9B8964;
  180. //DWORD PosY = 0x9B8968;
  181.  
  182.  
  183. }
  184. }MyPlayer;
  185.  
  186.  
  187.  
  188.  
  189.  
  190. struct TargetList_t
  191. {
  192. float Distance;
  193. float AimbotAngle[3];
  194.  
  195. TargetList_t()
  196. {
  197.  
  198. }
  199.  
  200. TargetList_t(float aimbotAngle[], float myCoords[], float enemyCoords[])
  201. {
  202.  
  203. Distance = Get3dDistance(myCoords[0], myCoords[1], myCoords[2],
  204. enemyCoords[0], enemyCoords[1], enemyCoords[2] );
  205.  
  206.  
  207. AimbotAngle[0] = aimbotAngle[0];
  208. AimbotAngle[1] = aimbotAngle[1];
  209. AimbotAngle[2] = aimbotAngle[2];
  210. }
  211.  
  212.  
  213. float Get3dDistance(float myCoordsX, float myCoordsZ, float myCoordsY,
  214. float eNx, float eNz, float eNy)
  215. {
  216.  
  217. return sqrt(
  218. pow(double(eNx - myCoordsX), 2.0) +
  219. pow(double(eNy - myCoordsY), 2.0) +
  220. pow(double(eNz - myCoordsZ), 2.0));
  221. }
  222. };
  223.  
  224.  
  225.  
  226. //ENemy struct
  227. struct PlayerList_t
  228. {
  229. DWORD gggGameBase;
  230. DWORD gggGameBaseB;
  231. DWORD gggGameBaseC;
  232. DWORD CBaseEntity;
  233. int Team;
  234. int Health;
  235. float Position[3];
  236. float AimbotAngle[3];
  237. char Name[39];
  238.  
  239. DWORD Healthptr;
  240. DWORD Teamptr;
  241. DWORD Positionptr;
  242. DWORD Nameptr;
  243.  
  244.  
  245. DWORD BaseOffsA, BaseOffsB,BaseOffsC,BaseOffsD,BaseOffsE,BaseOffsF,BaseOffsG,BaseOffsH;
  246. DWORD BaseOffsAptr, BaseOffsBptr,BaseOffsCptr,BaseOffsDptr,BaseOffsEptr,BaseOffsFptr,BaseOffsGptr,BaseOffsHptr;
  247. void ReadInformation(int Player)
  248. {
  249.  
  250.  
  251.  
  252.  
  253.  
  254.  
  255.  
  256.  
  257. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + GameBase), &gggGameBase, sizeof(DWORD), 0);
  258.  
  259. BaseOffsA = gggGameBase+0x4FC;
  260. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsA), &BaseOffsAptr, sizeof(DWORD), 0);
  261. BaseOffsB = BaseOffsAptr+0x504;
  262. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsB), &BaseOffsBptr, sizeof(DWORD), 0);
  263. BaseOffsC = BaseOffsBptr+0xD4;
  264. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsC), &BaseOffsCptr, sizeof(DWORD), 0);
  265. BaseOffsD = BaseOffsCptr+0x0;
  266. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsD), &BaseOffsDptr, sizeof(DWORD), 0);
  267. BaseOffsE = BaseOffsDptr+0x90;
  268. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsE), &BaseOffsEptr, sizeof(DWORD), 0);
  269. BaseOffsF = BaseOffsEptr+0x7C;
  270. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsF), &BaseOffsFptr, sizeof(DWORD), 0);
  271. BaseOffsG = BaseOffsFptr+0x120;
  272. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsG), &BaseOffsGptr, sizeof(DWORD), 0);
  273. BaseOffsH = BaseOffsGptr+0x200;
  274. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsH), &BaseOffsHptr, sizeof(DWORD), 0);
  275.  
  276.  
  277.  
  278. // ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(gggGameBaseB + (Player * EntityLoopDistance)),&CBaseEntity, sizeof(DWORD), 0);
  279.  
  280. CBaseEntity = BaseOffsH + (Player * EntityLoopDistance);
  281.  
  282. //printf("gggGameBaseB = %x", CBaseEntity);
  283.  
  284.  
  285. Teamptr = CBaseEntity - dw_mTeamOffset;
  286. Healthptr = CBaseEntity + dw_Health;
  287. Positionptr = CBaseEntity - dw_Pos;
  288. Nameptr = CBaseEntity + mname;
  289.  
  290.  
  291. // Reading out our Team to our "Team" Varible.
  292. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(Teamptr), &Team, sizeof(int), 0); //Tirar
  293. //printf("TeamId = %d \n", Team);
  294. // Reading out our Health to our "Health" Varible.
  295. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(Healthptr), &Health, sizeof(int), 0);
  296. // Reading out our Position to our "Position" Varible.
  297. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(Positionptr), &Position, sizeof(float[3]), 0);
  298.  
  299. ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(Nameptr), &Name, sizeof(char), 0);
  300.  
  301.  
  302. }
  303. }PlayerList[32];
  304.  
  305.  
  306.  
  307. struct CompareTargetEnArray
  308. {
  309.  
  310. bool operator() (TargetList_t & lhs, TargetList_t & rhs)
  311. {
  312. return lhs.Distance < rhs.Distance;
  313. }
  314. };
  315.  
  316.  
  317. void CalcAngle( float *src, float *dst, float *angles )
  318. {
  319.  
  320. double delta[3] = { (src[0]-dst[0]), (src[1]-dst[1]), (src[2]-dst[2]) };
  321. double hyp = sqrt(delta[0]*delta[0] + delta[1]*delta[1]);
  322. angles[0] = (float) (asinf(delta[2]/hyp) * 57.295779513082f);
  323. angles[1] = (float) (atanf(delta[1]/delta[0]) * 57.295779513082f);
  324. angles[2] = 0.0f;
  325.  
  326. if(delta[0] >= 0.0)
  327. {
  328. angles[1] += 180.0f;
  329. }
  330. }
  331.  
  332.  
  333.  
  334.  
  335. float Calculadistancia(float myCoordsX, float myCoordsZ, float myCoordsY,
  336. float eNx, float eNz, float eNy)
  337. {
  338.  
  339. return sqrt(
  340. pow(double(eNx - myCoordsX), 2.0) +
  341. pow(double(eNy - myCoordsY), 2.0) +
  342. pow(double(eNz - myCoordsZ), 2.0));
  343. }
  344.  
  345. void Aimbot()
  346. {
  347. float fNearest = (float)INT_MAX;
  348. int iAimAt = -1;
  349. int gambiarrameutime = 12;
  350.  
  351. TargetList_t* TargetList = new TargetList_t[NumOfPlayers];
  352.  
  353. int targetLoop = 0;
  354. for(int i = 1; i < NumOfPlayers; i ++)
  355. {
  356. if (GetAsyncKeyState(VK_RBUTTON)) { ////Meu
  357. i++;
  358. }
  359. if (GetAsyncKeyState(VK_F2)) { ////Meu
  360. gambiarrameutime = 12;
  361. }
  362. if (GetAsyncKeyState(VK_F3)) { ////Meu
  363. gambiarrameutime = 16;
  364. }
  365.  
  366. if (GetAsyncKeyState(VK_F4)) { ////Meu
  367. gambiarrameutime = 8;
  368. }
  369.  
  370.  
  371. PlayerList[i].ReadInformation(i);
  372.  
  373.  
  374. if (PlayerList[i].Team == MyPlayer.Team)
  375. continue;
  376.  
  377.  
  378. if (PlayerList[i].Health < 2)
  379. continue;
  380.  
  381. if(Calculadistancia(MyPlayer.Position[0], MyPlayer.Position[1], (MyPlayer.Position[2]),PlayerList[i].Position[0],PlayerList[i].Position[1], (PlayerList[i].Position[2]) ) < fNearest )//dis :D
  382. {
  383.  
  384.  
  385.  
  386. iAimAt = i;
  387.  
  388. fNearest = Calculadistancia(MyPlayer.Position[0], MyPlayer.Position[1],
  389. (MyPlayer.Position[2]),PlayerList[i].Position[0],PlayerList[i].Position[1], (PlayerList[i].Position[2]) );
  390. // }
  391. }
  392.  
  393.  
  394. //PlayerList[i].Position[2] -= 10;
  395. CalcAngle (MyPlayer.Position, PlayerList[i].Position, PlayerList[i].AimbotAngle);
  396.  
  397.  
  398. TargetList[targetLoop] = TargetList_t(PlayerList[i].AimbotAngle, MyPlayer.Position, PlayerList[i].Position);
  399.  
  400. //Increment
  401. targetLoop++;
  402. }
  403.  
  404.  
  405.  
  406.  
  407.  
  408. if(targetLoop > 0)
  409. {
  410.  
  411. std::sort(TargetList, TargetList+targetLoop, CompareTargetEnArray());
  412.  
  413.  
  414. if (GetAsyncKeyState(VK_MBUTTON))
  415. {
  416. if(iAimAt != -1) {
  417.  
  418.  
  419. /*
  420. WriteProcessMemory (fProcess.__HandleProcess,
  421. (PBYTE*)(fProcess.__csgoexe+dw_m_angRotation),
  422. TargetList[0].AimbotAngle, 12, 0);*/
  423.  
  424. if(MyPlayer.Health > 2) { //Evita um bug louco
  425. WriteProcessMemory (fProcess.__HandleProcess,
  426. (PBYTE*)(dw_m_angRotationFINAL),
  427. TargetList[0].AimbotAngle, 14, 0);
  428. }
  429.  
  430. int main()
  431. {
  432.  
  433. fProcess.RunProcess(); // CS:GO...
  434. cout << "starten!" << endl;
  435.  
  436.  
  437. while (!GetAsyncKeyState(F6_Key)) // or for(;;)
  438. {
  439.  
  440. MyPlayer.ReadInformation();
  441. // EncontraAngulo();
  442.  
  443.  
  444.  
  445. Aimbot();
  446.  
  447. }
  448. }
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!