API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 30th, 2017
4,347
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 34.38 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <Windows.h>
  3. #include <string>
  4. #include <TlHelp32.h>
  5. #include <Thread>
  6. #include <stdlib.h>
  7. #include <vector>
  8. #include <math.h>
  9.  
  10. #define spacebar VK_SPACE
  11. #define pressed 0x8000
  12. #define leftmouse VK_LBUTTON
  13. #define alt VK_MENU
  14. #define keyA 0x41
  15. #define keyD 0x44
  16. #define Num1 VK_NUMPAD1
  17. #define Num2 VK_NUMPAD2
  18. #define Num3 VK_NUMPAD3
  19. #define Num4 VK_NUMPAD4
  20. #define Num5 VK_NUMPAD5
  21. #define Num6 VK_NUMPAD6
  22. #define Num7 VK_NUMPAD7
  23. #define Num8 VK_NUMPAD8
  24. #define Num9 VK_NUMPAD9
  25.  
  26. #define MAXFOV 2 //Change this is you want to change Aimbot Fov
  27.  
  28. // OFFSETS \\
  29.  
  30. #define EntityListOff 0x4AC90F4
  31. #define localplayer 0xAA6834
  32. #define glowobject 0x4FE38C4 //GlowObjectManager
  33. #define clientstate 0x5C75A4
  34. #define AttackingOff 0x2F09228 //For You Marc, dwForceAttack
  35.  
  36. #define spotted 0x939
  37. #define FlashedOff 0xA304
  38. #define GlowIndexOff 0xA320
  39. #define CrosshairIDOffset 0xAA70
  40. #define ViewAnglesOff 0x4D0C
  41. #define VecPunchOff 0x301C
  42. #define ShotsFiredOff 0xA2C0
  43. #define BoneMatrixOff 0x2698
  44. #define NoHandsOff 0x38F3
  45. #define ForceUpdateOff 0x16C
  46.  
  47. #define m_hActiveWeapon 0x2EE8
  48. #define m_hMyWeapons 0x2DE8
  49. #define m_iItemDefinitionIndex 0x2F88
  50. #define m_iAccountID 0x2FA8
  51. #define m_OriginalOwnerXuidLow 0x3168
  52. #define m_OriginalOwnerXuidHigh 0x316C
  53. #define m_iItemIDLow 0x2FA4
  54. #define m_iItemIDHigh 0x2FA0
  55.  
  56. #define m_nFallbackPaintKit 0x3170
  57. #define m_nFallbackSeed 0x3174
  58. #define m_flFallbackWear 0x3178
  59. #define m_nFallbackStatTrak 0x317C
  60.  
  61. #define m_iEntityQuality 0x2F8C
  62. #define m_szCustomName 0x301C
  63. #define m_hViewModel 0x32FC
  64. #define m_nModelIndex 0x0254
  65. #define m_iWorldModelIndex 0x31E4
  66. #define m_iViewModelIndex 0x31E0
  67. #define m_iWorldDroppedModelIndex 0x31E8
  68.  
  69. // OFFSETS \\
  70.  
  71.  
  72. using namespace std;
  73.  
  74. int TriggerBind;
  75. int BhopBind;
  76. int AimbotBind;
  77.  
  78. bool bEsp = false;
  79. bool bBhop = false;
  80. bool bTrigger = false;
  81. bool bNoflash = false;
  82. bool bRCS = false;
  83. bool bAimbot = false;
  84. bool bSkinChanger = false;
  85.  
  86. char nohands[256] = { 0 };
  87. char SkinName[161] = "Get Memed" ;
  88.  
  89. int IsIngame;
  90.  
  91. struct Vector {
  92. float x, y, z;
  93. };
  94.  
  95. struct VectorYX {
  96. float x, y ;
  97. };
  98.  
  99. struct GlowStruct
  100. {
  101. void* m_pEntity;
  102. float r;
  103. float g;
  104. float b;
  105. float a;
  106. unsigned char _0x0014[16];
  107. bool rwo;
  108. bool rwuo;
  109. bool frb;
  110. unsigned char _0x0027[13];
  111. }GlowStructA;
  112.  
  113. struct RGBA {
  114. float r;
  115. float g;
  116. float b;
  117. float a;
  118. }RGBAA;
  119.  
  120. struct RenderWhen {
  121. bool rwo;
  122. bool rwuo;
  123. }RenderWhenA;
  124.  
  125.  
  126. int KeyPressed() {
  127. while (true) {
  128. for (int i = 1; i < 255; i++) {
  129. if (GetAsyncKeyState(i) & pressed) {
  130. Sleep(250);
  131. return i;
  132. }
  133. }
  134. Sleep(10);
  135. }
  136. }
  137.  
  138.  
  139.  
  140.  
  141. DWORD GetModuleBaseExtern(const DWORD dwProcessId, const char *szModuleName)
  142. {
  143. HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwProcessId);
  144. if (!hSnap) return 0;
  145.  
  146. MODULEENTRY32 me;
  147. me.dwSize = sizeof(MODULEENTRY32);
  148.  
  149. DWORD dwReturn = 0;
  150.  
  151. if (Module32First(hSnap, &me)) {
  152. while (Module32Next(hSnap, &me)) {
  153. if (lstrcmpi(me.szModule, szModuleName) == 0) {
  154. dwReturn = (DWORD)me.modBaseAddr;
  155. break;
  156. }
  157. }
  158. }
  159.  
  160. CloseHandle(hSnap);
  161.  
  162. return dwReturn;
  163. }
  164.  
  165.  
  166.  
  167.  
  168.  
  169. void Trigger(HWND hWnd, DWORD clientdll, HANDLE hProcess) {
  170. DWORD playerbase;
  171. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + localplayer), &playerbase, sizeof(playerbase), NULL);
  172. if (playerbase == NULL) {
  173. return;
  174. }
  175. int playernumber;
  176. ReadProcessMemory(hProcess, (LPCVOID)(playerbase + CrosshairIDOffset), &playernumber, sizeof(playernumber), NULL);
  177. if (playernumber < 1 || playernumber > 64 || playernumber == NULL) {
  178. return;
  179. }
  180. else {
  181. DWORD entity;
  182. bool dormant;
  183. int Eteam;
  184. int Iteam;
  185. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + EntityListOff + ((playernumber - 1) * 0x10)), &entity, sizeof(entity), NULL);
  186. ReadProcessMemory(hProcess, (LPCVOID)(entity + 0xE9), &dormant, sizeof(dormant), NULL);
  187. ReadProcessMemory(hProcess, (LPCVOID)(entity + 0xF0), &Eteam, sizeof(Eteam), NULL);
  188. ReadProcessMemory(hProcess, (LPCVOID)(playerbase + 0xF0), &Iteam, sizeof(Iteam), NULL);
  189. if (entity == NULL || Eteam == NULL || Iteam == NULL) {
  190. return;
  191. }
  192.  
  193.  
  194.  
  195.  
  196.  
  197. if (Eteam != Iteam && !dormant) {
  198. mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
  199. Sleep(1);
  200. mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
  201.  
  202. }
  203. }
  204. }
  205.  
  206. struct Skin {
  207. int PaintKit;
  208. int Seed;
  209. int StatTrak;
  210. float Wear;
  211. int EntityQuality;
  212. char CustomName[161];
  213. };
  214.  
  215. struct FallbackValues {
  216. int FBPaintKit;
  217. int FBSeed;
  218. float FBWear;
  219. int FBStatTrak;
  220. };
  221.  
  222. struct Knife {
  223. int iViewModelIndex;
  224. int iWorldModelIndex;
  225. int iItemDefinitionIndex;
  226. };
  227.  
  228. void WriteSkins(DWORD enginebase, DWORD CurrentWeaponEntity, HANDLE hProcess, Skin SkinToWrite, int WeaponXuid) {
  229. // FallbackValues Fallback;
  230. // Fallback.FBPaintKit = SkinToWrite.PaintKit;
  231. // Fallback.FBSeed = SkinToWrite.Seed;
  232. // Fallback.FBWear = SkinToWrite.Wear;
  233. // Fallback.FBStatTrak = SkinToWrite.StatTrak;
  234. int ItemHigh = -1;
  235. int zero = 0;
  236. int one = 1;
  237. // WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_nFallbackPaintKit), &Fallback, sizeof(FallbackValues), NULL);
  238. WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_nFallbackPaintKit), &SkinToWrite.PaintKit, sizeof(SkinToWrite.PaintKit), NULL);
  239. WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_nFallbackSeed), &SkinToWrite.Seed, sizeof(SkinToWrite.Seed), NULL);
  240. WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_flFallbackWear), &SkinToWrite.Wear, sizeof(SkinToWrite.Wear), NULL);
  241. WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_nFallbackStatTrak), &SkinToWrite.StatTrak, sizeof(SkinToWrite.StatTrak), NULL);
  242. WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_iEntityQuality), &SkinToWrite.EntityQuality, sizeof(SkinToWrite.EntityQuality), NULL);
  243. WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_szCustomName), &SkinToWrite.CustomName, sizeof(SkinToWrite.CustomName), NULL);
  244. WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_iAccountID), &WeaponXuid, sizeof(WeaponXuid), NULL);
  245. // WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_OriginalOwnerXuidHigh), &zero, sizeof(zero), NULL);
  246. // WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_OriginalOwnerXuidLow), &zero, sizeof(zero), NULL);
  247.  
  248. WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_iItemIDHigh), &one, sizeof(one), NULL);
  249.  
  250.  
  251.  
  252. // WriteProcessMemory(hProcess, (LPVOID)(enginebase + ForceUpdateOff), &ItemHigh, sizeof(ItemHigh), NULL);
  253.  
  254. }
  255.  
  256. void SkinChanger(HANDLE hProcess, DWORD clientdll, DWORD enginedll) {
  257. Skin FireSerpent = { 180,1,1337,0.00001,9,"fiery haircuts" };
  258. Skin Orion = { 313,1,1337,0.00001,9,"1tap" };
  259. Skin WaterElemental = { 353,1,1337,0.00001,9,"Water Splash" };
  260. Skin GoldenKoi = { 185,1,1337,0.00001,9,":3" };
  261. Skin BloodInTheWater = { 222,1,1337,0.00001,9,"Sharkperiod" };
  262. Skin DragonLore = { 344,1,13,0.00001,9,"dlore.exe" };
  263. Skin Howl = { 309,1,1337,0.00001,9,"HOWLY FUCK" };
  264. Skin MarbleFade = { 413,493,1337,0.00001, 3, "Get Memed" };
  265.  
  266. Knife Butterfly = { 403,404,515 };
  267. Knife Karambit = { 389, 390, 507 };
  268. int ItemHigh = -1;
  269. int vhf = 404;
  270. int glock = 422;
  271. if (IsIngame != 6 || !bSkinChanger) {
  272. return;
  273. std::this_thread::sleep_for(std::chrono::milliseconds(1));
  274. }
  275. else {
  276. DWORD playerbase;
  277. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + localplayer), &playerbase, sizeof(playerbase), NULL);
  278. DWORD enginebase;
  279. ReadProcessMemory(hProcess, (LPCVOID)(enginedll + clientstate), &enginebase, sizeof(enginebase), NULL);
  280.  
  281. for (int i = 1; i <= 4; i++) {
  282. DWORD CurrentWeaponIndex1;
  283. ReadProcessMemory(hProcess, (LPCVOID)(playerbase + m_hMyWeapons + ((i - 1) * 0x4)), &CurrentWeaponIndex1, sizeof(CurrentWeaponIndex1), NULL);
  284. if (CurrentWeaponIndex1 == NULL) {
  285. continue;
  286. }
  287. DWORD CurrentWeaponIndex = CurrentWeaponIndex1 & 0xFFF;
  288. DWORD CurrentWeaponEntity;
  289. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + EntityListOff + (CurrentWeaponIndex - 1) * 0x10), &CurrentWeaponEntity, sizeof(CurrentWeaponEntity), NULL);
  290. if (CurrentWeaponEntity == 0) {
  291. continue;
  292. }
  293. int CurrentWeaponId;
  294. ReadProcessMemory(hProcess, (LPCVOID)(CurrentWeaponEntity + m_iItemDefinitionIndex), &CurrentWeaponId, sizeof(CurrentWeaponId), NULL);
  295.  
  296. int WeaponXuid;
  297. ReadProcessMemory(hProcess, (LPCVOID)(CurrentWeaponEntity + m_OriginalOwnerXuidLow), &WeaponXuid, sizeof(WeaponXuid), NULL);
  298. int CurrentPaintKit;
  299. ReadProcessMemory(hProcess, (LPCVOID)(CurrentWeaponEntity + m_nFallbackPaintKit), &CurrentPaintKit, sizeof(CurrentPaintKit), NULL);
  300. if (CurrentWeaponId == 7 && CurrentPaintKit != FireSerpent.PaintKit) {
  301. WriteSkins(enginebase, CurrentWeaponEntity, hProcess, FireSerpent, WeaponXuid);
  302. }
  303.  
  304. else if (CurrentWeaponId == 61 && CurrentPaintKit != Orion.PaintKit) {
  305. WriteSkins(enginebase, CurrentWeaponEntity, hProcess, Orion, WeaponXuid);
  306. }
  307. else if (CurrentWeaponId == 4 && CurrentPaintKit != WaterElemental.PaintKit) {
  308. WriteSkins(enginebase, CurrentWeaponEntity, hProcess, WaterElemental, WeaponXuid);
  309. }
  310.  
  311. else if (CurrentWeaponId == 1 && CurrentPaintKit != GoldenKoi.PaintKit) {
  312. WriteSkins(enginebase, CurrentWeaponEntity, hProcess, GoldenKoi, WeaponXuid);
  313. }
  314.  
  315. else if (CurrentWeaponId == 40 && CurrentPaintKit != BloodInTheWater.PaintKit) {
  316. WriteSkins(enginebase, CurrentWeaponEntity, hProcess, BloodInTheWater, WeaponXuid);
  317. }
  318.  
  319. else if (CurrentWeaponId == 9 && CurrentPaintKit != DragonLore.PaintKit) {
  320. WriteSkins(enginebase, CurrentWeaponEntity, hProcess, DragonLore, WeaponXuid);
  321. }
  322.  
  323. else if (CurrentWeaponId == 16 && CurrentPaintKit != Howl.PaintKit) {
  324. WriteSkins(enginebase, CurrentWeaponEntity, hProcess, Howl, WeaponXuid);
  325. }
  326. else if (CurrentWeaponId == 59 || CurrentWeaponId == 42) {
  327. DWORD ViewModelEntityIndex1;
  328. ReadProcessMemory(hProcess, (LPCVOID)(playerbase + m_hViewModel + ((i - 1) * 0x4)), &ViewModelEntityIndex1, sizeof(ViewModelEntityIndex1), NULL);
  329. DWORD ViewModelEntityIndex = ViewModelEntityIndex1 & 0xFFF;
  330. DWORD ViewModel;
  331. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + EntityListOff + (ViewModelEntityIndex - 1) * 0x10), &ViewModel, sizeof(ViewModel), NULL);
  332. int NormalKnife;
  333. ReadProcessMemory(hProcess, (LPCVOID)(ViewModel + m_nModelIndex), &NormalKnife, sizeof(NormalKnife), NULL);
  334. int KarambitModelIndex = NormalKnife + 46;
  335. int KarambitWorldIndex = NormalKnife + 47;
  336. int KarambitWorldDroppedIndex = NormalKnife + 48;
  337. WriteProcessMemory(hProcess, (LPVOID)(ViewModel + m_nModelIndex), &KarambitModelIndex, sizeof(KarambitModelIndex), NULL);
  338.  
  339. WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_iViewModelIndex), &KarambitModelIndex, sizeof(KarambitModelIndex), NULL);
  340. WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_iWorldModelIndex), &KarambitWorldIndex, sizeof(KarambitWorldIndex), NULL);
  341. WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_iItemDefinitionIndex), &Karambit.iItemDefinitionIndex, sizeof(Karambit.iItemDefinitionIndex), NULL);
  342. WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_iWorldDroppedModelIndex), &KarambitWorldDroppedIndex, sizeof(KarambitWorldDroppedIndex), NULL);
  343. WriteSkins(enginebase, CurrentWeaponEntity, hProcess, MarbleFade, WeaponXuid);
  344.  
  345. }
  346.  
  347.  
  348.  
  349.  
  350. }
  351.  
  352.  
  353. }
  354. }
  355.  
  356. void KnifeChanger(HANDLE hProcess, DWORD clientdll, DWORD enginedll, int &NormalKnife) {
  357. Knife Karambit = { 389, 390, 507 };
  358. DWORD playerbase;
  359. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + localplayer), &playerbase, sizeof(playerbase), NULL);
  360. DWORD enginebase;
  361. ReadProcessMemory(hProcess, (LPCVOID)(enginedll + clientstate), &enginebase, sizeof(enginebase), NULL);
  362. int Iteam;
  363. ReadProcessMemory(hProcess, (LPCVOID)(playerbase + 0xF0), &Iteam, sizeof(Iteam), NULL);
  364. DWORD CurrentWeaponIndex1;
  365. ReadProcessMemory(hProcess, (LPCVOID)(playerbase + m_hActiveWeapon), &CurrentWeaponIndex1, sizeof(CurrentWeaponIndex1), NULL);
  366. if (CurrentWeaponIndex1 == NULL) {
  367. return;
  368. }
  369. DWORD CurrentWeaponIndex = CurrentWeaponIndex1 & 0xFFF;
  370. DWORD CurrentWeaponEntity;
  371. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + EntityListOff + (CurrentWeaponIndex - 1) * 0x10), &CurrentWeaponEntity, sizeof(CurrentWeaponEntity), NULL);
  372. if (CurrentWeaponEntity == 0) {
  373. return;
  374. }
  375. int CurrentWeaponId;
  376. ReadProcessMemory(hProcess, (LPCVOID)(CurrentWeaponEntity + m_iItemDefinitionIndex), &CurrentWeaponId, sizeof(CurrentWeaponId), NULL);
  377.  
  378. int WeaponXuid;
  379. ReadProcessMemory(hProcess, (LPCVOID)(CurrentWeaponEntity + m_OriginalOwnerXuidLow), &WeaponXuid, sizeof(WeaponXuid), NULL);
  380. int CurrentPaintKit;
  381. ReadProcessMemory(hProcess, (LPCVOID)(CurrentWeaponEntity + m_nFallbackPaintKit), &CurrentPaintKit, sizeof(CurrentPaintKit), NULL);
  382. if (CurrentWeaponId == 59 || CurrentWeaponId == 42) {
  383. DWORD ViewModelEntityIndex1;
  384. ReadProcessMemory(hProcess, (LPCVOID)(playerbase + m_hViewModel), &ViewModelEntityIndex1, sizeof(ViewModelEntityIndex1), NULL);
  385. DWORD ViewModelEntityIndex = ViewModelEntityIndex1 & 0xFFF;
  386. DWORD ViewModel;
  387. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + EntityListOff + (ViewModelEntityIndex - 1) * 0x10), &ViewModel, sizeof(ViewModel), NULL);
  388. int NormalKnifeIndex;
  389. ReadProcessMemory(hProcess, (LPCVOID)(ViewModel + m_nModelIndex), &NormalKnifeIndex, sizeof(NormalKnife), NULL);
  390. if (NormalKnife == 0) {
  391. NormalKnife = NormalKnifeIndex;
  392. }
  393. int KarambitModelIndex, KarambitWorldIndex, KarambitWorldDroppedIndex;
  394. if (Iteam == 2) {
  395. KarambitModelIndex = NormalKnife + 46;
  396. KarambitWorldIndex = NormalKnife + 47;
  397. KarambitWorldDroppedIndex = NormalKnife + 48;
  398. }
  399. else if (Iteam == 3) {
  400. KarambitModelIndex = NormalKnife + 345;
  401. KarambitWorldIndex = NormalKnife + 346;
  402. KarambitWorldDroppedIndex = NormalKnife + 347;
  403. }
  404. int CurrentKnifeModel;
  405. ReadProcessMemory(hProcess, (LPCVOID)(ViewModel + m_nModelIndex), &CurrentKnifeModel, sizeof(CurrentKnifeModel), NULL);
  406. if (CurrentKnifeModel == KarambitModelIndex) {
  407. return;
  408. }
  409. int times = 0;
  410. while (true) {
  411. ReadProcessMemory(hProcess, (LPCVOID)(ViewModel + m_nModelIndex), &CurrentKnifeModel, sizeof(CurrentKnifeModel), NULL);
  412. if (CurrentKnifeModel == KarambitModelIndex) {
  413. return;
  414. }
  415. else {
  416. WriteProcessMemory(hProcess, (LPVOID)(ViewModel + m_nModelIndex), &KarambitModelIndex, sizeof(KarambitModelIndex), NULL);
  417. WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_iViewModelIndex), &KarambitModelIndex, sizeof(KarambitModelIndex), NULL);
  418. WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_iWorldModelIndex), &KarambitWorldIndex, sizeof(KarambitWorldIndex), NULL);
  419. WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_iItemDefinitionIndex), &Karambit.iItemDefinitionIndex, sizeof(Karambit.iItemDefinitionIndex), NULL);
  420. WriteProcessMemory(hProcess, (LPVOID)(CurrentWeaponEntity + m_iWorldDroppedModelIndex), &KarambitWorldDroppedIndex, sizeof(KarambitWorldDroppedIndex), NULL);
  421. }
  422. }
  423. }
  424.  
  425.  
  426. }
  427.  
  428.  
  429.  
  430.  
  431.  
  432.  
  433.  
  434. void ForceUpdate(HANDLE hProcess, DWORD enginedll) {
  435. int ItemHigh = -1;
  436. DWORD enginebase;
  437. ReadProcessMemory(hProcess, (LPCVOID)(enginedll + clientstate), &enginebase, sizeof(enginebase), NULL);
  438. WriteProcessMemory(hProcess, (LPVOID)(enginebase + ForceUpdateOff), &ItemHigh, sizeof(ItemHigh), NULL);
  439.  
  440. }
  441.  
  442. void KnifeSkinChanger(HANDLE hProcess, DWORD clientdll, DWORD enginedll) {
  443. int NormalKnife = 0;
  444. while (true) {
  445. SkinChanger ( hProcess, clientdll, enginedll);
  446. KnifeChanger( hProcess, clientdll, enginedll, NormalKnife);
  447. std::this_thread::sleep_for(std::chrono::milliseconds(1));
  448. }
  449. }
  450.  
  451. void GlowESP(DWORD clientdll, HANDLE hProcess) {
  452. while (true) {
  453. if (!bEsp || IsIngame != 6) {
  454. std::this_thread::sleep_for(std::chrono::milliseconds(5));
  455. continue;
  456. }
  457. else {
  458. DWORD GlowPointer;
  459. DWORD playerbase;
  460. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + glowobject), &GlowPointer, sizeof(GlowPointer), NULL);
  461. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + localplayer), &playerbase, sizeof(playerbase), NULL);
  462. if (GlowPointer == NULL || playerbase == NULL) {
  463. return;
  464. }
  465. int Iteam;
  466. ReadProcessMemory(hProcess, (LPCVOID)(playerbase + 0xF0), &Iteam, sizeof(Iteam), NULL);
  467. for (int i = 0; i <= 64; i++) {
  468. DWORD entity;
  469. bool dormant;
  470. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + EntityListOff + (i * 0x10)), &entity, sizeof(entity), NULL);
  471. ReadProcessMemory(hProcess, (LPCVOID)(entity + 0xE9), &dormant, sizeof(dormant), NULL);
  472.  
  473.  
  474.  
  475. if (!dormant) {
  476. DWORD Glowindex;
  477. ReadProcessMemory(hProcess, (LPCVOID)(entity + GlowIndexOff), &Glowindex, sizeof(Glowindex), NULL);
  478. int Eteam;
  479. ReadProcessMemory(hProcess, (LPCVOID)(entity + 0xF0), &Eteam, sizeof(Eteam), NULL);
  480. // ReadProcessMemory(hProcess, (LPCVOID)(GlowPointer + (Glowindex * 0x38)), &GlowStructA, sizeof(GlowStruct), NULL);
  481. bool playerspotted;
  482. ReadProcessMemory(hProcess, (LPCVOID)(entity + spotted), &playerspotted, sizeof(playerspotted), NULL);
  483.  
  484.  
  485. if (Glowindex == NULL) {
  486. continue;
  487. }
  488. // WriteProcessMemory(hProcess, (LPVOID)(GlowPointer + (Glowindex * 0x38)), &GlowStructA, sizeof(GlowStruct), NULL);
  489. if (Eteam != Iteam && playerspotted == true) {
  490. RGBAA.r = 1.f;
  491. RGBAA.g = 0.15686274509803921568627450980392f;
  492. RGBAA.b = 0.73333333333333333333333333333333f;
  493. RGBAA.a = 0.7f;
  494. RenderWhenA.rwo = true;
  495. RenderWhenA.rwuo = false;
  496. WriteProcessMemory(hProcess, (LPVOID)(GlowPointer + (Glowindex * 0x38) + 0x4), &RGBAA, sizeof(RGBA), NULL);
  497. WriteProcessMemory(hProcess, (LPVOID)(GlowPointer + (Glowindex * 0x38) + 0x24), &RenderWhenA, sizeof(RenderWhen), NULL);
  498. }
  499.  
  500. else if (Eteam != Iteam && playerspotted == false) {
  501. RGBAA.r = 1.f;
  502. RGBAA.g = 0.15686274509803921568627450980392f;
  503. RGBAA.b = 0.73333333333333333333333333333333f;
  504. RGBAA.a = 1.f;
  505. RenderWhenA.rwo = true;
  506. RenderWhenA.rwuo = false;
  507. WriteProcessMemory(hProcess, (LPVOID)(GlowPointer + (Glowindex * 0x38) + 0x4), &RGBAA, sizeof(RGBA), NULL);
  508. WriteProcessMemory(hProcess, (LPVOID)(GlowPointer + (Glowindex * 0x38) + 0x24), &RenderWhenA, sizeof(RenderWhen), NULL);
  509. }
  510. else if (Eteam == Iteam && playerspotted == true) {
  511. RGBAA.r = 0.f;
  512. RGBAA.g = 0.76862745098039215686274509803922f;
  513. RGBAA.b = 0.88627450980392156862745098039216f;
  514. RGBAA.a = 0.7f;
  515. RenderWhenA.rwo = true;
  516. RenderWhenA.rwuo = false;
  517. WriteProcessMemory(hProcess, (LPVOID)(GlowPointer + (Glowindex * 0x38) + 0x4), &RGBAA, sizeof(RGBA), NULL);
  518. WriteProcessMemory(hProcess, (LPVOID)(GlowPointer + (Glowindex * 0x38) + 0x24), &RenderWhenA, sizeof(RenderWhen), NULL);
  519.  
  520. }
  521.  
  522. else if (Eteam == Iteam && playerspotted == false) {
  523. RGBAA.r = 0.f;
  524. RGBAA.g = 0.76862745098039215686274509803922f;
  525. RGBAA.b = 0.88627450980392156862745098039216f;
  526. RGBAA.a = 1.f;
  527. RenderWhenA.rwo = true;
  528. RenderWhenA.rwuo = false;
  529. WriteProcessMemory(hProcess, (LPVOID)(GlowPointer + (Glowindex * 0x38) + 0x4), &RGBAA, sizeof(RGBA), NULL);
  530. WriteProcessMemory(hProcess, (LPVOID)(GlowPointer + (Glowindex * 0x38) + 0x24), &RenderWhenA, sizeof(RenderWhen), NULL);
  531. }
  532.  
  533.  
  534. }
  535.  
  536. }
  537. }
  538. std::this_thread::sleep_for(std::chrono::milliseconds(1));
  539. }
  540. }
  541.  
  542. void NoFlash(HANDLE hProcess, DWORD clientdll ) {
  543.  
  544. while (true) {
  545. if (!bNoflash || IsIngame != 6) {
  546. std::this_thread::sleep_for(std::chrono::milliseconds(5));
  547. continue;
  548. }
  549. else {
  550. DWORD playerbase;
  551. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + localplayer), &playerbase, sizeof(playerbase), NULL);
  552. if (playerbase == NULL) {
  553. std::this_thread::sleep_for(std::chrono::milliseconds(1));
  554. continue;
  555. }
  556. float AmountFlashed;
  557. float WPMFlash = 0.f;
  558. ReadProcessMemory(hProcess, (LPCVOID)(playerbase + FlashedOff), &AmountFlashed, sizeof(playerbase), NULL);
  559. if (AmountFlashed > 0.f) {
  560. WriteProcessMemory(hProcess, (LPVOID)(playerbase + FlashedOff), &WPMFlash, sizeof(WPMFlash), NULL);
  561. }
  562.  
  563. }
  564. std::this_thread::sleep_for(std::chrono::milliseconds(1));
  565. }
  566.  
  567. }
  568.  
  569. void Bhop(HANDLE hProcess, HWND hWnd, DWORD clientdll) {
  570. DWORD playerbase;
  571. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + localplayer), &playerbase, sizeof(playerbase), NULL); //localplayer
  572. if (playerbase == NULL) {
  573. std::this_thread::sleep_for(std::chrono::milliseconds(1));
  574. return;
  575. }
  576. int flags;
  577. ReadProcessMemory(hProcess, (LPCVOID)(playerbase + 0x100), &flags, sizeof(flags), NULL);
  578. if (flags & 0x1 == 1) {
  579. SendMessage(hWnd, WM_KEYDOWN, spacebar, 0x390000);
  580. Sleep(40);
  581. SendMessage(hWnd, WM_KEYUP, spacebar, 0x390000);
  582. Sleep(40);
  583. }
  584. }
  585.  
  586.  
  587. void TriggerBhop (HANDLE hProcess, HWND hWnd, DWORD clientdll) {
  588. while (true) {
  589. if (GetAsyncKeyState(TriggerBind) & pressed && bTrigger == true) {
  590. Trigger(hWnd, clientdll, hProcess);
  591. }
  592. else if (GetAsyncKeyState(BhopBind) & pressed && bBhop == true) {
  593. Bhop(hProcess, hWnd, clientdll);
  594. }
  595. std::this_thread::sleep_for(std::chrono::milliseconds(1));
  596.  
  597. }
  598. }
  599.  
  600. Vector SubtractVector(Vector a, Vector b) { // a = target head || b = my head
  601. Vector c;
  602. c.x = a.x - b.x;
  603. c.y = a.y - b.y;
  604. c.z = a.z - b.z;
  605. return c;
  606. }
  607.  
  608. Vector AddVector(Vector a, Vector b) {
  609. Vector c;
  610. c.x = a.x + b.x;
  611. c.y = a.y + b.y;
  612. c.z = a.z + b.z;
  613. return c;
  614. }
  615.  
  616.  
  617. Vector CalcEnemyHead(HANDLE hProcess, DWORD clientdll, DWORD entity, int bone ) {
  618.  
  619. DWORD bonematrix;
  620. ReadProcessMemory(hProcess, (LPCVOID)(entity + BoneMatrixOff), &bonematrix, sizeof(bonematrix), NULL);
  621. if (bonematrix == NULL) {
  622. return{ 0,0,0 };
  623. }
  624. Vector EnemyHead;
  625. ReadProcessMemory(hProcess, (LPCVOID)(bonematrix + 0x30 * bone + 0x0C), &EnemyHead.x, sizeof(EnemyHead.x), NULL);
  626. ReadProcessMemory(hProcess, (LPCVOID)(bonematrix + 0x30 * bone + 0x1C), &EnemyHead.y, sizeof(EnemyHead.y), NULL);
  627. ReadProcessMemory(hProcess, (LPCVOID)(bonematrix + 0x30 * bone + 0x2C), &EnemyHead.z, sizeof(EnemyHead.z), NULL);
  628.  
  629. return EnemyHead;
  630. }
  631.  
  632.  
  633. Vector CalcLocalPos(HANDLE hProcess, DWORD playerbase) {
  634. Vector Origin;
  635. Vector ViewVector;
  636. Vector LocalHeadPos;
  637. ReadProcessMemory(hProcess, (LPCVOID)(playerbase + 0x134), &Origin, sizeof(Origin), NULL);
  638. ReadProcessMemory(hProcess, (LPCVOID)(playerbase + 0x104), &ViewVector, sizeof(ViewVector), NULL);
  639.  
  640. LocalHeadPos = AddVector(Origin, ViewVector);
  641.  
  642. return LocalHeadPos;
  643. }
  644.  
  645. void CalcAngle(Vector& src, Vector& dst, Vector &vAngle) // LocalEyePos and EnemyHeadPos
  646. {
  647. double delta[3] = { (src.x - dst.x), (src.y - dst.y), (src.z - dst.z) };
  648. double hyp = sqrt(pow(delta[0],2 ) + pow(delta[1],2));
  649. float angles[3];
  650.  
  651. angles[0] = (float)(atan(delta[2] / hyp) * 57.295779513082); //pitch (Verticaal)
  652. angles[1] = (float)(atanf(delta[1] / delta[0]) * 57.295779513082f); //yaw (Horizontaal)
  653. angles[2] = 0.0f;
  654.  
  655. if (delta[0] >= 0.0)
  656. {
  657. angles[1] += 180.0f;
  658. }
  659.  
  660. if (angles[0] != angles[0]) {
  661. angles[0] = 0.f;
  662. }
  663.  
  664. if (angles[1] != angles[1]) {
  665. angles[1] = 0.f;
  666. }
  667. if (angles[2] != angles[2]) {
  668. angles[2] = 0.f;
  669. }
  670. vAngle.x = angles[0]; //Verticaal (Pitch)
  671. vAngle.y = angles[1]; //Horizontaal (Yaw)
  672. vAngle.z = angles[2];
  673. }
  674.  
  675.  
  676. Vector ClampAngles(Vector AngleToNormalize)
  677. {
  678. Vector vec = AngleToNormalize;
  679. if (vec.x > 89.0f && vec.x <= 180.0f)
  680. {
  681. vec.x = 89.0f;
  682. }
  683. while (vec.x > 180.f)
  684. {
  685. vec.x -= 360.f;
  686. }
  687. while (vec.x < -89.0f)
  688. {
  689. vec.x = -89.0f;
  690. }
  691. while (vec.y > 180.f)
  692. {
  693. vec.y -= 360.f;
  694. }
  695. while (vec.y < -180.f)
  696. {
  697. vec.y += 360.f;
  698. }
  699. return vec;
  700. }
  701.  
  702. VectorYX CurrentAngles(HANDLE hProcess, DWORD enginebase) {
  703. VectorYX Viewangles;
  704. ReadProcessMemory(hProcess, (LPCVOID)(enginebase + ViewAnglesOff), &Viewangles, sizeof(Viewangles), NULL);
  705. return Viewangles; //Omhoog en Horizontaal
  706. }
  707.  
  708. float Fov(Vector Angle, VectorYX PlayerAngle)
  709. {
  710. return sqrt(pow(Angle.x - PlayerAngle.x, 2) + pow(Angle.y - PlayerAngle.y,2));
  711. }
  712.  
  713. /*void SmoothAngle(float* curAngles, float* aimbotAngle, double Smooth)
  714. {
  715. aimbotAngle[0] = (((aimbotAngle[0] - curAngles[0]) * Smooth) + curAngles[0]);
  716. aimbotAngle[1] = (((aimbotAngle[1] - curAngles[1]) * Smooth) + curAngles[1]);
  717. ClampAngle(aimbotAngle);
  718. }
  719. */
  720. void Aimbot(HANDLE hProcess, DWORD clientdll, DWORD enginedll) {
  721. while (true) {
  722. if (!bAimbot || IsIngame != 6) {
  723. std::this_thread::sleep_for(std::chrono::milliseconds(5));
  724. continue;
  725.  
  726. }
  727. else {
  728. int bone = 8;
  729. DWORD enginebase;
  730. ReadProcessMemory(hProcess, (LPCVOID)(enginedll + clientstate), &enginebase, sizeof(enginebase), NULL);
  731. DWORD playerbase;
  732. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + localplayer), &playerbase, sizeof(playerbase), NULL);
  733. int LocalTeam;
  734. ReadProcessMemory(hProcess, (LPCVOID)(playerbase + 0xF0), &LocalTeam, sizeof(LocalTeam), NULL);
  735.  
  736. for (int i = 0; i <= 64; i++) {
  737. DWORD entity;
  738. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + EntityListOff + (i * 0x10)), &entity, sizeof(entity), NULL);
  739. if (entity == NULL) {
  740. continue;
  741. }
  742. bool dormant;
  743. ReadProcessMemory(hProcess, (LPCVOID)(entity + 0xE9), &dormant, sizeof(dormant), NULL);
  744. if (dormant) {
  745. continue;
  746. }
  747. int EHealth;
  748. ReadProcessMemory(hProcess, (LPCVOID)(entity + 0xFC), &EHealth, sizeof(EHealth), NULL);
  749. if (EHealth < 1) {
  750. continue;
  751. }
  752. int EntityTeam;
  753. ReadProcessMemory(hProcess, (LPCVOID)(entity + 0xF0), &EntityTeam, sizeof(EntityTeam), NULL);
  754. if (EntityTeam == LocalTeam) {
  755. continue;
  756. }
  757. /* bool playerspotted;
  758. ReadProcessMemory(hProcess, (LPCVOID)(entity + spotted), &playerspotted, sizeof(playerspotted), NULL);
  759. if (!playerspotted) {
  760. continue;
  761. } */
  762. Vector LocalHeadPos = CalcLocalPos(hProcess, playerbase); //Eye Position
  763. Vector EnemyBonePos = CalcEnemyHead(hProcess, clientdll, entity, bone); // Pos of enemy Bone
  764. if (EnemyBonePos.x == NULL && EnemyBonePos.y == NULL && EnemyBonePos.z == NULL) {
  765. continue;
  766. }
  767. Vector Angle; //Yaw (Verticaal), Pitch(Horizontaal)
  768. CalcAngle(LocalHeadPos, EnemyBonePos, Angle); //Angle needed to aim at the enemy
  769. Vector AngleClamped = ClampAngles(Angle);
  770. VectorYX CurrentViewAngle = CurrentAngles(hProcess, enginebase); //ViewAngles {Pitch, Yaw}
  771. float FOV = Fov(AngleClamped, CurrentViewAngle);
  772.  
  773.  
  774.  
  775. if (GetAsyncKeyState(AimbotBind) & pressed && FOV < MAXFOV) {
  776. WriteProcessMemory(hProcess, (LPVOID)(enginebase + ViewAnglesOff), &AngleClamped, sizeof(AngleClamped), NULL);
  777. }
  778.  
  779.  
  780. }
  781. }
  782. std::this_thread::sleep_for(std::chrono::milliseconds(1));
  783. }
  784.  
  785. }
  786.  
  787.  
  788.  
  789.  
  790. void RCS(HANDLE hProcess, DWORD clientdll, DWORD enginedll) {
  791. Vector OldVecPunch;
  792. while (true) {
  793. if (!bRCS || IsIngame != 6) {
  794. std::this_thread::sleep_for(std::chrono::milliseconds(5));
  795. continue;
  796. }
  797.  
  798. else {
  799. DWORD playerbase;
  800. int shotsfired;
  801. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + localplayer), &playerbase, sizeof(playerbase), NULL);
  802. if (playerbase == NULL) {
  803. std::this_thread::sleep_for(std::chrono::milliseconds(1));
  804. continue;
  805. }
  806. DWORD enginebase;
  807. ReadProcessMemory(hProcess, (LPCVOID)(enginedll + clientstate), &enginebase, sizeof(enginebase), NULL);
  808. Vector VecPunch;
  809. ReadProcessMemory(hProcess, (LPCVOID)(playerbase + VecPunchOff), &VecPunch, sizeof(VecPunch), NULL);
  810. VecPunch.x *= 2.0f;
  811. VecPunch.y *= 2.0f;
  812. VecPunch.z *= 2.0f;
  813. int Attacking;
  814. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + AttackingOff), &Attacking, sizeof(Attacking), NULL);
  815.  
  816. if (Attacking == 5) {
  817. Vector CurrentAngles;
  818. ReadProcessMemory(hProcess, (LPCVOID)(enginebase + ViewAnglesOff), &CurrentAngles, sizeof(CurrentAngles), NULL);
  819. Vector modify = VecPunch;
  820. modify.x -= OldVecPunch.x;
  821. modify.y -= OldVecPunch.y;
  822.  
  823. CurrentAngles.x -= modify.x;
  824. CurrentAngles.y -= modify.y;
  825.  
  826. WriteProcessMemory(hProcess, (LPVOID)(enginebase + ViewAnglesOff), &CurrentAngles, sizeof(CurrentAngles), NULL);
  827.  
  828.  
  829. }
  830. OldVecPunch = VecPunch;
  831. }
  832.  
  833. std::this_thread::sleep_for(std::chrono::milliseconds(1));
  834. }
  835.  
  836. }
  837.  
  838. void NoHands(HANDLE hProcess, DWORD clientdll) {
  839. DWORD playerbase;
  840. ReadProcessMemory(hProcess, (LPCVOID)(clientdll + localplayer), &playerbase, sizeof(playerbase), NULL);
  841. WriteProcessMemory(hProcess, (LPVOID)(playerbase + NoHandsOff), &nohands, sizeof(nohands), NULL);
  842. }
  843.  
  844. void text() {
  845. system("CLS");
  846. cout << "\t You're using Project HeadStrong, made by : Sebastian \n";
  847. cout << "\t Skype: pipodeclown86@hotmail.com" << endl << endl;
  848. if (IsIngame == 6) {
  849. cout << "Glow ";
  850. if (!bEsp) {
  851. cout << "(Off)";
  852. }
  853. else if (bEsp) {
  854. cout << "(On)";
  855. }
  856. cout << "(Num1)" << endl;
  857. cout << "Trigger ";
  858. if (!bTrigger) {
  859. cout << "(Off)";
  860. }
  861. else if (bTrigger) {
  862. cout << "(On)";
  863. }
  864. cout << "(Num2)" << endl;
  865. cout << "Bhop ";
  866. if (!bBhop) {
  867. cout << "(Off)";
  868. }
  869. else if (bBhop) {
  870. cout << "(On)";
  871. }
  872. cout << "(Num3)" << endl;
  873. cout << "NoFlash ";
  874. if (!bNoflash) {
  875. cout << "(Off)";
  876. }
  877. else if (bNoflash) {
  878. cout << "(On)";
  879. }
  880. cout << "(Num4)" << endl;
  881. cout << "RCS";
  882. if (!bRCS) {
  883. cout << "(Off)";
  884. }
  885. else if (bRCS) {
  886. cout << "(On)";
  887. }
  888. cout << "(Num5)" << endl;
  889.  
  890. cout << "Aimbot";
  891. if (!bAimbot) {
  892. cout << "(Off)";
  893.  
  894. }
  895. else if (bAimbot) {
  896. cout << "(On)";
  897. }
  898. cout << "(Num6)" << endl;
  899. cout << "SkinChanger ";
  900. if (!bSkinChanger) {
  901. cout << "(Off)";
  902. }
  903. else if (bSkinChanger) {
  904. cout << "(On)";
  905. }
  906. cout << "(Num7)" << endl;
  907.  
  908. cout << "NoHands (Num8)" << endl;
  909.  
  910.  
  911.  
  912. }
  913. else {
  914. cout << "\t Not In-Game" << endl;
  915. }
  916. }
  917.  
  918. void keys(HANDLE hProcess, DWORD clientdll, DWORD enginedll) {
  919. while (true) {
  920. if (GetAsyncKeyState(Num1) & pressed) {
  921. bEsp = !bEsp;
  922. text();
  923. std::this_thread::sleep_for(std::chrono::milliseconds(100));
  924. }
  925. else if (GetAsyncKeyState(Num2) & pressed) {
  926. bTrigger = !bTrigger;
  927. text();
  928. std::this_thread::sleep_for(std::chrono::milliseconds(100));
  929. }
  930. else if (GetAsyncKeyState(Num3) & pressed) {
  931. bBhop = !bBhop;
  932. text();
  933. std::this_thread::sleep_for(std::chrono::milliseconds(100));
  934. }
  935. else if (GetAsyncKeyState(Num4) & pressed) {
  936. bNoflash = !bNoflash;
  937. text();
  938. std::this_thread::sleep_for(std::chrono::milliseconds(100));
  939.  
  940. }
  941. else if (GetAsyncKeyState(Num5) & pressed) {
  942. bRCS = !bRCS;
  943. text();
  944. std::this_thread::sleep_for(std::chrono::milliseconds(100));
  945. }
  946. else if (GetAsyncKeyState(Num6) & pressed) {
  947. bAimbot = !bAimbot;
  948. text();
  949. std::this_thread::sleep_for(std::chrono::milliseconds(100));
  950. }
  951. /* else if (GetAsyncKeyState(Num8) & pressed) {
  952. NoHands(hProcess, clientdll);
  953. std::this_thread::sleep_for(std::chrono::milliseconds(100));
  954. }
  955. else if (GetAsyncKeyState(Num9) & pressed) {
  956. // ForceUpdate(hProcess, enginedll);
  957.  
  958. std::this_thread::sleep_for(std::chrono::milliseconds(100));
  959. }
  960. else if (GetAsyncKeyState(Num7) & pressed) {
  961. bSkinChanger = !bSkinChanger;
  962. text();
  963. std::this_thread::sleep_for(std::chrono::milliseconds(100));
  964. }*/
  965. std::this_thread::sleep_for(std::chrono::milliseconds(5));
  966. }
  967. }
  968.  
  969. void InGame(HANDLE hProcess, DWORD enginedll) {
  970. while (true) {
  971. DWORD Enginebase;
  972. int x;
  973. x = IsIngame;
  974. ReadProcessMemory(hProcess, (LPCVOID)(enginedll + clientstate), &Enginebase, sizeof(Enginebase), NULL);
  975. if (Enginebase == NULL) {
  976. std::this_thread::sleep_for(std::chrono::milliseconds(1));
  977. continue;
  978. }
  979. ReadProcessMemory(hProcess, (LPCVOID)(Enginebase + 0x100), &IsIngame, sizeof(IsIngame), NULL);
  980. if (x != IsIngame) {
  981. text();
  982. }
  983. std::this_thread::sleep_for(std::chrono::milliseconds(5000));
  984. }
  985. }
  986.  
  987. int main() {
  988. SetConsoleTitle("Project HeadStrong");
  989. /* cout << "\t You're using Project HeadStrong, made by : Sebastian \n";
  990. cout << "Skype: pipodeclown86@hotmail.com" << endl << endl;
  991. cout << "Features: " << endl;
  992. cout << "Glow" << endl << "NoFlash" << endl << "Bhop (Insert key) " << endl << "Trigger(Insert key)" << endl; */
  993. cout << "Press key for Bhop: " << endl;
  994. BhopBind = KeyPressed();
  995. cout << "Key Found" << endl;
  996. cout << "Press key for Triggerbot: " << endl;
  997. TriggerBind = KeyPressed();
  998. cout << "Key Found" << endl;
  999. cout << "Press key for Aimbot: " << endl;
  1000. AimbotBind = KeyPressed();
  1001. cout << "Key Found" << endl;
  1002. Sleep(500);
  1003. HWND hWnd;
  1004. hWnd = FindWindow(0, "Counter-Strike: Global Offensive");
  1005. DWORD pID;
  1006. while (!hWnd)
  1007. {
  1008. cout << "Open CS:GO";
  1009. Sleep(5000);
  1010. hWnd = FindWindow(0, "Counter-Strike: Global Offensive");
  1011. }
  1012.  
  1013. GetWindowThreadProcessId(hWnd, &pID);
  1014. HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pID);
  1015. if (!hProcess)
  1016. {
  1017. cout << "Can't open process";
  1018. }
  1019.  
  1020. DWORD clientdll = GetModuleBaseExtern(pID, "client.dll");
  1021. DWORD enginedll = GetModuleBaseExtern(pID, "engine.dll");
  1022.  
  1023.  
  1024.  
  1025. thread THKeys(keys, std::ref(hProcess), std::ref(clientdll), std::ref(enginedll));
  1026. thread THNoFlash(NoFlash, std::ref(hProcess), std::ref(clientdll));
  1027. thread THTriggerBhop(TriggerBhop, std::ref(hProcess), std::ref(hWnd), std::ref(clientdll));
  1028. thread THGlow(GlowESP, std::ref(clientdll), std::ref(hProcess));
  1029. thread THInGame(InGame, std::ref(hProcess), std::ref(enginedll));
  1030. thread THRCS(RCS, std::ref(hProcess), std::ref(clientdll), std::ref(enginedll));
  1031. thread THAimbot(Aimbot, std::ref(hProcess), std::ref(clientdll), std::ref(enginedll));
  1032. // thread THKnifeSkinchanger(KnifeSkinChanger, std::ref(hProcess), std::ref(clientdll), std::ref(enginedll));
  1033. while (true) {
  1034. Sleep(100000);
  1035. }
  1036. }
  1037.  
  1038.  
  1039. // WPM(handle, (LPVOID)((uintptr_t)manager.DataPtr + (i * sizeof(GlowObjectDefinition)) + 4), (LPCVOID)((uintptr_t)glowobjects + (i * sizeof(GlowObjectDefinition)) + 4), sizeof(GlowObjectDefinition) - 4 - 18, (SIZE_T*)&bytesRead);
  1040. // WriteProcessMemory(hProcess, (LPVOID)(GlowPointer + (Glowindex * 0x38)), &GlowStructA, sizeof(GlowStruct), NULL);
  1041.  
  1042. // auto size = (i * sizeof(GlowStruct) - (sizeof(GlowStruct) - IDebugSymbols::GetFieldOffset(GlowStructA.a)));
  1043. // auto size = i * sizeof( struct ) - ( sizeof( struct ) - GetFieldOffset( glow_alpha ) )
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!