Как написать аимбот для кс го на c

1. #include «hVector.h»

2. #include <Windows.h>

3. #include «hProcess.h»

4. #include <algorithm>

5. #include <math.h>

6. using namespace std;

7. #include <iostream>

8. #include <Windows.h>

9. #include <dwmapi.h>

12. HWND TargetWnd; // handles to our game and overlay

13. RECT WindowRect, ClientRect;  // Rect, coordinates basically

14. char TargetWndName[256] = «Counter-Strike: Global Offensive»;

15. int windowHeight, windowWidth; // size of window

18. //AIM

19. bool smooth = false;

20. //IClientEntity* PlayerToAim;

21. float AimFOV;

22. bool isaimbotting;

24. //Hard Coded Made when TroubleShooting.

25. int ScreenCenterX = 960;

26. int ScreenCenterY = 540;

28. /*

30. extern IDirect3D9Ex* dx_Object;

31. extern IDirect3DDevice9Ex* dx_Device;

32. extern D3DPRESENT_PARAMETERS dx_Params;

33. extern ID3DXLine* dx_Line;

34. extern ID3DXFont* dx_Font;

35. */

37. float Get3dDistance(float * myCoords, float * enemyCoords);

38. void CalcAngle(float *src, float *dst, float *angles);

39. bool WorldToScreen(float * from, float * to);

40. void GetNumberOfPlayers();

41. void ESP(int x, int y, int distance, int hp, int team, int dorm);

42. void Aimbot();

43. void keyState();

44. int Render();

46. extern int windowWidth; // Game window width

47. extern int windowHeight; // Game window height

48. extern char lWindowName[256]; // Overlay window name (our overlay window name)

49. extern HWND hWnd; // Handle to our window

50. extern char tWindowName[256]; // Target window name (our game window name)

51. extern HWND TargetWnd; // Our target window handle

52. extern RECT WindowRect, ClientRect; // Rectangles, coordinates

53. extern MSG Message; // Queue message..

56. LRESULT CALLBACK Proc(HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam);

57. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow);

58. extern int NumOfPlayers;

62. const DWORD dw_playerbase = 0xA7094C; // Player Data Structure // DWORD = 4 bytes long aka 32 bits

63. const DWORD dw_entitybase = 0x4A13264; // Entity Base (list of players, which in this case includes you)

64. const DWORD dw_entity_loop_distance = 0x10; // The distance between each player data structure

65. const DWORD dw_mouse_x = 0x4CE0; // Engine.dll X, Y coordinates ingame… SetCursor

66. const DWORD dw_numofplayers = 0x5C817C; // How many players are in the game

68. const DWORD dw_health_offset = 0xFC; // Health

69. const DWORD dw_team_offset = 0xF0; // Team 1 — Spec, 2 — T, 3 — CT

70. const DWORD dw_position_offset = 0x134; // Position

71. const DWORD dw_flags_offset = 0x100; // Flags?

72. const DWORD dw_bone_offset = 0xA78; // Bone Offset

73. const DWORD dw_fov_offset = 0x158C; // FOV

74. const DWORD dw_activeweapon = 0x12C0; // Active

75. const DWORD dw_weaponid = 0x1684; // Weapon ID

76. const DWORD dw_crosshair_offset = 0x23F8; // We can use this as a triggerbot

77. const DWORD dw_engine_pointer = 0x55B434;

79. const DWORD dw_vmatrix = 0x4A087A4; // View Matrix

81. CHackProcess fProcess;

82. int NumOfPlayers = 32;

83. #define PI 3.14159265

85. int mfov;

86. int bonetarget = 10;

88. #define M_PI 3.14159265359

90. typedef struct

91. {

92. float rawflMatrix[5][4];

93. }WorldToScreenMatrix_t;

95. struct MyPlayer_t

96. {

97.     DWORD CLocalPlayer;

98. int Team;

99. int Health;

100.     WorldToScreenMatrix_t WorldToScreenMatrix;

101. float Position[3];

102. float CurrentAng[3];

103. float ViewAngle[3];

104. int Flags;

105. int CrosshairID;

106. int flickerCheck, flickerCheck2, flickerCheck3, flickerCheck4;

108. float Vecview[3];

110. void ReadInformation()

111. {

112.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + dw_playerbase), &CLocalPlayer, sizeof(DWORD), 0);

113.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(CLocalPlayer + dw_health_offset), &Health, sizeof(int), 0);

114.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(CLocalPlayer + dw_team_offset), &Team, sizeof(int), 0);

115.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(CLocalPlayer + dw_position_offset), &Position, sizeof(float[3]), 0);

116.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(CLocalPlayer + dw_flags_offset), &Flags, sizeof(int), 0);

117.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(CLocalPlayer + dw_crosshair_offset), &CrosshairID, sizeof(int), 0);

118.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordEngine + dw_mouse_x), &CurrentAng, sizeof(float[3]), 0);

120.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordEngine + dw_vmatrix), &ViewAngle, sizeof(float[3]), 0);

121.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(CLocalPlayer + 0x104), &Vecview, sizeof(float[3]), 0);

122.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + dw_vmatrix), &WorldToScreenMatrix, sizeof(WorldToScreenMatrix), 0);

124. }

125. }MyPlayer;

127. struct TargetList_t

128. {

129.     DWORD CLocalPlayer;

130. float Distance;

131. float AimAngle[3];

132.     TargetList_t() {    }

134.     TargetList_t(float MyCoords[], float EnemyCoords[], float aimAngle[])

135. {

137.         Distance = Get3dDistance(MyCoords, EnemyCoords);

139.         AimAngle[0] = aimAngle[0];

140.         AimAngle[1] = aimAngle[1];

141.         AimAngle[2] = aimAngle[2];

142. }

145. }TargetList;

147. struct PlayerList_t

148. {

149.     DWORD CBaseEntity;

150. int Team;

151. int Health;

152. int Dorm;

153. int Flags;

154.     DWORD Bones;

155. float Position[3];

156. float BonePosition[3];

157. float AimAngle[3]; // ?

158. float Distance; // ?

160. void ReadInformation(int player, int iBone)

161. {

162.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + dw_entitybase + (player * dw_entity_loop_distance)), &CBaseEntity, sizeof(DWORD), 0); // CBaseEntity

163.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(CBaseEntity + dw_health_offset), &Health, sizeof(int), 0);

164.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(CBaseEntity + dw_team_offset), &Team, sizeof(int), 0);

165.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(CBaseEntity + dw_position_offset), &Position, sizeof(float[3]), 0);

166.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(CBaseEntity + dw_flags_offset), &Flags, sizeof(int), 0);

167.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(CBaseEntity + dw_bone_offset), &Bones, sizeof(DWORD), 0);

168.         ReadProcessMemory(fProcess.__HandleProcess, (PVOID)(Bones + 0x30 * bonetarget + 0xC), &BonePosition[0], sizeof(float), 0);

169.         ReadProcessMemory(fProcess.__HandleProcess, (PVOID)(Bones + 0x30 * bonetarget + 0x1C), &BonePosition[1], sizeof(float), 0);

170.         ReadProcessMemory(fProcess.__HandleProcess, (PVOID)(Bones + 0x30 * bonetarget + 0x2C), &BonePosition[2], sizeof(float), 0);

171.         BonePosition[2] —= 60;

172. }

173. }PlayerList[32];

175. void SetAngles(float* Angles)

176. {

177.     DWORD cviewptr;

178.     ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordEngine + dw_engine_pointer), &cviewptr, sizeof(DWORD), NULL);

179. if (cviewptr){

180.         WriteProcessMemory(fProcess.__HandleProcess, (PBYTE*)(cviewptr + dw_mouse_x), Angles, sizeof(float[3]), 0);

181. }

182. }

185. void GetAngles(float* Angles)

186. {

187.     DWORD AnglePointer;

188.     ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordEngine + dw_engine_pointer), &AnglePointer, sizeof(DWORD), NULL);

189. if (AnglePointer)

190. {

191.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(AnglePointer + dw_mouse_x), &Angles, sizeof(float[3]), 0);

192. }

193. }

195. void AngleNormalize(float* angle)

196. {

197. if (angle[0] > 89.0f && angle[0] <= 180.0f)

198. {

199.         angle[0] = 89.0f;

200. }

201. if (angle[0] > 180.f)

202. {

203.         angle[0] —= 360.f;

204. }

205. if (angle[0] < —89.0f)

206. {

207.         angle[0] = —89.0f;

208. }

209. if (angle[1] > 180.f)

210. {

211.         angle[1] —= 360.f;

212. }

213. if (angle[1] < —180.f)

214. {

215.         angle[1] += 360.f;

216. }

217. if (angle[2] != 0.0f)

218. {

219.         angle[2] = 0.0f;

220. }

221. }

223. void SmoothAngleSet(float* dest, float* orig)

224. {

225. float SmoothAngles[3];

226.     SmoothAngles[0] = dest[0] — orig[0];

227.     SmoothAngles[1] = dest[1] — orig[1];

228.     SmoothAngles[2] = 0.0f;

229.     AngleNormalize(SmoothAngles);

230.     SmoothAngles[0] = orig[0] + SmoothAngles[0] / 100.0f * 20;

231.     SmoothAngles[1] = orig[1] + SmoothAngles[1] / 100.0f * 20;

232.     SmoothAngles[2] = 0.0f;

233.     AngleNormalize(SmoothAngles);

234.     SetAngles(SmoothAngles);

235.     Sleep(1);

236. }

238. void VelocityComp(int PlayerNumber, float* EnemyPos)

239. {

240. int smoothamount = 10;

241. float EnemyVelocity[3];

242. float MyVelocity[3];

243.     EnemyPos[0] = EnemyPos[0] + (EnemyVelocity[0] / 100.f) * (40.f / smoothamount); //not sure why 40 works. I tried a lot of different values and 40 seems to scale perfectly

244.     EnemyPos[1] = EnemyPos[1] + (EnemyVelocity[1] / 100.f) * (40.f / smoothamount);

245.     EnemyPos[2] = EnemyPos[2] + (EnemyVelocity[2] / 100.f) * (40.f / smoothamount);

246.     EnemyPos[0] = EnemyPos[0] — (MyVelocity[0] / 100.f) * (40.f / smoothamount);

247.     EnemyPos[1] = EnemyPos[1] — (MyVelocity[1] / 100.f) * (40.f / smoothamount);

248.     EnemyPos[2] = EnemyPos[2] — (MyVelocity[2] / 100.f) * (40.f / smoothamount);

249. }

251. bool inFOV(float* destination, float* MyAngle)

252. {

254. float myX = MyAngle[0];

255. float myY = MyAngle[1];

257. float toX = destination[0];

258. float toY = destination[1];

260. if (toX >= (myX — 10) &&

261.         toX <= (myX + 10) &&

262.         toY >= (myY — 10) &&

263.         toY <= (myY + 10))

264. return true;

265. return false;

267. }

269. DWORD GetPlayerBase()

270. {

271. return  ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + dw_playerbase), &GetPlayerBase, sizeof(DWORD), 0);

273. }

275. void GetVelocity(float* Buffer)

276. {

277.     DWORD PlayerBase = GetPlayerBase();

278. if (PlayerBase)

279. {

280. //      Mem.R<float*>(PlayerBase + DwVecVelocity, true, 3, Buffer);

281.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(PlayerBase + 0x110), &Buffer, sizeof(float[3]), 0);

283. }

284. }

285. /*

286. float GetViewOrigin()

287. {

288.     DWORD PlayerBase = GetPlayerBase();

289.     if (PlayerBase)

290.     {

291.         float Vecview[3];

292.         //Mem.R<float*>(PlayerBase + DwVecViewOrigin, true, 3, Vecview);

293.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(PlayerBase + 0x104), &Vecview, sizeof(float[3]), 0);

295.         return Vecview[2];

296.     }

297. } */

299. void GetPosition(float* Position)

300. {

301.     DWORD PlayerBase = GetPlayerBase();

302. if (PlayerBase)

303. {

304. //Mem.R<float*>(PlayerBase + DwVecOrigin, true, 3, Position);

305.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(PlayerBase + 0x134), &Position, sizeof(float[3]), 0);

307. }

308. }

310. void MakeVector(float *angle, float *vector)

311. {

312. float pitch = float(angle[0] * M_PI / 180);

313. float yaw = float(angle[1] * M_PI / 180);

314. float tmp = float(cos(pitch));

315.     vector[0] = float(—tmp * —cos(yaw));

316.     vector[1] = float(sin(yaw)*tmp);

317.     vector[2] = float(—sin(pitch));

318. }

320. void CalcAngle(float *src, float *dst, float *angles)

321. {

322. double delta[3] = { (src[0] — dst[0]), (src[1] — dst[1]), (src[2] — dst[2]) };

323. double hyp = sqrt(delta[0] * delta[0] + delta[1] * delta[1]);

324.     angles[0] = atan(delta[2] / hyp) * 180.0 / PI;

325.     angles[1] = (float)(atanf(delta[1] / delta[0]) * 57.295779513082f);

326.     angles[2] = 0.0f;

328. if (delta[0] >= 0.0)

329. {

330.         angles[1] += 180.0f;

331. }

333. }

335. float GetFOV(float *Angles, float *Source, float *Dst)

336. {

337. float ang[3], aim[3];

338. float fov;

339.     CalcAngle(Source, Dst, ang);

340.     MakeVector(Angles, aim);

341.     MakeVector(ang, ang);

342. float mag_s = sqrt((aim[0] * aim[0]) + (aim[1] * aim[1]) + (aim[2] * aim[2]));

343. float mag_d = sqrt((aim[0] * aim[0]) + (aim[1] * aim[1]) + (aim[2] * aim[2]));

344. float u_dot_v = aim[0] * ang[0] + aim[1] * ang[1] + aim[2] * ang[2];

345.     fov = acos(u_dot_v / (mag_s*mag_d)) * (180.0 / 3.14159265358979323846);

346. return fov;

347. }

348. struct CompareTargetArray

349. {

350. bool operator () (TargetList_t & lhs, TargetList_t & rhs)

351. {

352. int x = lhs.Distance;

353. int y = rhs.Distance;

354. return x < y;

355. }

356. };

358. float Get3dDistance(float * myCoords, float * enemyCoords)

359. {

360. return sqrt(

361. pow(double(enemyCoords[0] — myCoords[0]), 2.0) +

362. pow(double(enemyCoords[1] — myCoords[1]), 2.0) +

363. pow(double(enemyCoords[2] — myCoords[2]), 2.0));

365. }

367. float m_vecStoreboneData[3][4];

368. void GetBonePosition(int BoneNumber, float *FloatArray){

369.     DWORD Bones;

370.     DWORD CBaseEntity;

371.     ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + dw_entitybase + (32* dw_entity_loop_distance)), &CBaseEntity, sizeof(DWORD), 0);

372.     ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(CBaseEntity + dw_bone_offset), &Bones, sizeof(DWORD), 0);

373.     ReadProcessMemory(fProcess.__HandleProcess,(PBYTE*)(Bones + BoneNumber * 0x30), &m_vecStoreboneData, sizeof(m_vecStoreboneData), NULL);

374.     FloatArray[0] = m_vecStoreboneData[0][3];

375. }

377. void Aimbot()

378. {

380.     TargetList_t * TargetList = new TargetList_t[NumOfPlayers];

381. int targetLoop = 0;

382. float EnemyXY[3];

383. float _x = 500;

384. float _y = 450;

385. int enemydistance;

386. float Fov;

387. int AimFov;

389. for (int i = 1; i < NumOfPlayers; i++)

390. {

391.         PlayerList[i].ReadInformation(i, 14);

392. if (PlayerList[i].Health < 2)

393. {

394. continue;

395. }

396. else

397. {

398.             CalcAngle(MyPlayer.Position, PlayerList[i].BonePosition, PlayerList[i].AimAngle);

400. int distanceX = Get3dDistance(MyPlayer.Position, PlayerList[i].Position);

401.                 enemydistance = distanceX;

403. if (PlayerList[i].Team != MyPlayer.Team)

404. {

405.                     TargetList[targetLoop] = TargetList_t(MyPlayer.Position, PlayerList[i].BonePosition, PlayerList[i].AimAngle);

406.                     targetLoop++;

407. }

409. }

410. }

411. //(GetKeyState(0x01)) & 0x80

412. if ((targetLoop > 0) && (GetAsyncKeyState(0x05)))

413. {

414.        std::sort(TargetList, TargetList + targetLoop, CompareTargetArray());

416. float Head[3];

417.        GetBonePosition(10, Head);

418.        MyPlayer.ReadInformation();

419.        Fov = GetFOV(MyPlayer.ViewAngle, MyPlayer.Vecview, Head);

420. cout << Fov << endl;

422. //      if (Fov < 10)

423. //      {

424.             SetAngles(TargetList[0].AimAngle);

425. //      }

426. }

427.     targetLoop = 0;

428. delete[] TargetList;

429. }

431. struct Player {

433.     DWORD dwBase;

434. int team;

435.     Vector m_vecPunch;

436.     Vector oldPunch;

437. int m_iShotsFired;

438. };

440. void RecoilControlSystem()

441. {

442. bool activated = false;

444.     Player me;

445.     me.oldPunch.x = 0;

446.     me.oldPunch.y = 0;

447. while (true)

448. {

450. if (GetAsyncKeyState(VK_NUMPAD1) & 0x8000) {

451.             activated = !activated;

452.             std::cout << «RCS «;

453. if (activated) {

454.                 std::cout << «enabled»;

455. }

456. else {

457.                 std::cout << «disabled»;

458. }

459.             std::cout << «n«;

460.             Sleep(200);

461. }

462. //  if (RCSWeapon){

463.         DWORD dwPlayer;

464.         DWORD dwEngine;// = mem.Read<DWORD>(modClient.dwBase + LocalPlayer_offset);

465. // = mem.Read<DWORD>(modEngine.dwBase + EnginePointer_offset);

466.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + dw_playerbase), &dwPlayer, sizeof(DWORD), NULL);

467.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordEngine + dw_engine_pointer), &dwEngine, sizeof(DWORD), NULL);

469.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(dwPlayer + 0x13DC), &me.m_vecPunch, sizeof(Vector), NULL);

470. //me.m_vecPunch = mem.Read<Vector>(dwPlayer + VecPunch_offset);

471.         me.m_vecPunch.x *= 2.0f;

472.         me.m_vecPunch.y *= 2.0f;

474. //me.m_iShotsFired = mem.Read<int>(dwPlayer + iShotsFired_offset);

475.         ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(dwPlayer + 0x1D58), &me.m_iShotsFired, sizeof(int), 0);

477. if (me.m_iShotsFired > 1 && activated) {

478.             Vector currentAngles; // = mem.Read<Vector>(dwEngine + SetViewAngle_offset);

479.             ReadProcessMemory(fProcess.__HandleProcess, (PBYTE*)(dwPlayer + 0x4ce0), &currentAngles, sizeof(Vector), NULL);

481.             Vector modifier = me.m_vecPunch;

482.             modifier.x —= me.oldPunch.x;

483.             modifier.y —= me.oldPunch.y;

485.             currentAngles.x —= modifier.x;

486.             currentAngles.y —= modifier.y;

488. //  mem.Write<Vector>(dwEngine + SetViewAngle_offset, currentAngles);

489.             WriteProcessMemory(fProcess.__HandleProcess, (PBYTE*)(dwEngine + dw_mouse_x), &currentAngles, sizeof(Vector), 0);

491. }

493.         me.oldPunch = me.m_vecPunch;

494. //  }

495.         Sleep(1);

496. }

497. }

499. int main()

500. {

501.     HANDLE thread_GlowESP, thread_RCSystem, thread_RCSWeapon, thread_bhop, thread_ReadInfoTriggerBot;

502.     DWORD ThreadID;

503. //thread_rcs = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)rcs, NULL, NULL, &ThreadID);

504.     fProcess.RunProcess();

505. cout << «Aimbot on!» << endl;

506. while (true)

507. {

508.         MyPlayer.ReadInformation();

509.         Aimbot();

510.         Sleep(1);

511. }

512. return 0;

513. }

Время на прочтение
11 мин

Количество просмотров 13K

В этом посте мы расскажем о процессе создания aimbot — программы, автоматически прицеливающейся во врагов в игре жанра «шутер от первого лица» (FPS). Создавать будем aimbot для игры Half-Life 2, работающей на движке Source. Aimbot будет работать внутри процесса игры и использовать для своей работы внутренние функции игры, подвергнутые реверс-инжинирингу (в отличие от других систем, работающих снаружи игры и сканирующих экран).

Для начала изучим Source SDK и используем его как руководство для реверс-инжиниринга исполняемого файла Half-Life 2. Затем мы применим полученные данные, для создания бота. К концу статьи у нас будет написан aimbot, привязывающий прицел игрока к ближайшему врагу.

▍ Реверс-инжиниринг и Source SDK

Давайте рассмотрим, как выполнить реверс-инжиниринг исполняемого файла, чтобы найти нужную нам информацию. Для создания кода, который будет автоматически прицеливаться в мишень, нужно знать следующее:

• Позицию глаз игрока
• Позицию глаз ближайшего врага
• Вектор от глаза игрока к глазу врага (получаемый по двум предыдущим пунктам)
• Способ изменения положения камеры игрока так, чтобы глаз игрока смотрел по вектору к глазу врага

Для всего, кроме третьего пункта, требуется получать информацию от состояния запущенной игры. Эту информацию получают реверс-инжинирингом игры для поиска классов, содержащих соответствующие поля. Обычно это оказывается чрезвычайно трудоёмкой задачей со множеством проб и ошибок; однако в данном случае у нас есть доступ к Source SDK, который мы используем в качестве руководства.

Начнём поиск с нахождения ссылок на позицию глаз в репозитории. Изучив несколько страниц с результатами поиска, мы выйдем на огромный класс CBaseEntity. Внутри этого класса есть две функции:

virtual Vector EyePosition(void);
virtual const QAngle &EyeAngles(void);

Так как CBaseEntity является базовым классом, от которого происходят все сущности (entity) игры, и он содержит члены для позиции глаза и углов камеры, то похоже, именно с ним нам и нужно работать. Дальше нам нужно посмотреть, откуда ссылаются на эти функции. Снова немного поискав на GitHub Source SDK, мы находим интерфейс IServerTools, у которого есть несколько весьма многообещающих функций:

virtual IServerEntity *GetIServerEntity(IClientEntity *pClientEntity) = 0;
virtual bool SnapPlayerToPosition(const Vector &org, const QAngle &ang, IClientEntity *pClientPlayer = NULL) = 0;
virtual bool GetPlayerPosition(Vector &org, QAngle &ang, IClientEntity  *pClientPlayer = NULL) = 0;

// ...

virtual CBaseEntity *FirstEntity(void) = 0;
virtual CBaseEntity *NextEntity(CBaseEntity *pEntity) = 0;

В этом интерфейсе очень удобно то, что он предоставляет доступ к позиции локального игрока, что позволяет привязать игрока к другой позиции и углу обзора, а также обеспечивает возможность итеративно обходить сущности. К тому же его экземпляр создаётся глобально и привязан к жёстко прописанной в коде строке.

#define VSERVERTOOLS_INTERFACE_VERSION_1	"VSERVERTOOLS001"
#define VSERVERTOOLS_INTERFACE_VERSION_2	"VSERVERTOOLS002"
#define VSERVERTOOLS_INTERFACE_VERSION		"VSERVERTOOLS003"
#define VSERVERTOOLS_INTERFACE_VERSION_INT	3

// ...

EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CServerTools, IServerTools001, VSERVERTOOLS_INTERFACE_VERSION_1, g_ServerTools);
EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CServerTools, IServerTools, VSERVERTOOLS_INTERFACE_VERSION, g_ServerTools);

Можем начать разработку aimbot с поиска этого класса в памяти. Запустив Half-Life 2 и подключив к нему отладчик, поищем строковые ссылки на VSERVERTOOLS.

Мы видим, откуда на них ссылаются:

7BCAB090 | 68 88FA1F7C              | push server.7C1FFA88                    | 7C1FFA88:"VSERVERTOOLS001"
7BCAB095 | 68 00C4087C              | push server.7C08C400                    |
7BCAB09A | B9 B02A337C              | mov ecx,server.7C332AB0                 |
7BCAB09F | E8 8CCA3F00              | call server.7C0A7B30                    |
7BCAB0A4 | C3                       | ret                                     |
7BCAB0A5 | CC                       | int3                                    |
7BCAB0A6 | CC                       | int3                                    |
7BCAB0A7 | CC                       | int3                                    |
7BCAB0A8 | CC                       | int3                                    |
7BCAB0A9 | CC                       | int3                                    |
7BCAB0AA | CC                       | int3                                    |
7BCAB0AB | CC                       | int3                                    |
7BCAB0AC | CC                       | int3                                    |
7BCAB0AD | CC                       | int3                                    |
7BCAB0AE | CC                       | int3                                    |
7BCAB0AF | CC                       | int3                                    |
7BCAB0B0 | 68 98FA1F7C              | push server.7C1FFA98                    | 7C1FFA98:"VSERVERTOOLS002"
7BCAB0B5 | 68 00C4087C              | push server.7C08C400                    |
7BCAB0BA | B9 BC2A337C              | mov ecx,server.7C332ABC                 |
7BCAB0BF | E8 6CCA3F00              | call server.7C0A7B30                    |
7BCAB0C4 | C3                       | ret                                     |

В ассемблерном листинге видно, что функция-член server.7C0A7B30 вызывается в server.7C332AB0 и server.7C332ABC. Эта функция получает два аргумента, один из которых — это имя-строка интерфейса. После изучения отладчика становится понятно, что второй параметр — это статический экземпляр чего-то.

Посмотрев на то, что делает в коде макрос EXPOSE_SINGLE_INTERFACE_GLOBALVAR, становится понятнее, что это синглтон CServerTools, предоставленный как глобальный интерфейс. Зная это, мы легко сможем получить указатель на этот синглтон в среде исполнения: мы просто берём адрес этой псевдофункции, перемещающей указатель в EAX, и вызываем её напрямую. Чтобы сделать это, можно написать следующий дженерик-код, который мы продолжим применять для нового использования других функций:

template <typename T>
T GetFunctionPointer(const std::string moduleName, const DWORD_PTR offset) {

    auto moduleBaseAddress{ GetModuleHandleA(moduleName.c_str()) };
    if (moduleBaseAddress == nullptr) {
        std::cerr << "Could not get base address of " << moduleName
            << std::endl;
        std::abort();
    }
    return reinterpret_cast<T>(
        reinterpret_cast<DWORD_PTR>(moduleBaseAddress) + offset);
}

IServerTools* GetServerTools() {

    constexpr auto globalServerToolsOffset{ 0x3FC400 };
    static GetServerToolsFnc getServerToolsFnc{ GetFunctionPointer<GetServerToolsFnc>(
        "server.dll", globalServerToolsOffset) };

    return getServerToolsFnc();
}

Здесь мы берём базовый адрес, в который загружена server.dll, добавляем смещение, чтобы попасть туда, откуда можно получить доступ к синглтону CServerTools, и возвращаем его как указатель вызывающей функции. Благодаря этому мы сможем вызывать нужные нам функции в интерфейсе и игра будет реагировать соответствующим образом. Нас интересуют две функции: GetPlayerPosition и SnapPlayerToPosition.

Внутри GetPlayerPosition при помощи вызова UTIL_GetLocalPlayer получается класс локального игрока, а также вызываются EyePosition и EyeAngles; внутри SnapPlayerToPosition при помощи SnapEyeAngles корректируются углы обзора игрока. Всё вместе это даёт нам то, что необходимо для получения позиций и углов обзора сущностей, благодаря чему можно выполнить соответствующие вычисления нового вектора и угла обзора, привязывающихся к глазам врагов.

Давайте разбираться по порядку, начнём с GetPlayerPosition. Так как мы можем получить указатель на IServerTools и имеем определение интерфейса, можно выполнить явный вызов GetPlayerPosition и пошагово пройтись по вызову при помощи отладчика. При этом мы попадём сюда:

7C08BEF0 | 55                       | push ebp                                |
7C08BEF1 | 8BEC                     | mov ebp,esp                             |
7C08BEF3 | 8B01                     | mov eax,dword ptr ds:[ecx]              |
7C08BEF5 | 83EC 0C                  | sub esp,C                               |
7C08BEF8 | 56                       | push esi                                |
7C08BEF9 | FF75 10                  | push dword ptr ss:[ebp+10]              |
7C08BEFC | FF50 04                  | call dword ptr ds:[eax+4]               |
7C08BEFF | 8BF0                     | mov esi,eax                             |
7C08BF01 | 85F6                     | test esi,esi                            |
7C08BF03 | 75 14                    | jne server.7C08BF19                     |
7C08BF05 | E8 E616E7FF              | call server.7BEFD5F0                    |
7C08BF0A | 8BF0                     | mov esi,eax                             |
7C08BF0C | 85F6                     | test esi,esi                            |
7C08BF0E | 75 09                    | jne server.7C08BF19                     |
7C08BF10 | 32C0                     | xor al,al                               |
7C08BF12 | 5E                       | pop esi                                 |
7C08BF13 | 8BE5                     | mov esp,ebp                             |
7C08BF15 | 5D                       | pop ebp                                 |
7C08BF16 | C2 0C00                  | ret C                                   |
7C08BF19 | 8B06                     | mov eax,dword ptr ds:[esi]              |
7C08BF1B | 8D4D F4                  | lea ecx,dword ptr ss:[ebp-C]            |
7C08BF1E | 51                       | push ecx                                |
7C08BF1F | 8BCE                     | mov ecx,esi                             |
7C08BF21 | FF90 08020000            | call dword ptr ds:[eax+208]             |
7C08BF27 | 8B4D 08                  | mov ecx,dword ptr ss:[ebp+8]            |
7C08BF2A | D900                     | fld st(0),dword ptr ds:[eax]            |
7C08BF2C | D919                     | fstp dword ptr ds:[ecx],st(0)           |
7C08BF2E | D940 04                  | fld st(0),dword ptr ds:[eax+4]          |
7C08BF31 | D959 04                  | fstp dword ptr ds:[ecx+4],st(0)         |
7C08BF34 | D940 08                  | fld st(0),dword ptr ds:[eax+8]          |
7C08BF37 | 8B06                     | mov eax,dword ptr ds:[esi]              |
7C08BF39 | D959 08                  | fstp dword ptr ds:[ecx+8],st(0)         |
7C08BF3C | 8BCE                     | mov ecx,esi                             |
7C08BF3E | FF90 0C020000            | call dword ptr ds:[eax+20C]             |
7C08BF44 | 8B4D 0C                  | mov ecx,dword ptr ss:[ebp+C]            |
7C08BF47 | 5E                       | pop esi                                 |
7C08BF48 | D900                     | fld st(0),dword ptr ds:[eax]            |
7C08BF4A | D919                     | fstp dword ptr ds:[ecx],st(0)           |
7C08BF4C | D940 04                  | fld st(0),dword ptr ds:[eax+4]          |
7C08BF4F | D959 04                  | fstp dword ptr ds:[ecx+4],st(0)         |
7C08BF52 | D940 08                  | fld st(0),dword ptr ds:[eax+8]          |
7C08BF55 | B0 01                    | mov al,1                                |
7C08BF57 | D959 08                  | fstp dword ptr ds:[ecx+8],st(0)         |
7C08BF5A | 8BE5                     | mov esp,ebp                             |
7C08BF5C | 5D                       | pop ebp                                 |
7C08BF5D | C2 0C00                  | ret C                                   |

Разбираться в этом довольно долго, однако в виде графа потока управления всё выглядит довольно просто:

Если построчно сопоставить дизассемблированную программу с кодом, то мы достаточно быстро найдём необходимое. Код вызывает функцию UTIL_GetLocalPlayer только тогда, когда переданный параметр pClientEntity равен null. Эта логика проверяется в блоке первой функции графа. Если существует действительная клиентская сущность, код переходит к получению позиции и углов глаза для неё, а в противном случае получает сущность локального игрока. Этот вызов происходит при исполнении команды call server.7BEFD5F0 по адресу server.7C08BF05. Как и ранее, мы можем создать указатель функции на UTIL_GetLocalPlayer и вызывать её напрямую.

CBasePlayer* GetLocalPlayer() {

    constexpr auto globalGetLocalPlayerOffset{ 0x26D5F0 };
    static GetLocalPlayerFnc getLocalPlayerFnc{ GetFunctionPointer<GetLocalPlayerFnc>(
        "server.dll", globalGetLocalPlayerOffset) };

    return getLocalPlayerFnc();
}

Следующими в дизассемблированном коде идут вызовы функций EyePosition и EyeAngles. Нас интересует только получение позиций глаза, поэтому важен только первый вызов. Для получения адреса функции мы можем пошагово пройти по вызову, пока не вызовем адрес, находящийся в [EAX+0x208]. После исполнения этой команды мы перейдём на server.dll+0x119D00, таким образом узнав, где находится функция.

Vector GetEyePosition(CBaseEntity* entity) {
    
    constexpr auto globalGetEyePositionOffset{ 0x119D00 };
    static GetEyePositionFnc getEyePositionFnc{ GetFunctionPointer<GetEyePositionFnc>(
        "server.dll", globalGetEyePositionOffset) };

    return getEyePositionFnc(entity);
}

И это всё, что нам нужно от GetPlayerPosition; теперь у нас есть возможность получения указателя локальной сущности игрока и получения позиции глаза сущности. Последнее, что нам потребуется — возможность задания угла обзора игрока. Как говорилось выше, это можно сделать, вызвав функцию SnapPlayerToPosition и посмотрев, где находится функция SnapEyeAngles. Дизассемблированный код SnapEyeAngles выглядит следующим образом:

7C08C360 | 55                       | push ebp                                |
7C08C361 | 8BEC                     | mov ebp,esp                             |
7C08C363 | 8B01                     | mov eax,dword ptr ds:[ecx]              |
7C08C365 | 83EC 0C                  | sub esp,C                               |
7C08C368 | 56                       | push esi                                |
7C08C369 | FF75 10                  | push dword ptr ss:[ebp+10]              |
7C08C36C | FF50 04                  | call dword ptr ds:[eax+4]               |
7C08C36F | 8BF0                     | mov esi,eax                             |
7C08C371 | 85F6                     | test esi,esi                            |
7C08C373 | 75 14                    | jne server.7C08C389                     |
7C08C375 | E8 7612E7FF              | call server.7BEFD5F0                    |
7C08C37A | 8BF0                     | mov esi,eax                             |
7C08C37C | 85F6                     | test esi,esi                            |
7C08C37E | 75 09                    | jne server.7C08C389                     |
7C08C380 | 32C0                     | xor al,al                               |
7C08C382 | 5E                       | pop esi                                 |
7C08C383 | 8BE5                     | mov esp,ebp                             |
7C08C385 | 5D                       | pop ebp                                 |
7C08C386 | C2 0C00                  | ret C                                   |
7C08C389 | 8B06                     | mov eax,dword ptr ds:[esi]              |
7C08C38B | 8BCE                     | mov ecx,esi                             |
7C08C38D | FF90 24020000            | call dword ptr ds:[eax+224]             |
7C08C393 | 8B4D 08                  | mov ecx,dword ptr ss:[ebp+8]            |
7C08C396 | F3:0F1001                | movss xmm0,dword ptr ds:[ecx]           |
7C08C39A | F3:0F5C00                | subss xmm0,dword ptr ds:[eax]           |
7C08C39E | F3:0F1145 F4             | movss dword ptr ss:[ebp-C],xmm0         |
7C08C3A3 | F3:0F1041 04             | movss xmm0,dword ptr ds:[ecx+4]         |
7C08C3A8 | F3:0F5C40 04             | subss xmm0,dword ptr ds:[eax+4]         |
7C08C3AD | F3:0F1145 F8             | movss dword ptr ss:[ebp-8],xmm0         |
7C08C3B2 | F3:0F1041 08             | movss xmm0,dword ptr ds:[ecx+8]         |
7C08C3B7 | 8BCE                     | mov ecx,esi                             |
7C08C3B9 | F3:0F5C40 08             | subss xmm0,dword ptr ds:[eax+8]         |
7C08C3BE | 8D45 F4                  | lea eax,dword ptr ss:[ebp-C]            |
7C08C3C1 | 50                       | push eax                                |
7C08C3C2 | F3:0F1145 FC             | movss dword ptr ss:[ebp-4],xmm0         |
7C08C3C7 | E8 14CFD0FF              | call server.7BD992E0                    |
7C08C3CC | FF75 0C                  | push dword ptr ss:[ebp+C]               |
7C08C3CF | 8BCE                     | mov ecx,esi                             |
7C08C3D1 | E8 4A0FE0FF              | call server.7BE8D320                    |
7C08C3D6 | 8B06                     | mov eax,dword ptr ds:[esi]              |
7C08C3D8 | 8BCE                     | mov ecx,esi                             |
7C08C3DA | 6A FF                    | push FFFFFFFF                           |
7C08C3DC | 6A 00                    | push 0                                  |
7C08C3DE | FF90 88000000            | call dword ptr ds:[eax+88]              |
7C08C3E4 | B0 01                    | mov al,1                                |
7C08C3E6 | 5E                       | pop esi                                 |
7C08C3E7 | 8BE5                     | mov esp,ebp                             |
7C08C3E9 | 5D                       | pop ebp                                 |
7C08C3EA | C2 0C00                  | ret C                                   |

Повторив уже описанный выше процесс, мы выясним, что команда call server.7BE8D320 является вызовом SnapEyeAngles. Мы можем определить следующую функцию:

void SnapEyeAngles(CBasePlayer* player, const QAngle& angles)
{
    constexpr auto globalSnapEyeAnglesOffset{ 0x1FD320 };
    static SnapEyeAnglesFnc snapEyeAnglesFnc{ GetFunctionPointer<SnapEyeAnglesFnc>(
        "server.dll", globalSnapEyeAnglesOffset) };

    return snapEyeAnglesFnc(player, angles);
}

Итак, теперь у нас есть всё необходимое.

▍ Создание aimbot

Для создания aimbot нам нужно следующее:

• Итеративно обойти сущности
  • Если сущность является врагом, то найти расстояние между сущностью и игроком
  • Отслеживать ближайшую сущность
• Вычислить вектор «глаз-глаз» между игроком и ближайшим врагом
• Корректировать углы глаза игрока так, чтобы он следовал за этим вектором

Ранее мы узнали, что для получения позиции игрока можно вызвать GetPlayerPosition. Для циклического обхода списка сущностей можно вызвать FirstEntity и NextEntity, которые возвращают указатель на экземпляр CBaseEntity. Чтобы понять, является ли сущность врагом, можно сравнить имя сущности со множеством имён враждебных NPC-сущностей. Если мы получили сущность врага, то вычисляем расстояние между игроком и сущностью и сохраняем позицию сущности, если она ближайшая из всех, пока найденных нами.

После итеративного обхода всего списка сущностей мы получаем ближайшего врага, вычисляем вектор «глаз-глаз» и корректируем углы глаза игрока при помощи функции VectorAngles.

В виде кода получим следующее:

auto* serverEntity{ reinterpret_cast<IServerEntity*>(
    GetServerTools()->FirstEntity()) };

if (serverEntity != nullptr) {
    do {
        if (serverEntity == GetServerTools()->FirstEntity()) {

            SetPlayerEyeAnglesToPosition(closestEnemyVector);
            closestEnemyDistance = std::numeric_limits<float>::max();
            closestEnemyVector = GetFurthestVector();
        }

        auto* modelName{ serverEntity->GetModelName().ToCStr() };
        if (modelName != nullptr) {
            auto entityName{ std::string{GetEntityName(serverEntity)} };

            if (IsEntityEnemy(entityName)) {
                Vector eyePosition{};
                QAngle eyeAngles{};

                GetServerTools()->GetPlayerPosition(eyePosition, eyeAngles);

                auto enemyEyePosition{ GetEyePosition(serverEntity) };

                auto distance{ VectorDistance(enemyEyePosition, eyePosition) };
                if (distance <= closestEnemyDistance) {
                    closestEnemyDistance = distance;
                    closestEnemyVector = enemyEyePosition;
                }
            }
        }

        serverEntity = reinterpret_cast<IServerEntity*>(
            GetServerTools()->NextEntity(serverEntity));

    } while (serverEntity != nullptr);
}

В коде есть несколько вспомогательных функций, которые мы ранее не рассматривали: функция GetFurthestVector возвращает вектор с максимальными значениями float в полях x, y и z; GetEntityName возвращает имя сущности в виде строки, получая член m_iName экземпляра CBaseEntity; а IsEntityEnemy просто сверяет имя сущности со множеством враждебных NPC.

Векторные вычисления и расчёт нового угла обзора происходят в показанной ниже SetPlayerEyeAnglesToPosition:

void SetPlayerEyeAnglesToPosition(const Vector& enemyEyePosition) {

    Vector eyePosition{};
    QAngle eyeAngles{};
    GetServerTools()->GetPlayerPosition(eyePosition, eyeAngles);

    Vector forwardVector{ enemyEyePosition.x - eyePosition.x,
        enemyEyePosition.y - eyePosition.y,
        enemyEyePosition.z - eyePosition.z
    };

    VectorNormalize(forwardVector);

    QAngle newEyeAngles{};
    VectorAngles(forwardVector, newEyeAngles);

    SnapEyeAngles(GetLocalPlayer(), newEyeAngles);
}

Эта функция вычисляет вектор «глаз-глаз», вычитая из вектора позиции глаза врага вектор позиции глаза игрока. Затем этот новый вектор нормализуется и передаётся функции VectorAngles для вычисления новых углов обзора. Затем углы глаза игрока корректируются под эти новые углы, что должно создавать эффект слежения за сущностью.

Как это выглядит в действии?

Вы видите почти прозрачный прицел, следующий за головой идущего по комнате NPC. Когда NPC отходит достаточно далеко, код выполняет привязку к более близкому NPC. Всё работает!

▍ Заключение

Описанные в статье методики в общем случае применимы к любой игре жанра FPS. Способ получения позиций и углов может различаться в разных игровых движках, однако векторные вычисления для создания угла обзора из вектора расстояния применимы в любом случае.

Реверс-инжиниринг Half-Life 2 был сильно упрощён открытостью Source SDK. Возможность сопоставления кода и структур данных с ассемблерным кодом существенно упростила отладку, однако обычно такого везения не бывает! Надеюсь, эта статья помогла вам понять, как работают aimbot и показала, что создавать их не очень сложно.

Полный исходный код aimbot выложен на GitHub, можете свободно с ним экспериментировать.