API tools faq
paste
Advertisement
Dream1337

Untitled

Dream1337
Aug 21st, 2017
116
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 19.12 KB | None | 0 0
raw download clone embed print report
  1. #include "Resolver.h"
  2. #include "RenderManager.h"
  3.  
  4. #define LC_NONE 0
  5. #define LC_ALIVE (1<<0)
  6.  
  7. #define LC_ORIGIN_CHANGED (1<<8)
  8. #define LC_ANGLES_CHANGED (1<<9)
  9. #define LC_SIZE_CHANGED (1<<10)
  10. #define LC_ANIMATION_CHANGED (1<<11)
  11.  
  12. #define LAG_COMPENSATION_TELEPORTED_DISTANCE_SQR ( 64.0f * 64.0f )
  13. #define LAG_COMPENSATION_EPS_SQR ( 1.5f * 1.5f )
  14. #define LAG_COMPENSATION_ERROR_EPS_SQR ( 5.0f * 5.0f )
  15.  
  16. extern int bullets;
  17. float tickcount;
  18. float YawDelta[64];
  19. float reset[64];
  20. float Delta[64];
  21. float OldLowerBodyYaw[64];
  22. float Resolved_angles[64];
  23. int iSmart;
  24. static int jitter = -1;
  25.  
  26. int Globals::Shots = 0;
  27. bool Globals::change;
  28. CUserCmd* Globals::UserCmd;
  29. int Globals::TargetID;
  30. IClientEntity* Globals::Target;
  31.  
  32.  
  33.  
  34.  
  35. void R::Resolve()
  36. {
  37. IClientEntity *pLocal = Interfaces::EntList->GetClientEntity(Interfaces::Engine->GetLocalPlayer());
  38.  
  39. for (int i = 0; i < Interfaces::Engine->GetMaxClients(); ++i)
  40. {
  41. IClientEntity *pEntity = Interfaces::EntList->GetClientEntity(i);
  42.  
  43. if (!pEntity || pEntity->IsDormant() || !pEntity->IsAlive())
  44. continue;
  45.  
  46. if (pEntity->GetTeamNum() == pLocal->GetTeamNum() || !pLocal->IsAlive())
  47. continue;
  48.  
  49. Vector* eyeAngles = pEntity->GetEyeAnglesPointer();
  50.  
  51.  
  52. if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 9)
  53. {
  54. if (pEntity != Globals::Target) continue;
  55.  
  56. Vector AimAngle;
  57. CalcAngleYawOnly(pEntity->GetEyePosition(), pLocal->GetAbsOrigin2(), AimAngle);
  58. NormalizeVector(AimAngle);
  59. static float StoredYaw = 0;
  60. static bool bLowerBodyIsUpdated = false;
  61. if (pEntity->GetLowerBodyYaw() != StoredYaw) bLowerBodyIsUpdated = true;
  62. else bLowerBodyIsUpdated = false;
  63. if (bLowerBodyIsUpdated) StoredYaw = pEntity->GetLowerBodyYaw();
  64. if (pEntity->GetFlags() & FL_ONGROUND && pEntity->GetVelocity().Length2D() != 0) eyeAngles->y = pEntity->GetLowerBodyYaw();
  65. else
  66. {
  67. if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 1)
  68. {
  69. int value = rand() % 10;
  70. switch (value) {
  71. case 0:eyeAngles->y = AimAngle.y; break;
  72. case 1:eyeAngles->y += 0; break;
  73. case 2:eyeAngles->y = AimAngle.y + 180; break;
  74. case 3:eyeAngles->y += 15; break;
  75. case 4:eyeAngles->y = AimAngle.y + 90; break;
  76. case 5:eyeAngles->y -= 15; break;
  77. case 6:eyeAngles->y = AimAngle.y + 270; break;
  78. case 7:eyeAngles->y += 0; break;
  79. case 8:eyeAngles->y = AimAngle.y + 180; break;
  80. case 9:eyeAngles->y -= 45; break;
  81. case 10:eyeAngles->y += 45; break;
  82. break;
  83. }
  84. }
  85. }
  86. break;
  87. if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 2)
  88. {
  89. int num = Globals::Shots % 5;
  90. switch (num) {
  91. case 0:eyeAngles->y = AimAngle.y - 0; break;
  92. case 1:eyeAngles->y = AimAngle.y - 15; break;
  93. case 2:eyeAngles->y = AimAngle.y + 40; break;
  94. case 3:eyeAngles->y = AimAngle.y - 40; break;
  95. case 4:eyeAngles->y = AimAngle.y + 15; break;
  96. }
  97. }
  98. break;
  99. if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 3)
  100. {
  101. int num = Globals::Shots % 4;
  102. switch (num) {
  103. case 0:eyeAngles->y = rand() % 360; break;
  104. case 1:eyeAngles->y = 0; break;
  105. case 2:eyeAngles->y = rand() % 180; break;
  106. case 3:eyeAngles->y = 180; break;// te reso zle jest?
  107. break;
  108. }
  109. }
  110. break;
  111. if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 4)
  112. {
  113. for (int i = 0; i < 64; ++i)
  114. {
  115. IClientEntity* ent = Interfaces::EntList->GetClientEntity(i);
  116.  
  117. if (!ent || !ent->IsAlive())
  118. continue;
  119.  
  120. *(float*)((uintptr_t)ent + 0xAA08 + 4) += Delta[i];
  121. reset[i] = *(float*)((uintptr_t)ent + 0xAA08 + 4);
  122.  
  123. float LowerBodyYaw = *(float*)((uintptr_t)ent + 0x39F8);
  124.  
  125. if (OldLowerBodyYaw[i] != LowerBodyYaw)
  126. {
  127. YawDelta[i] = reset[i] - LowerBodyYaw;
  128. OldLowerBodyYaw[i] = LowerBodyYaw;
  129. *(float*)((uintptr_t)ent + 0xAA08 + 4) = LowerBodyYaw;
  130. }
  131. else
  132. {
  133. *(float*)((uintptr_t)ent + 0xAA08 + 4) = reset[i] - YawDelta[i];
  134.  
  135. while (*(float*)((uintptr_t)ent + 0xAA08 + 4) < -180.0f)
  136. *(float*)((uintptr_t)ent + 0xAA08 + 4) += 360.0f;
  137.  
  138. while (*(float*)((uintptr_t)ent + 0xAA08 + 4) > 180.0f)
  139. *(float*)((uintptr_t)ent + 0xAA08 + 4) -= 360.0f;
  140. }
  141. Resolved_angles[i] = *(float*)((uintptr_t)ent + 0xAA08 + 4);
  142. }
  143. }
  144. break;
  145. if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 5)
  146. {
  147. IClientEntity* ent = Interfaces::EntList->GetClientEntity(i);
  148.  
  149. for (int i = 0; i < 32; i++) {
  150. if (!pEntity || !pEntity->IsAlive() || !(pEntity->GetEyeAngles().y >= 85.f && pEntity->GetEyeAngles().y <= 89.f))
  151. continue;
  152.  
  153. float CurYaw = pEntity->GetLowerBodyYaw();
  154. if (OldLowerBodyYaw[i] != CurYaw) {
  155. Delta[i] = pEntity->GetEyeAngles().y - CurYaw;
  156. OldLowerBodyYaw[i] = CurYaw;
  157. *(float*)((uintptr_t)ent + 0xAA08 + 4) = CurYaw;
  158. continue;
  159. }
  160. else {
  161. *(float*)((uintptr_t)ent + 0xAA08 + 4) = pEntity->GetEyeAngles().y - Delta[i];
  162. }
  163.  
  164. float yClamped = pEntity->GetEyeAngles().y;
  165. while (yClamped < -180.0f)
  166. yClamped += 360.0f;
  167.  
  168. while (yClamped > 180.0f)
  169. yClamped -= 360.0f;
  170. *(float*)((uintptr_t)ent + 0xAA08 + 4) = yClamped;
  171. }
  172. Resolved_angles[i] = *(float*)((uintptr_t)ent + 0xAA08 + 4);
  173. }
  174. break;
  175. if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 6)
  176. {
  177. int value = rand() % 3 + 0;
  178. switch (value)
  179. {
  180. case 0:
  181. {
  182. eyeAngles->y = (rand() % 180);
  183. break;
  184. }
  185. case 1:
  186. {
  187. eyeAngles->y = (rand() % 360);
  188. break;
  189. }
  190. case 2:
  191. {
  192. eyeAngles->y = 0;
  193. break;
  194. }
  195. }
  196. break;
  197. }
  198. if(Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 7)
  199. {
  200. int value = rand() % 10;
  201. switch (value) {
  202. case 0:eyeAngles->y = eyeAngles->y; break;
  203. case 1:eyeAngles->y += 0; break;
  204. case 2:eyeAngles->y = eyeAngles->y + 180; break;
  205. case 3:eyeAngles->y += 15; break;
  206. case 4:eyeAngles->y = eyeAngles->y + 90; break;
  207. case 5:eyeAngles->y -= 15; break;
  208. case 6:eyeAngles->y = eyeAngles->y + 270; break;
  209. case 7:eyeAngles->y += 0; break;
  210. case 8:eyeAngles->y = eyeAngles->y + 180; break;
  211. case 9:eyeAngles->y -= 45; break;
  212. case 10:eyeAngles->y += 45; break;
  213. break;
  214. }
  215. break;
  216. }
  217. if (Menu::Window.RageBotTab.AccuracyResolverPitch.GetIndex() == 1)
  218. {
  219. int shoots = Globals::Shots;
  220. int value = shoots % 9;
  221. int num = rand() % 5;
  222. switch (value && num) {
  223. case 0:eyeAngles->x = -50; break;
  224. case 1:eyeAngles->x = +50; rand(); break;
  225. case 2:eyeAngles->x = -89; break;
  226. case 3:eyeAngles->x = +89; rand(); break;
  227. case 4:eyeAngles->x = -90; break;
  228. case 5:eyeAngles->x = +90; rand(); break;
  229. break;
  230. }
  231. }
  232. if (Menu::Window.RageBotTab.AccuracyResolverPitch.GetIndex() == 2)
  233. {
  234. int shoots = Globals::Shots;
  235. int value = shoots % 9;
  236. int num = rand() % 5;
  237. switch (value && num) {
  238. case 0:eyeAngles->x = 89.f;
  239. case 1:eyeAngles->x = 89.f;
  240. case 2:eyeAngles->x = -89.f;
  241. }
  242. }
  243. }
  244. }
  245. }
  246. /*
  247. static void pNormalizeAngle(float& flAngle)
  248. {
  249. if (std::isnan(flAngle)) flAngle = 0.0f;
  250. if (std::isinf(flAngle)) flAngle = 0.0f;
  251.  
  252. float flRevolutions = flAngle / 360;
  253.  
  254. if (flAngle > 180 || flAngle < -180)
  255. {
  256. if (flRevolutions < 0)
  257. flRevolutions = -flRevolutions;
  258.  
  259. flRevolutions = round(flRevolutions);
  260.  
  261. if (flAngle < 0)
  262. flAngle = (flAngle + 360 * flRevolutions);
  263. else
  264. flAngle = (flAngle - 360 * flRevolutions);
  265. }
  266. }
  267.  
  268. static void pNormalizeAngles(QAngle &angles)
  269. {
  270. pNormalizeAngle(angles.x);
  271. pNormalizeAngle(angles.y);
  272. angles.z = 0;
  273. }
  274.  
  275. static void pClampAngles(QAngle &angles)
  276. {
  277. if (std::isnan(angles.x)) angles.x = 0.0f;
  278. if (std::isnan(angles.y)) angles.y = 0.0f;
  279. if (std::isnan(angles.z)) angles.z = 0.0f;
  280. if (std::isinf(angles.x)) angles.x = 0.0f;
  281. if (std::isinf(angles.y)) angles.y = 0.0f;
  282. if (std::isinf(angles.z)) angles.z = 0.0f;
  283.  
  284. if (angles.x > 89.0f && angles.x <= 180.0f)
  285. angles.x = 89.0f;
  286. while (angles.x > 180.0f)
  287. angles.x -= 360.0f;
  288. while (angles.x < -89.0f)
  289. angles.x = -89.0f;
  290. while (angles.y > 180.0f)
  291. angles.y -= 360.0f;
  292. while (angles.y < -180.0f)
  293. angles.y += 360.0f;
  294.  
  295. angles.z = 0;
  296. }
  297. static void pClamp(QAngle &angles)
  298. {
  299. pNormalizeAngles(angles);
  300. pClampAngles(angles);
  301. }
  302.  
  303. int GetLowsestDenominator(int a, int b)
  304. {
  305. for (int i = 2; i <= min(a, b); i++)
  306. if ((a % i == 0) && (b % i == 0)) { return i; }
  307. return 1;
  308. }
  309.  
  310. int GetServerSideID(int EntityIndex)
  311. {
  312. player_info_t pInfo;
  313. Interfaces::Engine->GetPlayerInfo(EntityIndex, &pInfo);
  314. return pInfo.userID;
  315. }
  316. void R::Other(CUserCmd *pCmd, bool &bSendPacket, unsigned int vguiPanel,int viewangles, unsigned __int8 swap)
  317. {
  318.  
  319. static unsigned int FocusOverlayPanel = 0;
  320. static bool FoundPanel = false;
  321.  
  322. IClientEntity* pLocal = hackManager.pLocal();
  323.  
  324. if (Menu::Window.ResolverTab.AntiResolver.GetIndex() == 4)
  325. {
  326. {
  327. static bool antiResolverFlip = false;
  328. if (pCmd->viewangles.y == pLocal->GetVelocity().Length() > 0.f)
  329. {
  330. if (antiResolverFlip && pLocal->GetVelocity().Length() > 0.f)
  331. pCmd->viewangles.y += 90.f;
  332. else
  333. pCmd->viewangles.y -= 90.f;
  334. antiResolverFlip = !antiResolverFlip;
  335. }
  336. }
  337. if (Menu::Window.ResolverTab.AccuracyResolverr.GetState())
  338. {
  339. {
  340. bool result; // al@4
  341. unsigned __int8 byte_100AA52C;
  342. unsigned __int8 byte_100AFD00;
  343. unsigned __int8 byte_100AFD08;
  344. unsigned __int8 byte_100AFD01;
  345. unsigned __int8 dword_100AFABC;
  346. unsigned __int8 byte_100AFD09;
  347. unsigned __int8 dword_100AFAB8;
  348. unsigned __int8 sub_10004CA0;
  349.  
  350.  
  351. if (sub_10004CA0)
  352. {
  353. if (byte_100AA52C)
  354. {
  355. if (byte_100AFD00)
  356. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) - 226.0;
  357. else
  358. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) - 134.0;
  359. result = byte_100AFD00 == 0;
  360. byte_100AFD00 = byte_100AFD00 == 0;
  361. }
  362. else
  363. {
  364. if (byte_100AFD01)
  365. {
  366. result = viewangles;
  367. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) - 134.0;
  368. }
  369. else
  370. {
  371. result = viewangles;
  372. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) - 226.0;
  373. }
  374. byte_100AFD01 = byte_100AFD01 == 0;
  375. }
  376. }
  377. else if (++dword_100AFABC == 1)
  378. {
  379. byte_100AA52C = 0;
  380. if (byte_100AFD09)
  381. {
  382. result = viewangles;
  383. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) - 134.0;
  384. }
  385. else
  386. {
  387. result = viewangles;
  388. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) - 226.0;
  389. }
  390. byte_100AFD09 = byte_100AFD09 == 0;
  391. }
  392. else
  393. {
  394. byte_100AA52C = 1;
  395. if (byte_100AFD08)
  396. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) - 226.0;
  397. else
  398. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) - 134.0;
  399. result = byte_100AFD08 == 0;
  400. byte_100AFD08 = byte_100AFD08 == 0;
  401. dword_100AFABC = 0;
  402. }
  403. }
  404. if (Menu::Window.ResolverTab.AccuracyResolverr.GetState())
  405. {
  406. int result; // eax@1
  407.  
  408. result = swap;
  409. if (swap)
  410. *(DWORD *)(viewangles + 12) = -89;
  411. else
  412. *(DWORD *)(viewangles + 12) = 89;
  413. return;
  414. }
  415. if (Menu::Window.ResolverTab.AccuracyResolverr.GetState())
  416. {
  417. int result; // eax@1
  418. unsigned __int8 byte_100AA52C;
  419. unsigned __int8 dword_100AFAA8;
  420. unsigned __int8 sub_10004CA0;
  421.  
  422. if ((BYTE)result)
  423. {
  424. result = (unsigned __int8)byte_100AA52C;
  425. if (byte_100AA52C)
  426. {
  427. result = viewangles;
  428. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) + 90.0;
  429. }
  430. else
  431. {
  432. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) - 90.0;
  433. }
  434. }
  435. else if (++dword_100AFAA8 == 1)
  436. {
  437. byte_100AA52C = 0;
  438. result = viewangles;
  439. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) - 90.0;
  440. }
  441. else
  442. {
  443. byte_100AA52C = 1;
  444. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) + 90.0;
  445. dword_100AFAA8 = 0;
  446. }
  447. return;
  448. }
  449. if (Menu::Window.ResolverTab.AccuracyResolverr.GetState())
  450. {
  451. {
  452. int v1; // eax@1
  453. int result; // eax@1
  454. signed __int64 v3; // rtt@1
  455. float v4; // xmm0_4@4
  456. float v5; // xmm0_4@6
  457. signed int v6; // [sp+8h] [bp-4h]@1
  458.  
  459. v1 = rand();
  460. v3 = v1;
  461. result = v1 / 100;
  462. v6 = v3 % 100;
  463. if (v6 < 98)
  464. {
  465. result = viewangles;
  466. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) - 180.0;
  467. }
  468. if (v6 < 15)
  469. {
  470. v4 = *(float *)(viewangles + 16) + (float)(rand() % 141 - 70);
  471. result = viewangles;
  472. *(float *)(viewangles + 16) = v4;
  473. }
  474. if (v6 == 69)
  475. {
  476. v5 = *(float *)(viewangles + 16) + (float)(rand() % 181 - 90);
  477. result = viewangles;
  478. *(float *)(viewangles + 16) = v5;
  479. }
  480. return;
  481. }
  482. }
  483. if (Menu::Window.ResolverTab.AccuracyResolverr.GetState())
  484. {
  485. int result; // eax@1
  486. unsigned __int8 byte_100AA52C;
  487. unsigned __int8 dword_100AFAB8;
  488. unsigned __int8 sub_10004CA0;
  489.  
  490.  
  491. if ((BYTE)result)
  492. {
  493. result = (unsigned __int8)byte_100AA52C;
  494. if (byte_100AA52C)
  495. {
  496. result = viewangles;
  497. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) + 0.0;
  498. }
  499. else
  500. {
  501. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) + 180.0;
  502. }
  503. }
  504. else if (++dword_100AFAB8 == 1)
  505. {
  506. byte_100AA52C = 0;
  507. result = viewangles;
  508. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) + 180.0;
  509. }
  510. else
  511. {
  512. byte_100AA52C = 1;
  513. *(float *)(viewangles + 16) = *(float *)(viewangles + 16) + 0.0;
  514. dword_100AFAB8 = 0;
  515. }
  516. return;
  517. }
  518. }
  519. }
  520. }
  521. void pNormalize(float& angle) {
  522. while (angle > 180.f) {
  523. angle -= 360.f;
  524. }
  525. while (angle < -180.f) {
  526. angle += 360.f;
  527. }
  528. }
  529. void FixYaw(const CRecvProxyData *pData, void *pStruct, void *pOut)
  530. {
  531. IClientEntity *pLocal = Interfaces::EntList->GetClientEntity(Interfaces::Engine->GetLocalPlayer());
  532. static Vector vLast[65];
  533. static bool bShotLastTime[65];
  534. static bool bJitterFix[65];
  535.  
  536. float *flPitch = (float*)((DWORD)pOut - 4);
  537. float flYaw = pData->m_Value.m_Float;
  538. bool bHasAA;
  539. bool bSpinbot;
  540. static bool last[128];
  541. bool tmp = last[((IClientEntity*)(pStruct))->GetIndex()];
  542. float yaw = pData->m_Value.m_Float;
  543.  
  544. if (Menu::Window.ResolverTab.AccuracyResolverr.GetState())
  545. {
  546. for (int i = 0; i < Interfaces::EntList->GetHighestEntityIndex(); ++i)
  547. {
  548. IClientEntity *pEntity = Interfaces::EntList->GetClientEntity(i);
  549.  
  550. flYaw = pEntity->GetLowerBodyYaw(); //Sets entity's eye angles to their current LBY
  551. }
  552. }
  553. else if (Menu::Window.ResolverTab.AccuracyResolverr.GetState())
  554. {
  555. for (int i = 0; i < Interfaces::EntList->GetHighestEntityIndex(); ++i)
  556. {
  557. IClientEntity *pEntity = Interfaces::EntList->GetClientEntity(i);
  558.  
  559. static float lowerDelta[64];
  560. static float lastYaw[64];
  561.  
  562. float curLower = pEntity->GetLowerBodyYaw();
  563. float curYaw = flYaw;
  564.  
  565. lowerDelta[i] = curYaw - curLower;
  566. pNormalize(lowerDelta[i]);
  567.  
  568. if (fabs(lowerDelta[i]) > 15.f) {
  569. if (pEntity->GetVelocity().Length() > 0.1f) //If the entity is moving, Set EyeAngles to LBY. LBY Updates when moving.
  570. {
  571. flYaw = pEntity->GetLowerBodyYaw();
  572. }
  573. else
  574. {
  575. if (curYaw != lastYaw[i])
  576. {
  577. flYaw += lowerDelta[i];
  578. lastYaw[i] = curYaw;
  579. }
  580. }
  581. }
  582. }
  583. }
  584. else if (Menu::Window.ResolverTab.AccuracyResolverr.GetState())
  585. {
  586. for (int i = 0; i < Interfaces::EntList->GetHighestEntityIndex(); ++i)
  587. {
  588. IClientEntity *pEntity = Interfaces::EntList->GetClientEntity(i);
  589.  
  590. static float OldLowerBodyYaws[64];
  591. static float OldYawDeltas[64];
  592.  
  593. float CurYaw = pEntity->GetLowerBodyYaw();
  594.  
  595. if (OldLowerBodyYaws[i] != CurYaw)
  596. {
  597. OldYawDeltas[i] = flYaw - CurYaw;
  598. OldLowerBodyYaws[i] = CurYaw;
  599. flYaw = CurYaw;
  600. continue;
  601. }
  602. else
  603. {
  604. flYaw = flYaw - OldYawDeltas[i];
  605. }
  606. }
  607. }
  608. else if (Menu::Window.ResolverTab.AccuracyResolverr.GetState())
  609. {
  610. static bool flip;
  611.  
  612. for (int i = 0; i < Interfaces::EntList->GetHighestEntityIndex(); ++i)
  613. {
  614. IClientEntity *pEntity = Interfaces::EntList->GetClientEntity(i);
  615.  
  616. if (!pEntity->GetVelocity().Length() > 0.1f)
  617. {
  618. float flCurTime = Interfaces::Globals->curtime;
  619. static float flTimeUpdate = 0.5f;
  620. static float flNextTimeUpdate = flCurTime + flTimeUpdate;
  621.  
  622. if (flCurTime >= flNextTimeUpdate)
  623. {
  624. flip != flip;
  625. }
  626.  
  627. if (flNextTimeUpdate < flCurTime || flNextTimeUpdate - flCurTime > 10.f)
  628. flNextTimeUpdate = flCurTime + flTimeUpdate;
  629.  
  630. if (flip)
  631. {
  632. flYaw += 35.f;
  633. }
  634. else {
  635. flYaw -= 35.f;
  636. }
  637. }
  638.  
  639. flYaw;
  640. }
  641.  
  642. *(float*)(pOut) = flYaw;
  643. }
  644. else if (Menu::Window.ResolverTab.AccuracyResolverr.GetState())
  645. {
  646. // Anglefix
  647. bHasAA = ((*flPitch == 90.0f) || (*flPitch == 270.0f));
  648. bSpinbot = false;
  649.  
  650. if (!bShotLastTime[((IClientEntity*)(pStruct))->GetIndex()]
  651. && (fabsf(flYaw - vLast[((IClientEntity*)(pStruct))->GetIndex()].y) > 15.0f) && !bHasAA)
  652. {
  653. flYaw = vLast[((IClientEntity*)(pStruct))->GetIndex()].y;
  654. bShotLastTime[((IClientEntity*)(pStruct))->GetIndex()] = true;
  655. }
  656. else
  657. {
  658. if (bShotLastTime[((IClientEntity*)(pStruct))->GetIndex()]
  659. && (fabsf(flYaw - vLast[((IClientEntity*)(pStruct))->GetIndex()].y) > 15.0f))
  660. {
  661. bShotLastTime[((IClientEntity*)(pStruct))->GetIndex()] = true;
  662. bSpinbot = true;
  663. }
  664. else
  665. {
  666. bShotLastTime[((IClientEntity*)(pStruct))->GetIndex()] = false;
  667. }
  668. }
  669.  
  670. vLast[((IClientEntity*)(pStruct))->GetIndex()].y = flYaw;
  671.  
  672.  
  673. bool bTmp = bJitterFix[((IClientEntity*)(pStruct))->GetIndex()];
  674.  
  675. bJitterFix[((IClientEntity*)(pStruct))->GetIndex()] = (flYaw >= 180.0f && flYaw <= 360.0f);
  676.  
  677. if (bTmp && (flYaw >= 0.0f && flYaw <= 180.0f))
  678. {
  679. flYaw += 359.0f;
  680. }
  681.  
  682. }
  683.  
  684. *(float*)(pOut) = flYaw;
  685. }
  686.  
  687.  
  688. void FixPitch(const CRecvProxyData *pData, void *pStruct, void *pOut)
  689. {
  690. float p = pData->m_Value.m_Float;
  691.  
  692. if (!Menu::Window.ResolverTab.AccuracyResolverr.GetState())
  693. if(pNormalize)
  694. {
  695. if (p > 89.0f && p < 91.0f)
  696. p -= 90.0f;
  697. else if (p > -89.0f && p < -91.0f)
  698. p += 90.0f;
  699.  
  700. if (p > 179.0f && p < 181.0f)
  701. p -= 180.0f;
  702.  
  703. else if (p > -179.0f && p < -181.0f)
  704. p += 180.0f;
  705.  
  706. }
  707. *(float*)pOut = p;
  708. }
  709. void Resolverapp()
  710. {
  711. ClientClass *pClass = Interfaces::Client->GetAllClasses();
  712. while (pClass)
  713. {
  714. const char *pszName = pClass->m_pRecvTable->m_pNetTableName;
  715. if (!strcmp(pszName, "DT_CSPlayer"))
  716. {
  717. for (int i = 0; i < pClass->m_pRecvTable->m_nProps; i++)
  718. {
  719. RecvProp *pProp = &(pClass->m_pRecvTable->m_pProps[i]);
  720. const char *name = pProp->m_pVarName;
  721.  
  722. // Pitch Fix
  723. if (!strcmp(name, "m_angEyeAngles[0]"))
  724. {
  725. pProp->m_ProxyFn = FixPitch;
  726. }
  727.  
  728. // Yaw Fix
  729. if (!strcmp(name, "m_angEyeAngles[1]"))
  730. {
  731.  
  732. pProp->m_ProxyFn = FixYaw;
  733. }
  734. }
  735. }
  736. }
  737. }
  738. */
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!