bunnyhope code

[emiprohitman56]

1. #include <Windows.h> //All KeyState func and a lot more
2. #include <iostream> //Shit ton of things
3. #include "ProcMem.h" //Set up permissions, creates byte array, allowing us to read memory
4. 
   
5. #define PRESSED 0x8000 //Determines key press(highest bit)
6. #define SPACE 0x20 //Virtual Key Code 'SPACE'
7. #define KEY9 0x39 //Virtual Key Code '9' (not to confuse with keypad 9)
8. #define KEY9SC 0x0A //Scan Code *You usually don't need this, but CS:GO uses DirectInput so we need to use this*
9. 
   
10. ProcMem Mem; //Creates object of ProcMem class
11. 
    
12. void endProgram(); //Declaring some funcs
13. 
    
14. //Changes when CS:GO updates:
15. const DWORD playerBase = 0xA6B91C; //OUTDATED OFFSET *client.dll*
16. 
    
17. //Does not change when CS:GO updates:
18. const DWORD healthOffset = 0xFC; //*client.dll*
19. const DWORD m_fFlags = 0x100; //*client.dll*
20. 
    
21. const DWORD EntLoopDist = 0x10; //Distance between entities in Entity array *You don't need this, BHOP only uses our player info*
22. 
    
23. struct PlayerLocal_t //Struct to hold our player's data
24. {
25. int Flags; //State of our player *Is he jumping, crouching....*
26. int Health; //Health
27. DWORD ClientDLL; //Module to read from
28. DWORD LocalPlayer; //Get our player's information
29. void ReadInfo() //Func to read memory
30. {
31. Mem.Process("csgo.exe"); //Set process name
32. ClientDLL = Mem.Module("client.dll"); //Module to read from
33. LocalPlayer = Mem.Read<DWORD>(ClientDLL + playerBase); //Get our player's information
34. Flags = Mem.Read<int>(LocalPlayer + m_fFlags); //Get flag state
35. Health = Mem.Read<int>(LocalPlayer + healthOffset); //Get health
36. }
37. }PlayerLocal;
38. 
    
39. BOOL findWindow(LPCSTR Window) //Func to find our CS:GO window
40. {
41. HWND hWnds = FindWindow(NULL, TEXT(Window));
42. if (hWnds == NULL)
43. return false;
44. else
45. return true;
46. }
47. 
    
48. BOOL compareWnd(char AWnd[323]) //Func to compare active window with CS:GO window
49. {
50. char wnd_title[256];
51. HWND hwnd = GetForegroundWindow();
52. GetWindowText(hwnd, wnd_title, sizeof(wnd_title));
53. if (strcmp(wnd_title, AWnd) == 0)
54. return true;
55. else
56. return false;
57. }
58. 
    
59. BOOL keyState(int vKey, int vState) //I don't like writing GetAsyncKeyState every time ;)
60. {
61. return GetAsyncKeyState(vKey) & vState;
62. }
63. 
    
64. void sendKeys() //Func to send KEY9 to active window
65. {
66. keybd_event(KEY9, KEY9SC, 0, 0);
67. Sleep(10); //Delay to diminush number of times key is sent and diminush CPU usage
68. keybd_event(KEY9, KEY9SC, KEYEVENTF_KEYUP, 0);
69. }
70. 
    
71. void endProgram() //Func to end program *Makes code cleaner*
72. {
73. std::cout << "Exiting... " << std::endl;
74. Sleep(1500);
75. exit(0);
76. }
77. 
    
78. void searchWindow() //Will search for CS:GO window
79. {
80. Sleep(100);
81. std::cout << "by jkfauvel" << std::endl;
82. std::cout << "------------------------------------------------------------------ " << std::endl;
83. std::cout << "Searching for process...";
84. Sleep(200);
85. LPCSTR Wnd = "Counter-Strike: Global Offensive"; //Check if there is a window named as stated
86. 
    
87. if (!findWindow(Wnd)) //If window is not found then print 'something' and call EndProgram() func
88. {
89. Sleep(1500);
90. std::cout << " PROCESS: Process Not Found! " << std::endl;
91. Sleep(2000);
92. endProgram();
93. }
94. else if (findWindow(Wnd)) //If windows is found then continue with the code
95. {
96. Sleep(300);
97. std::cout << " PROCESS: Process Found! " << std::endl;
98. Sleep(1500);
99. }
100. }
101. 
     
102. void optionsList() //List of BHOP options
103. {
104. std::cout << "------------------------------------------------------------------ " << std::endl;
105. std::cout << "Set your jump hotkey to Keyboard 9 'NOT KEYPAD 9' (Game options) " << std::endl;
106. std::cout << "Press END to exit " << std::endl;
107. std::cout << "Hold SPACE to Bunnyhop " << std::endl;
108. std::cout << "------------------------------------------------------------------ " << std::endl;
109. }
110. 
     
111. void bhop() //Func to determine if sendKeys() func will be called *essentially func to BHOP*
112. {
113. PlayerLocal.ReadInfo(); //Read player's info
114. char wndCsgo[33] = "Counter-Strike: Global Offensive"; //Set the window we want to compare
115. 
     
116. /*Check if player is on ground *257 is on ground 256 is on air*;
117. *Check if player's health is more or equal to 1 *1 means dead for some reason*;
118. *Call compareWnd() to compare active window with that of CS:GO;
119. *Check if space is held
120. */
121. if (PlayerLocal.Flags == 257 && PlayerLocal.Health >= 1 && compareWnd(wndCsgo) && keyState(SPACE, PRESSED))
122. sendKeys(); //Call sendKeys() func
123. }
124. 
     
125. int main() //main() func *tie all of the program*
126. {
127. searchWindow();
128. optionsList(); //"Load options list *Call optionsList() func*"
129. while (true) //Infinite loop
130. {
131. bhop();
132. if (keyState(0x23, PRESSED)) //0x23 = ENDK
133. endProgram();
134. Sleep(1);
135. }

Thank for watch my post
Offsets not NEW