Advertisement
Guest User

Untitled

a guest
Feb 18th, 2020
117
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 16.30 KB | None | 0 0
  1. #include "Anti-aim.hpp"
  2.  
  3. #include "../../menu/menu.hpp"
  4. #include "../../menu/menu.hpp"
  5. bool Switch = false;
  6.  
  7. CAntiAim g_AntiAim;
  8.  
  9. bool IsStandingCheck(CUserCmd* pCmd)
  10. {
  11. return ((Globals::localPlayer->velocity().Length2D() < 36) && (Globals::localPlayer->flags() & FL_ONGROUND) /*&& && !Globals::isSlowWalking*/);
  12. }
  13.  
  14. bool IsMovingCheck(CUserCmd* pCmd)
  15. {
  16. return ((Globals::localPlayer->velocity().Length2D() > 36) && (Globals::localPlayer->flags() & FL_ONGROUND) && !Globals::isSlowWalking);
  17. }
  18.  
  19. bool IsInAirCheck(CUserCmd* pCmd)
  20. {
  21. //return (((pCmd->buttons & IN_JUMP) && (!(Globals::localPlayer->flags() & FL_ONGROUND))) || (!(Globals::localPlayer->flags() & FL_ONGROUND) && !Globals::isSlowWalking));
  22. return (!(Globals::localPlayer->flags() & FL_ONGROUND) && !Globals::isSlowWalking);
  23. }
  24.  
  25. bool IsSlowWalkingCheck(CUserCmd* pCmd)
  26. {
  27. return ((Globals::isSlowWalking) && (Globals::localPlayer->flags() & FL_ONGROUND));
  28. }
  29.  
  30. void CAntiAim::onMove(CUserCmd* userCmd)
  31. {
  32. if (!g_Interfaces->gameEngine->inGame() && !g_Interfaces->gameEngine->connected()) {
  33. Globals::desyncEnabledSpecialChecks = false;
  34. return;
  35. }
  36.  
  37. if (!config->get_bool("aaEnable")) {
  38. Globals::desyncEnabledSpecialChecks = false;
  39. return;
  40. }
  41.  
  42. if (Globals::disableAA) {
  43. Globals::desyncEnabledSpecialChecks = false;
  44. return;
  45. }
  46.  
  47. if (!Globals::localPlayer->alive()) {
  48. Globals::desyncEnabledSpecialChecks = false;
  49. return;
  50. }
  51.  
  52. if (Globals::oCmd->buttons & IN_USE) {
  53. Globals::desyncEnabledSpecialChecks = false;
  54. return;
  55. }
  56.  
  57. if (!Globals::localPlayer->activeWeapon() || Globals::localPlayer->isNade()) {
  58. Globals::desyncEnabledSpecialChecks = false;
  59. return;
  60. }
  61.  
  62. if (Globals::localPlayer->moveType() == movetype_ladder /*|| Globals::localPlayer->moveType( ) == movetype_noclip */) {
  63. Globals::desyncEnabledSpecialChecks = false;
  64. return;
  65. }
  66.  
  67. if (Globals::localPlayer->activeWeapon()->itemDefenitionIndex() == weapon_revolver)
  68. {
  69. if (userCmd->buttons & IN_ATTACK2) {
  70. Globals::desyncEnabledSpecialChecks = false;
  71. return;
  72. }
  73.  
  74. if (Globals::localPlayer->activeWeapon()->canFirePostpone() && (userCmd->buttons & IN_ATTACK)) {
  75. Globals::desyncEnabledSpecialChecks = false;
  76. return;
  77. }
  78. }
  79.  
  80. float serverTime = Globals::localPlayer->tickBase() * g_Interfaces->globalVars->intervalPerTick;
  81. float canShoot = Globals::localPlayer->activeWeapon()->nextPrimaryAttack() <= serverTime;
  82.  
  83. if (canShoot && (Globals::oCmd->buttons & IN_ATTACK)) {
  84. Globals::desyncEnabledSpecialChecks = false;
  85. return;
  86. }
  87.  
  88. /* dont blame me, this shit is so we can feel the 180z experience(lol) even when freestanding :sunglasses: */
  89.  
  90. if (Globals::bSendPacket)
  91. Switch = !Switch;
  92.  
  93.  
  94. pitch(userCmd);
  95.  
  96. //yaw(userCmd);
  97.  
  98. if (config->get_int("aaDesync"))
  99. desync_initialize(userCmd);
  100. else
  101. yaw(userCmd);
  102. }
  103.  
  104. void CAntiAim::pitch(CUserCmd* pCmd)
  105. {
  106. if (config->get_bool("miscAntiUT")) // anti-untrusted
  107. {
  108. if (IsStandingCheck(pCmd))
  109. { // standing
  110. switch (config->get_int("aaStandingPitch"))
  111. {
  112. case 1: pitch_down(pCmd); break;
  113. case 2: pitch_up(pCmd); break;
  114. case 3: pitch_zero(pCmd); break;
  115. case 4: pitch_jitter(pCmd); break;
  116. }
  117. }
  118. else if (IsMovingCheck(pCmd))
  119. { // moving
  120. switch (config->get_int("aaMovingPitch"))
  121. {
  122. case 1: pitch_down(pCmd); break;
  123. case 2: pitch_up(pCmd); break;
  124. case 3: pitch_zero(pCmd); break;
  125. case 4: pitch_jitter(pCmd); break;
  126. }
  127. }
  128. else if (IsInAirCheck(pCmd))
  129. { // in-air
  130. switch (config->get_int("aaInAirPitch"))
  131. {
  132. case 1: pitch_down(pCmd); break;
  133. case 2: pitch_up(pCmd); break;
  134. case 3: pitch_zero(pCmd); break;
  135. case 4: pitch_jitter(pCmd); break;
  136. }
  137. }
  138. /*else
  139. { // is slow walking
  140. switch (config->get_int("aaSlowWalkPitch"))
  141. {
  142. case 1: pitch_down(pCmd); break;
  143. case 2: pitch_up(pCmd); break;
  144. case 3: pitch_zero(pCmd); break;
  145. case 4: pitch_jitter(pCmd); break;
  146. }
  147. }*/
  148. }
  149. else
  150. {
  151. if (IsStandingCheck(pCmd))
  152. { // standing
  153. switch (config->get_int("aaStandingPitch"))
  154. {
  155. case 1: pitch_fake_down(pCmd); break;
  156. case 2: pitch_fake_up(pCmd); break;
  157. case 3: pitch_fake_zero(pCmd); break;
  158. case 4: pitch_fake_jitter(pCmd); break;
  159. }
  160. }
  161. else if (IsMovingCheck(pCmd))
  162. { // moving
  163. switch (config->get_int("aaMovingPitch"))
  164. {
  165. case 1: pitch_fake_down(pCmd); break;
  166. case 2: pitch_fake_up(pCmd); break;
  167. case 3: pitch_fake_zero(pCmd); break;
  168. case 4: pitch_fake_jitter(pCmd); break;
  169. }
  170. }
  171. else if (IsInAirCheck(pCmd))
  172. { // in-air
  173. switch (config->get_int("aaInAirPitch"))
  174. {
  175. case 1: pitch_fake_down(pCmd); break;
  176. case 2: pitch_fake_up(pCmd); break;
  177. case 3: pitch_fake_zero(pCmd); break;
  178. case 4: pitch_fake_jitter(pCmd); break;
  179. }
  180. }
  181. /*else
  182. { // is slow walking
  183. switch (config->get_int("aaSlowWalkPitch"))
  184. {
  185. case 1: pitch_fake_down(pCmd); break;
  186. case 2: pitch_fake_up(pCmd); break;
  187. case 3: pitch_fake_zero(pCmd); break;
  188. case 4: pitch_fake_jitter(pCmd); break;
  189. }
  190. }*/
  191. }
  192. }
  193.  
  194. void CAntiAim::yaw(CUserCmd* pCmd)
  195. {
  196. if (IsStandingCheck(pCmd))
  197. { // standing
  198. if (config->get_bool("aaStandingAutoDir"))
  199. yaw_autoDirection(pCmd);
  200. else
  201. {
  202. switch (config->get_int("aaStandingYaw"))
  203. {
  204. case 0: { } break;
  205. case 1: { yaw_backwards(pCmd); } break;
  206. case 2: { yaw_sideways(pCmd); } break;
  207. }
  208. }
  209.  
  210. if (config->get_int("aaStandingJitterType") == 1)
  211. pCmd->viewAngles.y += rand() % (int)config->get_int("aaStandingJitterRange"); // jitter
  212. else if (config->get_int("aaStandingJitterType") == 2)
  213. pCmd->viewAngles.y += rand() % 179 + 1; // jitter
  214. }
  215. if (IsMovingCheck(pCmd))
  216. { // moving
  217. if (config->get_bool("aaMovingAutoDir"))
  218. yaw_autoDirection(pCmd);
  219. else
  220. {
  221. switch (config->get_int("aaMovingYaw"))
  222. {
  223. case 0: { } break;
  224. case 1: { yaw_backwards(pCmd); } break;
  225. case 2: { yaw_sideways(pCmd); } break;
  226. }
  227. }
  228. if (config->get_int("aaMovingJitterType") == 1)
  229. pCmd->viewAngles.y += rand() % (int)config->get_int("aaMovingJitterRange"); // jitter
  230. else if (config->get_int("aaMovingJitterType") == 2)
  231. pCmd->viewAngles.y += rand() % 179 + 1; // jitter
  232. }
  233. if (IsInAirCheck(pCmd))
  234. { // in-air
  235. if (config->get_bool("aaInAirAutoDir"))
  236. yaw_autoDirection(pCmd);
  237. else
  238. {
  239. switch (config->get_int("aaInAirYaw"))
  240. {
  241. case 0: { } break;
  242. case 1: { yaw_backwards(pCmd); } break;
  243. case 2: { yaw_sideways(pCmd); } break;
  244. }
  245. }
  246.  
  247. if (config->get_int("aaInAirJitterType") == 1)
  248. pCmd->viewAngles.y += rand() % (int)config->get_int("aaInAirJitterRange"); // jitter
  249. else if (config->get_int("aaInAirJitterType") == 2)
  250. pCmd->viewAngles.y += rand() % 179 + 1; // jitter
  251. }
  252. /*else
  253. { // is slow walking
  254. if (config->get_bool("aaSlowWalkAutoDir"))
  255. 1;
  256. else
  257. {
  258. switch (config->get_int("aaSlowWalkYaw"))
  259. {
  260. case 0: { } break;
  261. case 1: { yaw_backwards(pCmd); } break;
  262. case 2: { yaw_sideways(pCmd); } break;
  263. }
  264.  
  265. if (config->get_int("aaSlowWalkJitterType") > 0 && config->get_int("aaSlowWalkJitterRange") > 0) // should jitter?
  266. pCmd->viewAngles += rand() % (int)config->get_int("aaSlowWalkJitterRange"); // jitter
  267. }
  268. }*/
  269. }
  270.  
  271. float get_curtime(CUserCmd* ucmd) {
  272. auto local_player = Globals::localPlayer;
  273.  
  274. if (!local_player)
  275. return 0;
  276.  
  277. int g_tick = 0;
  278. CUserCmd* g_pLastCmd = nullptr;
  279. if (!g_pLastCmd || g_pLastCmd->hasbeenPredicted) {
  280. g_tick = (float)local_player->tickBase();
  281. }
  282. else {
  283. ++g_tick;
  284. }
  285. g_pLastCmd = ucmd;
  286. float curtime = g_tick * g_Interfaces->globalVars->intervalPerTick;
  287. return curtime;
  288. }
  289. bool next_lby_update(const float yaw_to_break, CUserCmd* cmd)
  290. {
  291. auto local_player = Globals::localPlayer;
  292.  
  293. if (!local_player)
  294. return false;
  295.  
  296. static float next_lby_update_time = 0;
  297. float curtime = get_curtime(cmd);
  298.  
  299. auto animstate = local_player->animState();
  300. if (!animstate)
  301. return false;
  302.  
  303. if (!(local_player->flags() & FL_ONGROUND))
  304. return false;
  305.  
  306. if (animstate->speed_2d > 0.1)
  307. next_lby_update_time = curtime + 0.22f;
  308.  
  309. if (next_lby_update_time < curtime)
  310. {
  311. next_lby_update_time = curtime + 1.1f;
  312. return true;
  313. }
  314.  
  315. return false;
  316. }
  317.  
  318. bool next_lby_update2(CUserCmd* cmd)
  319. {
  320. auto local_player = Globals::localPlayer;
  321.  
  322. if (!local_player)
  323. return false;
  324.  
  325. static float next_lby_update_time = 0;
  326. float curtime = get_curtime(cmd);
  327.  
  328. auto animstate = local_player->animState();
  329. if (!animstate)
  330. return false;
  331.  
  332. if (!(local_player->flags() & FL_ONGROUND))
  333. return false;
  334.  
  335. if (animstate->speed_2d > 0.1)
  336. next_lby_update_time = curtime + 0.22f;
  337.  
  338. if (next_lby_update_time < curtime)
  339. {
  340. next_lby_update_time = curtime + 1.1f;
  341. return true;
  342. }
  343.  
  344. return false;
  345. }
  346.  
  347. // _ _ _
  348. // _ __ (_)| |_ ___ | |__
  349. //| '_ \ | || __| / __|| '_ \
  350. //| |_) || || |_ | (__ | | | |
  351. //| .__/ |_| \__| \___||_| |_|
  352. //|_|
  353.  
  354. void CAntiAim::pitch_down(CUserCmd* cmd)
  355. {
  356. cmd->viewAngles.x = 89.f;
  357. }
  358.  
  359. void CAntiAim::pitch_fake_down(CUserCmd* cmd)
  360. {
  361. cmd->viewAngles.x = -991;
  362. }
  363.  
  364. void CAntiAim::pitch_up(CUserCmd* cmd)
  365. {
  366. cmd->viewAngles.x = -89.f;
  367. }
  368.  
  369. void CAntiAim::pitch_fake_up(CUserCmd* cmd)
  370. {
  371. cmd->viewAngles.x = 991;
  372. }
  373.  
  374. void CAntiAim::pitch_zero(CUserCmd* cmd)
  375. {
  376. cmd->viewAngles.x = 0.f;
  377. }
  378. void CAntiAim::pitch_fake_zero(CUserCmd* cmd)
  379. {
  380. cmd->viewAngles.x = 1080.f;
  381. }
  382.  
  383. void CAntiAim::pitch_jitter(CUserCmd* cmd)
  384. {
  385. bool jitter = false;
  386. if (jitter)
  387. jitter != jitter;
  388. else
  389. jitter != jitter;
  390.  
  391. cmd->viewAngles.x = jitter ? -89.0 : 89.0;
  392. }
  393.  
  394. void CAntiAim::pitch_fake_jitter(CUserCmd* cmd)
  395. {
  396. bool jitter = false;
  397. if (jitter)
  398. jitter != jitter;
  399. else
  400. jitter != jitter;
  401.  
  402. cmd->viewAngles.x = jitter ? 991.0 : -991.0;
  403. }
  404.  
  405.  
  406. // _ _ __ _ __ __
  407. //| | | | / _` |\ \ /\ / /
  408. //| |_| || (_| | \ V V /
  409. // \__, | \__,_| \_/\_/
  410. // |___/
  411.  
  412. void CAntiAim::yaw_backwards(CUserCmd* cmd)
  413. {
  414. cmd->viewAngles.y += 180;
  415. }
  416.  
  417. void CAntiAim::yaw_sideways(CUserCmd* cmd)
  418. {
  419. if (menu->get_hotkey("aaFlipKey"))
  420. cmd->viewAngles.y += 90;
  421. else
  422. cmd->viewAngles.y -= 90;
  423. }
  424.  
  425. void CAntiAim::yaw_autoDirection( CUserCmd* cmd )
  426. {
  427. static float FinalAngle;
  428. bool bside1 = false;
  429. bool bside2 = false;
  430. bool autowalld = false;
  431. for (int i = 0; i <= g_Interfaces->globalVars->maxClients; ++i)
  432. {
  433. CBaseEntity* pPlayerEntity = g_Interfaces->clientEntity->GetClientEntity(i);
  434.  
  435. if (!pPlayerEntity
  436. || !pPlayerEntity->alive()
  437. || pPlayerEntity->IsDormant()
  438. || pPlayerEntity == Globals::localPlayer
  439. || pPlayerEntity->team() == Globals::localPlayer->team())
  440. continue;
  441.  
  442. float angToLocal = g_Math.calcAngle(Globals::localPlayer->GetOrigin(), pPlayerEntity->GetOrigin()).y;
  443. Vector3 ViewPoint = pPlayerEntity->GetOrigin() + Vector3(0, 0, 90);
  444.  
  445. Vector2 Side1 = { (45 * sin(g_Math.GRD_TO_BOG(angToLocal))),(45 * cos(g_Math.GRD_TO_BOG(angToLocal))) };
  446. Vector2 Side2 = { (45 * sin(g_Math.GRD_TO_BOG(angToLocal + 180))) ,(45 * cos(g_Math.GRD_TO_BOG(angToLocal + 180))) };
  447.  
  448. Vector2 Side3 = { (50 * sin(g_Math.GRD_TO_BOG(angToLocal))),(50 * cos(g_Math.GRD_TO_BOG(angToLocal))) };
  449. Vector2 Side4 = { (50 * sin(g_Math.GRD_TO_BOG(angToLocal + 180))) ,(50 * cos(g_Math.GRD_TO_BOG(angToLocal + 180))) };
  450.  
  451. Vector3 Origin = Globals::localPlayer->GetOrigin();
  452.  
  453. Vector2 OriginLeftRight[] = { Vector2(Side1.x, Side1.y), Vector2(Side2.x, Side2.y) };
  454.  
  455. Vector2 OriginLeftRightLocal[] = { Vector2(Side3.x, Side3.y), Vector2(Side4.x, Side4.y) };
  456.  
  457. for (int side = 0; side < 2; side++)
  458. {
  459. Vector3 OriginAutowall = { Origin.x + OriginLeftRight[side].x, Origin.y - OriginLeftRight[side].y , Origin.z + 80 };
  460. Vector3 OriginAutowall2 = { ViewPoint.x + OriginLeftRightLocal[side].x, ViewPoint.y - OriginLeftRightLocal[side].y , ViewPoint.z };
  461.  
  462. if (g_Autowall.CanHitFloatingPoint(OriginAutowall, ViewPoint))
  463. {
  464. if (side == 0)
  465. {
  466. bside1 = true;
  467. FinalAngle = angToLocal + 90;
  468. }
  469. else if (side == 1)
  470. {
  471. bside2 = true;
  472. FinalAngle = angToLocal - 90;
  473. }
  474. autowalld = true;
  475. }
  476. else
  477. {
  478. for (int side222 = 0; side222 < 2; side222++)
  479. {
  480. Vector3 OriginAutowall222 = { Origin.x + OriginLeftRight[side222].x, Origin.y - OriginLeftRight[side222].y , Origin.z + 80 };
  481.  
  482. if (g_Autowall.CanHitFloatingPoint(OriginAutowall222, OriginAutowall2))
  483. {
  484. if (side222 == 0)
  485. {
  486. bside1 = true;
  487. FinalAngle = angToLocal + 90;
  488. }
  489. else if (side222 == 1)
  490. {
  491. bside2 = true;
  492. FinalAngle = angToLocal - 90;
  493. }
  494. autowalld = true;
  495. }
  496. }
  497. }
  498. }
  499. }
  500. if (!autowalld || (bside1 && bside2))
  501. cmd->viewAngles.y += 180;
  502. else
  503. cmd->viewAngles.y += FinalAngle;
  504. }
  505.  
  506. void CAntiAim::breakLby( ) //polak
  507. {
  508. // anti-paste
  509. }
  510.  
  511. float dget_fixed_feet_yaw() {
  512.  
  513. float current_feet_yaw = *(float*)(Globals::localPlayer->animState() + 0x80);
  514.  
  515. if (current_feet_yaw >= -360)
  516. current_feet_yaw = min(current_feet_yaw, 360.0);
  517.  
  518. return current_feet_yaw;
  519. }
  520. float dmax_desync_angle() {
  521. auto local_player = Globals::localPlayer;
  522. auto animstate = uintptr_t(local_player->animState());
  523.  
  524. float duckammount = *(float*)(animstate + 0xA4);
  525. float speedfraction = max(0, min(*reinterpret_cast<float*>(animstate + 0xF8), 1));
  526.  
  527. float speedfactor = max(0, min(1, *reinterpret_cast<float*> (animstate + 0xFC)));
  528.  
  529. float unk1 = ((*reinterpret_cast<float*> (animstate + 0x11C) * -0.30000001) - 0.19999999) * speedfraction;
  530. float unk2 = unk1 + 1.f;
  531. float unk3;
  532.  
  533. if (duckammount > 0)
  534. unk2 += ((duckammount * speedfactor) * (0.5f - unk2));
  535.  
  536. unk3 = *(float*)(animstate + 0x334) * unk2;
  537.  
  538. return unk3;
  539. }
  540. float dquick_normalize(float degree, const float min, const float max) {
  541. while (degree < min)
  542. degree += max - min;
  543. while (degree > max)
  544. degree -= max - min;
  545.  
  546. return degree;
  547. }
  548. float BalanceDumpedFromPolak(CUserCmd* cmd, int type)
  549. {
  550. auto net_channel = *reinterpret_cast<NetChannel * *>(reinterpret_cast<std::uintptr_t>(g_Interfaces->clientState) + 0x9C);
  551.  
  552. float desync = dmax_desync_angle();
  553. float balance = 1.0f;
  554. if (type == 2)
  555. balance = -1.0f;
  556.  
  557. if (g_Interfaces->globalVars->curtime <= next_lby_update2(cmd)) {
  558. if (net_channel->m_nChokedPackets >= 2)
  559. return dquick_normalize(cmd->viewAngles.y, -180.f, 180.f);
  560.  
  561. if (type == 1)
  562. return -100.0f;
  563. else
  564. return +(balance * 120.0f);
  565. }
  566. else if (type != 1) {
  567. return -((desync + 30.0f) * balance);
  568. }
  569. }
  570.  
  571. int m_iJitter = 0;
  572. void CAntiAim::desync_initialize(CUserCmd* cmd)
  573. {
  574. // if ( Globals::localPlayer->animState( ) && Globals::bSendPacket && g_Interfaces->clientState->ChokedCommands )
  575. if (config->get_bool("aaDesync"))
  576. {
  577. bool invert;
  578. float balance = 1.0f;
  579. int type = rand() % 2;
  580. if (type == 2)
  581. balance = -1.0f;
  582.  
  583.  
  584. if (next_lby_update(cmd->viewAngles.y, cmd)) {
  585.  
  586. if (type == 1)
  587. cmd->viewAngles.y -= 180.0f;
  588. else
  589. cmd->viewAngles.y += (balance * 60.0f);
  590. }
  591.  
  592. else if (type != 1) {
  593. int jitter_side = invert ? 1 : -1;
  594. cmd->viewAngles.y += 180.0f;
  595. float desync = dmax_desync_angle();
  596. float lby_delta = 60.0f - desync + 58.0f;
  597. float desync_length = 60.0f - lby_delta * 60.0f;
  598. float jitter = 60.0f * jitter_side;
  599. auto net_channel = *reinterpret_cast<NetChannel * *>(reinterpret_cast<std::uintptr_t>(g_Interfaces->clientState) + 0x9C);
  600.  
  601. if (!net_channel)
  602. return;
  603. if (net_channel->m_nChokedPackets >= 10) {
  604. cmd->viewAngles.y = g_Math.normalizeYaw(cmd->viewAngles.y);
  605. return;
  606. }
  607. if (jitter_side == 1)
  608. cmd->viewAngles.y += desync_length;
  609.  
  610. else if (jitter_side == -1)
  611. cmd->viewAngles.y -= desync_length;
  612.  
  613.  
  614.  
  615.  
  616. int v19 = 0;
  617. if (g_Interfaces->globalVars->curtime < g_Interfaces->globalVars->curtime <= next_lby_update(cmd->viewAngles.y, cmd)) {
  618. v19 = rand() % 30;
  619. }
  620. else {
  621. m_iJitter = 0;
  622. }
  623.  
  624. int v20 = v19 - 1;
  625. if (v20) {
  626. if (v20 == 1) {
  627. if (jitter_side == 1)
  628. cmd->viewAngles.y += lby_delta;
  629. else
  630. cmd->viewAngles.y += desync - 68;
  631. }
  632. }
  633. else {
  634. if (jitter_side == 1)
  635. cmd->viewAngles.y += desync - 68;
  636. else
  637. cmd->viewAngles.y += lby_delta;
  638. Globals::bSendPacket = false;
  639. }
  640.  
  641. if (++m_iJitter >= 3)
  642. m_iJitter = 0;
  643.  
  644. cmd->viewAngles.y = g_Math.normalizeYaw(cmd->viewAngles.y);
  645. }
  646. }
  647. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement