API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 18th, 2018
91
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 21.49 KB | None | 0 0
raw download clone embed print report
  1. #include "sdk.h"
  2. #include "Resolver.h"
  3. #include "global.h"
  4. #include "BacktrackingHelper.h"
  5. #include "Math.h"
  6. #include "GameUtils.h"
  7. #include "Menu.h"
  8. CResolver2* g_Resolver = new CResolver2;
  9.  
  10. bool did_hs[64];
  11. bool did_hit[64];
  12. int hit_tick;
  13. int hit_tick2;
  14. bool ran_thru_resolverfloat ;
  15. float moving_vals[32];
  16. float storedlby[32];
  17.  
  18.  
  19. #define TICK_INTERVAL ( g_pGlobals->interval_per_tick )
  20. #define TIME_TO_TICKS( dt ) ( (int)( 0.5f + (float)(dt) / TICK_INTERVAL ) )
  21. #define TICKS_TO_TIME( t ) ( TICK_INTERVAL *( t ) )
  22. float logged_hits[64];
  23.  
  24. int KillsPerRound;
  25. int GetServerSideID(int CBaseEntityIndex)
  26. {
  27. player_info_t pInfo;
  28. g_pEngine->GetPlayerInfo(CBaseEntityIndex, &pInfo);
  29. return pInfo.m_nUserID;
  30. }
  31.  
  32.  
  33.  
  34. CResolver2::CTickRecord::CTickRecord(CBaseEntity* ent, int tickcount)
  35. {
  36. m_flLowerBodyYawTarget = ent->LowerBodyYaw();
  37. m_angEyeAngles = ent->GetEyeAngles();
  38. m_flCycle = ent->GetCycle();
  39. m_flSimulationTime = ent->GetSimulationTime();
  40. m_nSequence = ent->GetSequence();
  41. m_vecOrigin = ent->GetOrigin();
  42. m_vecVelocity = ent->GetVelocity();
  43. // m_flPoseParameter = ent->GetPoseParameters();
  44. m_angAbsAngles = ent->GetAbsAngles();
  45. m_vecAbsOrigin = ent->GetOrigin();
  46. this->tickcount = tickcount;
  47. }
  48. CResolver2::CTickRecord::CTickRecord(CBaseEntity* ent, Vector EyeAngles, float LowerBodyYaw)
  49. {
  50. m_flLowerBodyYawTarget = LowerBodyYaw;
  51. m_angEyeAngles = EyeAngles;//ent->GetEyeAngles();
  52. m_flCycle = ent->GetCycle();
  53. m_flSimulationTime = ent->GetSimulationTime();
  54. m_nSequence = ent->GetSequence();
  55. m_vecOrigin = ent->GetOrigin();
  56. m_vecVelocity = ent->GetVelocity();
  57. // m_flPoseParameter = ent->GetPoseParameters();
  58. m_angAbsAngles = ent->GetAbsAngles();
  59. m_vecAbsOrigin = ent->GetOrigin();
  60. tickcount = G::UserCmdForBacktracking->tick_count;
  61. }
  62. float tolerance = 10.f;
  63.  
  64. const inline float LBYDelta(const CResolver2::CTickRecord& v) {
  65. return v.m_angEyeAngles.y - v.m_flLowerBodyYawTarget;
  66. }
  67.  
  68. bool HasStaticRealAngle(const std::deque<CResolver2::CTickRecord>& l, float tolerance) {
  69. auto minmax = std::minmax_element(std::begin(l), std::end(l), [](const CResolver2::CTickRecord& t1, const CResolver2::CTickRecord& t2) { return t1.m_flLowerBodyYawTarget < t2.m_flLowerBodyYawTarget; });
  70. return (fabs(minmax.first->m_flLowerBodyYawTarget - minmax.second->m_flLowerBodyYawTarget) <= tolerance);
  71. }
  72.  
  73. bool HasStaticYawDifference(const std::deque<CResolver2::CTickRecord>& l, float tolerance) {
  74. for (auto i = l.begin(); i < l.end() - 1;)
  75. {
  76. if (GetDelta(LBYDelta(*i), LBYDelta(*++i)) > tolerance)
  77. return false;
  78. }
  79. return true;
  80. }
  81.  
  82. bool HasSteadyDifference(const std::deque<CResolver2::CTickRecord>& l, float tolerance, CBaseEntity* pEnt) {
  83. size_t misses = 0;
  84. for (size_t i = 0; i < l.size() - 1; i++) {
  85. float tickdif = static_cast<float>(l.at(i).m_flSimulationTime - l.at(i + 1).tickcount);
  86. float lbydif = GetDelta(l.at(i).m_flLowerBodyYawTarget, l.at(i + 1).m_flLowerBodyYawTarget);
  87. float ntickdif = static_cast<float>(G::UserCmdForBacktracking->tick_count - l.at(i).tickcount);
  88. if (((lbydif / tickdif) * ntickdif) > tolerance)
  89. misses++;
  90. }
  91. return (misses <= (l.size() / 3));
  92. }
  93. int GetDifferentDeltas(const std::deque<CResolver2::CTickRecord>& l, float tolerance) {
  94. std::vector<float> vec;
  95. for (auto var : l) {
  96. float curdelta = LBYDelta(var);
  97. bool add = true;
  98. for (auto fl : vec) {
  99. if (!IsDifferent(curdelta, fl, tolerance))
  100. add = false;
  101. }
  102. if (add)
  103. vec.push_back(curdelta);
  104. }
  105. return vec.size();
  106. }
  107.  
  108. int GetDifferentLBYs(const std::deque<CResolver2::CTickRecord>& l, float tolerance) {
  109. std::vector<float> vec;
  110. for (auto var : l)
  111. {
  112. float curyaw = var.m_flLowerBodyYawTarget;
  113. bool add = true;
  114. for (auto fl : vec)
  115. {
  116. if (!IsDifferent(curyaw, fl, tolerance))
  117. add = false;
  118. }
  119. if (add)
  120. vec.push_back(curyaw);
  121. }
  122. return vec.size();
  123. }
  124. float GetLBYByComparingTicks(const std::deque<CResolver2::CTickRecord>& l, CBaseEntity* pEnt)
  125. {
  126. int modulo = 1;//;Config->GetValue<int>("Resolver", "Modulo");
  127. int difangles = GetDifferentLBYs(l, tolerance);
  128. int inc = modulo * difangles;
  129. for (auto var : l)
  130. {
  131. for (int lasttick = var.tickcount; lasttick < G::UserCmdForBacktracking->tick_count; lasttick += inc)
  132. {
  133. if (lasttick == G::UserCmdForBacktracking->tick_count)
  134. return var.m_flLowerBodyYawTarget;
  135. }
  136. }
  137. return 0.f;
  138. }
  139.  
  140. float GetDeltaByComparingTicks(const std::deque<CResolver2::CTickRecord>& l, CBaseEntity* pEnt) {
  141. int modulo = 1;// Config->GetValue<int>("Resolver", "Modulo");
  142. int difangles = GetDifferentDeltas(l, tolerance);
  143. int inc = modulo * difangles;
  144. for (auto var : l)
  145. {
  146. for (int lasttick = var.tickcount; lasttick < G::UserCmdForBacktracking->tick_count; lasttick += inc) {
  147. if (lasttick == G::UserCmdForBacktracking->tick_count)
  148. return LBYDelta(var);
  149. }
  150. }
  151. return 0.f;
  152. }
  153. bool DeltaKeepsChanging(const std::deque<CResolver2::CTickRecord>& cur, float tolerance) {
  154. return (GetDifferentDeltas(cur, tolerance) >(int) cur.size() / 2);
  155. }
  156.  
  157. bool LBYKeepsChanging(const std::deque<CResolver2::CTickRecord>& cur, float tolerance) {
  158. return (GetDifferentLBYs(cur, tolerance) > (int)cur.size() / 2);
  159. }
  160.  
  161.  
  162.  
  163. void CResolver::Resolve_Bruteforce(CBaseEntity* pEntity, float org_yaw) {
  164. auto getdst = [](int a, int b) {
  165. int x = abs(b - a) % 360;
  166. return x > 180 ? 360 - x : x;
  167. };
  168.  
  169. auto record = Backtracking->arr_infos.at(pEntity->GetIndex());
  170.  
  171. int avg = 1;
  172. int count = 1;
  173.  
  174. float prevlby = 0.f;
  175.  
  176. for (auto& r : record.TickRecords) {
  177. if (r.m_flLowerBodyYawTarget == prevlby)
  178. continue;
  179.  
  180. prevlby = r.m_flLowerBodyYawTarget;
  181.  
  182. avg += getdst(static_cast<int>(r.m_angEyeAngles.y), static_cast<int>(r.m_flLowerBodyYawTarget));
  183.  
  184. count++;
  185. }
  186.  
  187. avg /= count;
  188.  
  189. float add = 0;
  190.  
  191. if (avg > 145)
  192. add = 180;
  193. else if (avg > 110)
  194. add = 135;
  195. else if (avg > 75)
  196. add = 90;
  197. else if (avg > 40)
  198. add = 45;
  199.  
  200. pEntity->GetEyeAnglesPtr()->y += (G::UserCmd->command_number % 2) ? add : -add;
  201. pEntity->GetEyeAnglesPtr()->y = ClampYaw(pEntity->GetEyeAngles().y);
  202. }
  203.  
  204. void CResolver::Resolve_Predict(CBaseEntity* pEntity, float org_yaw) {
  205. auto record = Backtracking->arr_infos.at(pEntity->GetIndex());
  206.  
  207. float prevlby = 0.f;
  208.  
  209. int avg = 1;
  210. int count = 1;
  211.  
  212. for (auto& r : record.TickRecords) {
  213. if (r.m_flLowerBodyYawTarget == prevlby)
  214. continue;
  215.  
  216. prevlby = r.m_flLowerBodyYawTarget;
  217.  
  218. float diff = r.m_flLowerBodyYawTarget - prevlby;
  219.  
  220. avg += static_cast<int>(diff);
  221. count++;
  222. }
  223.  
  224. avg /= count;
  225.  
  226. pEntity->GetEyeAnglesPtr()->y += avg;
  227. }
  228. void CResolver::Resolve_Delta(CBaseEntity* pEntity, float org_yaw)
  229. {
  230. float last_simtime[64] = { 0.f };
  231. float last_lby[64] = { 0.f };
  232. float last_lby_delta[64] = { 0.f };
  233. float large_lby_delta[64] = { 0.f };
  234. float moving_lby[64] = { 0.f };
  235. bool was_moving[64] = { false };
  236.  
  237. const auto local = G::LocalPlayer;
  238. if (!local) return;
  239.  
  240. for (auto i = 0; i < g_pEngine->GetMaxClients(); ++i) {
  241. const auto player = const_cast <CBaseEntity*>(g_pEntitylist->GetClientEntity(i));
  242.  
  243.  
  244. if (!player || local == player || player->GetTeamNum() == local->GetTeamNum() || player->IsDormant()) {
  245. last_simtime[i] = 0.f;
  246.  
  247. last_lby[i] = 0.f;
  248. last_lby_delta[i] = 0.f;
  249. large_lby_delta[i] = 0.f;
  250. was_moving[i] = false;
  251. continue;
  252. }
  253.  
  254. //grab values from player
  255. const auto lby = player->LowerBodyYaw();
  256. const auto eye = player->GetEyeAnglesPtr();
  257. const auto sim = player->GetSimulationTime();
  258. const auto vel = player->GetVelocity().Length2D();
  259.  
  260. //auto missed = Globals::missedshots;
  261. auto missed = G::fired - G::hit;
  262. while (missed > 5) missed -= 5;
  263. while (missed < 0) missed += 5;
  264.  
  265. auto is_legit = false;
  266. auto update = false;
  267.  
  268.  
  269. if (sim - last_simtime[i] >= 1) {
  270. if (sim - last_simtime[i] == 1)
  271. {
  272.  
  273. is_legit = true;
  274. }
  275.  
  276.  
  277. last_simtime[i] = sim;
  278. }
  279.  
  280.  
  281. if (lby != last_lby[i]) {
  282. update = true;
  283. auto delta = fabsf(lby - last_lby[i]);
  284. last_lby_delta[i] = delta;
  285. if (delta > 90)
  286. {
  287. large_lby_delta[i] = delta;
  288. }
  289. last_lby[i] = lby;
  290. }
  291.  
  292.  
  293. auto angle = 0.f;
  294. if (is_legit)
  295. {
  296. if (GetAsyncKeyState(0x4D))
  297. {
  298. angle = lby;
  299. }
  300. else
  301. angle = eye->y;
  302. }
  303. else if (update)
  304. {
  305.  
  306. angle = lby;
  307. }
  308.  
  309. else if (vel > 35) {
  310. angle = lby;
  311. moving_lby[i] = lby;
  312. was_moving[i] = true;
  313. }
  314. else if (was_moving[i])
  315. {
  316. if (GetAsyncKeyState(0x4D))
  317. {
  318. angle = lby;
  319. }
  320. else
  321. {
  322. switch (missed) {
  323. case 0: angle = moving_lby[i]; break;
  324. case 1: angle = lby + large_lby_delta[i]; break;
  325. case 2: angle = lby + last_lby_delta[i]; break;
  326. case 3: angle = moving_lby[i]; break;
  327. case 4: angle = moving_lby[i] + 180; break;
  328. default: angle = lby - 120;
  329. }
  330. }
  331. }
  332. else {
  333. if (GetAsyncKeyState(0x4D))
  334. {
  335. angle = lby;
  336. }
  337. else
  338. {
  339. switch (missed) {
  340. case 0:angle = lby - 120; break;
  341. case 1: angle = lby + large_lby_delta[i]; break;
  342. case 2: angle = lby + last_lby_delta[i]; break;
  343. case 3: angle = moving_lby[i] - 35; break;
  344. case 4: angle = moving_lby[i] + 145; break;
  345. default: angle = lby + (90 * (missed + 1));
  346. }
  347. }
  348.  
  349. }
  350.  
  351.  
  352. player->GetEyeAnglesPtr()->y = angle;
  353. }
  354. }
  355. /*void CResolver::Resolve(CBaseEntity * pEntity) {
  356. int resolvermode = Clientvariables->Ragebot.AutomaticResolver;
  357.  
  358. if (resolvermode == RESOLVERMODE_OFF)
  359. return;
  360.  
  361. if (pEntity->IsMoving())
  362. pEntity->GetEyeAnglesPtr()->y = pEntity->LowerBodyYaw();
  363. else {
  364. if (Backtracking->arr_infos.at(pEntity->GetIndex()).TickRecords.size() < 3)
  365. return;
  366.  
  367. switch (resolvermode) {
  368. case RESOLVERMODE_PREDICT:
  369. Resolve_Predict(pEntity);
  370. break;
  371. case RESOLVERMODE_BRUTEFORCE:
  372. Resolve_Bruteforce(pEntity);
  373. break;
  374. case RESOLVERMODE_DELTA:
  375. Resolve_Delta(pEntity);
  376. break;
  377. default:
  378. return;
  379. break;
  380. }
  381. }
  382. }*/
  383.  
  384. CPredictable::CPredictable(float lby, float sim)
  385. {
  386. m_flLowerBodyYawTarget = lby;
  387. m_flSimulationTime = sim;
  388. }
  389.  
  390. void CResolver::Animation(CBaseEntity* pEntity, float org_yaw) {
  391. auto record = Backtracking->arr_infos.at(pEntity->GetIndex());
  392.  
  393. std::vector<CPredictable> m_predictable;
  394.  
  395. float last_lby = 0.0f;
  396.  
  397.  
  398. bool is_breaking_lby = false;
  399. int sequence = g_pModelInfo->GetStudioModel(pEntity->GetModel())->pSeqdesc(pEntity->GetSequence())->activity;
  400.  
  401. for (auto &r : record.TickRecords)
  402. {
  403. if (sequence == Activity::ACT_CSGO_IDLE_TURN_BALANCEADJUST) // ACT_CSGO_IDLE_TURN_BALANCEADJUST
  404. {
  405. printf("cool");
  406. m_predictable.push_back(CPredictable(r.m_angEyeAngles.y, r.m_flSimulationTime));
  407. }
  408.  
  409. if (GetDelta(r.m_flLowerBodyYawTarget, last_lby) < 35)
  410. continue;
  411.  
  412. if (GetDelta(r.m_flLowerBodyYawTarget, r.m_angEyeAngles.y) < 35)
  413. continue;
  414.  
  415. last_lby = r.m_flLowerBodyYawTarget;
  416. }
  417. int idx = pEntity->GetIndex();
  418. float new_yaw = pEntity->LowerBodyYaw();
  419.  
  420. AnimationLayer curBalanceLayer, prevBalanceLayer;
  421.  
  422. if (GetAsyncKeyState(Clientvariables->Ragebot.BruteForceKey) && Clientvariables->Ragebot.BruteForce)
  423. {
  424. new_yaw = pEntity->LowerBodyYaw();
  425.  
  426. switch (Clientvariables->Ragebot.BruteForce2)
  427. {
  428. case 0:
  429. new_yaw += 180.f;
  430. break;
  431. case 1:
  432. new_yaw = moving_vals[pEntity->GetIndex()];
  433. break;
  434. case 2:
  435. new_yaw = storedlby[pEntity->GetIndex()];
  436. break;
  437. }
  438. new_yaw = ClampYaw(new_yaw);
  439. pEntity->GetEyeAnglesPtr()->y = new_yaw;
  440. pEntity->SetPoseAngles(new_yaw, pEntity->GetEyeAngles().x);
  441. //player->m_angRotation() = QAngle(0, 0, 0);
  442. pEntity->GetAngRotation() = QAngle(0, 0, 0);
  443. return;
  444. }
  445. for (auto c : m_predictable)
  446. {
  447. //dont want to be using outdated data
  448. if (IsDifferent(c.m_flSimulationTime, pEntity->GetSimulationTime(), 0.170f) /* 170ms is good for now */)
  449. continue;
  450.  
  451. if (GetDelta(c.m_flLowerBodyYawTarget, pEntity->GetEyeAngles().y) < 90)
  452. continue;
  453.  
  454. is_breaking_lby = true;
  455. last_lby = c.m_flLowerBodyYawTarget;
  456. }
  457.  
  458. static float moving_lby[64];
  459.  
  460. if (pEntity->Velocity().Length() > 40.f && *pEntity->GetFlags() & FL_ONGROUND) {
  461. G::ResolverMode[pEntity->GetIndex()] = 0;
  462. pEntity->GetEyeAnglesPtr()->y = pEntity->LowerBodyYaw();
  463. moving_lby[pEntity->GetIndex()] = pEntity->LowerBodyYaw();
  464. }
  465. else
  466. {
  467. if (is_breaking_lby)
  468. {
  469. G::ResolverMode[pEntity->GetIndex()] = 1;
  470. float offset = 90.0f;
  471.  
  472. if (GetDelta(last_lby, pEntity->GetEyeAngles().y) < 270.0f && GetDelta(last_lby, pEntity->GetEyeAngles().y) > 90.0f)
  473. {
  474. offset = 180.0f;
  475. }
  476.  
  477. switch (G::Shots[pEntity->GetIndex()] % 5)
  478. {
  479. case 0: pEntity->GetEyeAnglesPtr()->y = moving_lby[pEntity->GetIndex()]; break;
  480. case 1: pEntity->GetEyeAnglesPtr()->y += offset; break;
  481. case 2: pEntity->GetEyeAnglesPtr()->y += offset + 35.0f; break;
  482. case 3: pEntity->GetEyeAnglesPtr()->y -= offset + 35.0f; break;
  483. case 4: pEntity->GetEyeAnglesPtr()->y -= offset; break;
  484. }
  485. }
  486. else if (IsDifferent(last_lby, pEntity->GetEyeAngles().y))
  487. {
  488. G::ResolverMode[pEntity->GetIndex()] = 2;
  489. switch (G::Shots[pEntity->GetIndex()] % 7)
  490. {
  491. case 0: pEntity->GetEyeAnglesPtr()->y = moving_lby[pEntity->GetIndex()]; break;
  492. case 1: pEntity->GetEyeAnglesPtr()->y = logged_hits[pEntity->GetIndex()]; break;
  493. case 2: pEntity->GetEyeAnglesPtr()->y = last_lby; break;
  494. case 3:pEntity->GetEyeAnglesPtr()->y = last_lby + 35.0f; break;
  495. case 4: pEntity->GetEyeAnglesPtr()->y = last_lby - 35.0f; break;
  496. case 5: pEntity->GetEyeAnglesPtr()->y = pEntity->LowerBodyYaw() + 90.f; break;
  497. case 6: pEntity->GetEyeAnglesPtr()->y = pEntity->LowerBodyYaw() - 90.f; break;
  498. }
  499. }
  500. }
  501. pEntity->GetEyeAnglesPtr()->NormalizeVec();
  502. }
  503.  
  504. float CResolver::ResolvePitch(CBaseEntity* pPlayer, float org_pitch)
  505. {
  506.  
  507.  
  508. auto new_pitch = org_pitch;
  509. /*bruteforce method*/
  510.  
  511. if (org_pitch > 181 && org_pitch < 271)
  512. {
  513. new_pitch = 269.0;
  514. }
  515. else if (org_pitch > 89 && org_pitch < 181)
  516. {
  517. new_pitch = 89.0;
  518. }
  519. else
  520. {
  521. if (!(*pPlayer->GetFlags() & FL_ONGROUND))
  522. {
  523.  
  524. new_pitch = 89;
  525. }
  526. else
  527. {
  528.  
  529. /*proper dynamic fix*/
  530. if (org_pitch > 181 && org_pitch < 271)
  531. {
  532. new_pitch = 269.0;
  533. }
  534. else if (org_pitch > 89 && org_pitch < 181)
  535. {
  536. new_pitch = 89.0;
  537. }
  538. else if (org_pitch <= -66)
  539. new_pitch = 89;
  540. else if (org_pitch == 0)
  541. new_pitch = 89;
  542.  
  543. //}
  544. }
  545. }
  546.  
  547.  
  548. return new_pitch;
  549. }
  550.  
  551. float CResolver2::ResolvePitch(CBaseEntity* pPlayer, float org_pitch)
  552. {
  553.  
  554.  
  555. auto new_pitch = org_pitch;
  556. /*bruteforce method*/
  557.  
  558. if (org_pitch > 181 && org_pitch < 271)
  559. {
  560. new_pitch = 269.0;
  561. }
  562. else if (org_pitch > 89 && org_pitch < 181)
  563. {
  564. new_pitch = 89.0;
  565. }
  566. else
  567. {
  568. if (!(*pPlayer->GetFlags() & FL_ONGROUND))
  569. {
  570.  
  571. new_pitch = 89;
  572. }
  573. else
  574. {
  575.  
  576. /*proper dynamic fix*/
  577. if (org_pitch > 181 && org_pitch < 271)
  578. {
  579. new_pitch = 269.0;
  580. }
  581. else if (org_pitch > 89 && org_pitch < 181)
  582. {
  583. new_pitch = 89.0;
  584. }
  585. else if (org_pitch <= -66)
  586. new_pitch = 89;
  587. else if (org_pitch == 0)
  588. new_pitch = 89;
  589.  
  590. //}
  591. }
  592. }
  593.  
  594.  
  595. return new_pitch;
  596. }
  597. enum at_target_antiaims
  598. {
  599. Undefined,
  600. Backwards,
  601. Left,
  602. Right
  603. };
  604.  
  605. float CResolver2::ResolveYaw(CBaseEntity* pPlayer, float org_yaw)
  606. {
  607. auto index = pPlayer->Index();
  608.  
  609. auto GetYawToNearestPlayer = [](CBaseEntity* pCenter) -> QAngle
  610. {
  611. auto get3ddist = [](Vector myCoords, Vector enemyCoords) -> float
  612. {
  613.  
  614. return sqrt(
  615. pow(double(enemyCoords.x - myCoords.x), 2.0) +
  616. pow(double(enemyCoords.y - myCoords.y), 2.0) +
  617. pow(double(enemyCoords.z - myCoords.z), 2.0));
  618.  
  619. };
  620. float best_dist = 9999;
  621. CBaseEntity* selected_player = nullptr;
  622. Vector vEyePos = pCenter->GetEyePosition();
  623. for (int i = 1; i < g_pGlobals->maxClients; i++)
  624. {
  625.  
  626. CBaseEntity* pCBaseEntity = g_pEntitylist->GetClientEntity(i);
  627. if (pCBaseEntity)
  628. {
  629. if (pCBaseEntity->GetHealth() > 0 && !pCBaseEntity->IsDormant() && pCBaseEntity->GetTeamNum() != pCenter->GetTeamNum() && pCBaseEntity != pCenter)
  630. {
  631. float dist = get3ddist(vEyePos, pCBaseEntity->GetEyePosition());
  632. if (best_dist > dist)
  633. {
  634. best_dist = dist;
  635. selected_player = pCBaseEntity;
  636. }
  637. }
  638. }
  639. }
  640. if (selected_player)
  641. {
  642. return GameUtils::CalculateAngle(vEyePos, selected_player->GetEyePosition());
  643. }
  644.  
  645. return QAngle(-1, -1, -1);
  646. };
  647.  
  648. QAngle at_target = GetYawToNearestPlayer(pPlayer);
  649. at_target.y = Math::NormalizeYaw(at_target.y);
  650.  
  651. auto new_yaw = org_yaw;
  652.  
  653. bool is_moving = pPlayer->GetVelocity().Length() > 29.f;
  654.  
  655. bool is_onground = *pPlayer->GetFlags() & FL_ONGROUND;
  656.  
  657. if (pPlayer->LowerBodyYaw() != LatestLowerBodyYaw[index] || (is_moving && is_onground))
  658. {
  659. LatestLowerBodyYaw[index] = pPlayer->LowerBodyYaw();
  660.  
  661. OldYawDifference[index] = YawDifference[index];
  662.  
  663. YawDifference[index] = Math::NormalizeYaw(new_yaw - pPlayer->LowerBodyYaw());
  664.  
  665. aa_info[index] = "lby update";
  666.  
  667. LatestLowerBodyYawUpdateTime[index] = g_pGlobals->curtime;//pPlayer->GetSimulationTime();
  668.  
  669. return Math::NormalizeYaw(pPlayer->LowerBodyYaw());
  670. }
  671.  
  672. if (is_moving)
  673. {
  674. aa_info[index] = "lby update";
  675. }
  676. else /*On ground resolver*/
  677. {
  678.  
  679. if (((g_pGlobals->curtime - LatestLowerBodyYawUpdateTime[index]) >= 0.5))
  680. {
  681. new_yaw -= 180;
  682. aa_info[index] = "static";
  683. }
  684. else
  685. {
  686. auto cur = this->m_arrInfos.at(index).m_sRecords;
  687.  
  688. if (cur.size() > 1)
  689. {
  690. if (HasStaticRealAngle(cur, 5))
  691. new_yaw = (cur.front().m_flLowerBodyYawTarget) + (Math::RandomFloat(0.f, 1.f) > 0.5f ? 10 : -10);
  692. else if (HasStaticYawDifference(cur, 10))
  693. new_yaw -= (cur.front().m_angEyeAngles.y - cur.front().m_flLowerBodyYawTarget);
  694. else if (HasSteadyDifference(cur, 10, pPlayer)) {
  695. float tickdif = static_cast<float>(cur.front().tickcount - cur.at(1).tickcount);
  696. float lbydif = GetDelta(cur.front().m_flLowerBodyYawTarget, cur.at(1).m_flLowerBodyYawTarget);
  697. float ntickdif = static_cast<float>(TIME_TO_TICKS(g_pGlobals->curtime) - cur.front().tickcount);
  698. new_yaw = (lbydif / tickdif) * ntickdif;
  699. }
  700. else if (DeltaKeepsChanging(cur, 10))
  701. new_yaw -= GetDeltaByComparingTicks(cur, pPlayer);
  702. else if (LBYKeepsChanging(cur, 10))
  703. new_yaw = GetLBYByComparingTicks(cur, pPlayer);
  704.  
  705. aa_info[index] = "stored";
  706. }
  707. else
  708. {
  709. // do all other logic here
  710. new_yaw = pPlayer->LowerBodyYaw() + Math::RandomFloat(-45, 45);
  711. aa_info[index] = "bruteforce";
  712. }
  713.  
  714. }
  715. }
  716.  
  717. new_yaw = Math::NormalizeYaw(new_yaw);
  718.  
  719. return new_yaw;
  720. }
  721.  
  722.  
  723.  
  724. void CResolver2::Run(CBaseEntity* pPlayer)
  725. {
  726. Vector* eye_angles = pPlayer->GetEyeAnglesPtr();
  727.  
  728. static Vector old_resolved[64];
  729.  
  730. int index = pPlayer->GetIndex();
  731.  
  732. static int shotsfired[64];
  733.  
  734. if (G::LocalPlayer->GetHealth() > 0 && (pPlayer->IsTargettingLocal() || shotsfired[index] < pPlayer->GetShotsFired()))
  735. {
  736. shotsfired[index] = pPlayer->GetShotsFired();
  737. eye_angles->x = g_BacktrackHelper->PlayerRecord[index].EyeAngles.x;//old_resolved[index].x;
  738. eye_angles->y = g_BacktrackHelper->PlayerRecord[index].EyeAngles.y;//old_resolved[index].y;
  739. return;
  740. }
  741. shotsfired[index] = pPlayer->GetShotsFired();
  742.  
  743. int CBaseEntityServerID = GetServerSideID(pPlayer->Index());
  744. if (PlayerData[CBaseEntityServerID].MissedShots >= 2)
  745. {
  746. PlayerData[CBaseEntityServerID].LastAnglesHit.Invalidate();
  747. PlayerData[CBaseEntityServerID].MissedShots = 0;
  748. Msg("Angles Invalidated %i", CBaseEntityServerID);
  749. }
  750.  
  751.  
  752. Vector eye_ang = pPlayer->GetEyeAngles();
  753.  
  754. if (Clientvariables->Ragebot.AutomaticResolver)
  755. {
  756.  
  757.  
  758. float pitch = ResolvePitch(pPlayer, g_BacktrackHelper->PlayerRecord[index].EyeAngles.x/*eye_ang.x*/);
  759. float yaw = ResolveYaw(pPlayer, g_BacktrackHelper->PlayerRecord[index].EyeAngles.y/*eye_ang.y*/);
  760.  
  761. eye_angles->x = pitch;
  762.  
  763.  
  764. eye_angles->y = yaw;
  765.  
  766. old_resolved[index] = Vector(pitch, yaw);
  767. }
  768.  
  769. }
  770. void CResolver::Resolve(CBaseEntity * pEntity) {
  771. int resolvermode = Clientvariables->Ragebot.AutomaticResolver;
  772.  
  773. if (resolvermode == RESOLVERMODE_OFF)
  774. return;
  775. int index = pEntity->GetIndex();
  776.  
  777. if (pEntity->IsMoving())
  778. pEntity->GetEyeAnglesPtr()->y = pEntity->LowerBodyYaw();
  779. else {
  780. if (Backtracking->arr_infos.at(pEntity->GetIndex()).TickRecords.size() < 3)
  781. return;
  782. {
  783. switch (Clientvariables->Ragebot.AutomaticResolver)
  784. {
  785. case 0:
  786. ResolvePitch(pEntity, g_BacktrackHelper->PlayerRecord[index].EyeAngles.x/*eye_ang.x*/);
  787. Resolve_Predict(pEntity, g_BacktrackHelper->PlayerRecord[index].EyeAngles.y);
  788. break;
  789. case 1:
  790. ResolvePitch(pEntity, g_BacktrackHelper->PlayerRecord[index].EyeAngles.x/*eye_ang.x*/);
  791. Resolve_Bruteforce(pEntity, g_BacktrackHelper->PlayerRecord[index].EyeAngles.y);
  792. break;
  793. case 2:
  794. ResolvePitch(pEntity, g_BacktrackHelper->PlayerRecord[index].EyeAngles.x/*eye_ang.x*/);
  795. Resolve_Delta(pEntity, g_BacktrackHelper->PlayerRecord[index].EyeAngles.y);
  796. break;
  797. case 3:
  798. ResolvePitch(pEntity, g_BacktrackHelper->PlayerRecord[index].EyeAngles.x/*eye_ang.x*/);
  799. Animation(pEntity, g_BacktrackHelper->PlayerRecord[index].EyeAngles.y);
  800. break;
  801. case 4:
  802. g_Resolver->Run(pEntity);
  803. break;
  804. }
  805. }
  806. }
  807. }
  808. void CResolver::Store(CBaseEntity * Entity) {
  809. if (!G::UserCmd || !Entity || Entity->GetIndex() < 1 || Entity->GetIndex() > 32)
  810. return;
  811.  
  812. auto record = &Backtracking->arr_infos.at(Entity->GetIndex());
  813.  
  814. record->Entity = Entity;
  815.  
  816. if (record->TickRecords.size() > 1 && record->TickRecords.front().tickcount == G::UserCmd->tick_count)
  817. return;
  818.  
  819. record->TickRecords.push_front(CTickRecord(Entity));
  820.  
  821. while ((int)record->TickRecords.size() > Clientvariables->Ragebot.ResolvoTicks)
  822. record->TickRecords.pop_back();
  823. }
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!