API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 18th, 2018
86
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 22.11 KB | None | 0 0
raw download clone embed print report
  1. #include "../includes.h"
  2. #include "../UTILS/interfaces.h"
  3. #include "../SDK/IEngine.h"
  4. #include "../SDK/CUserCmd.h"
  5. #include "../SDK/CBaseEntity.h"
  6. #include "../SDK/CClientEntityList.h"
  7. #include "../UTILS/render.h"
  8. #include "../SDK/CTrace.h"
  9. #include "../SDK/CBaseWeapon.h"
  10. #include "../SDK/CGlobalVars.h"
  11. #include "../SDK/ConVar.h"
  12. #include "../SDK/AnimLayer.h"
  13. #include "../UTILS/qangle.h"
  14. #include "../FEATURES/Aimbot.h"
  15. #include "../FEATURES/Resolver.h"
  16.  
  17. inline float RandomFloat(float min, float max)
  18. {
  19. static auto fn = (decltype(&RandomFloat))(GetProcAddress(GetModuleHandle("vstdlib.dll"), "RandomFloat"));
  20. return fn(min, max);
  21. }
  22.  
  23. void CResolver::UpdateResolveRecord(SDK::CBaseEntity* entity)
  24. {
  25. const auto previous_record = player_resolve_records[entity->GetIndex()];
  26. auto& record = player_resolve_records[entity->GetIndex()];
  27.  
  28. record.resolved_angles = record.networked_angles;
  29. record.velocity = entity->GetVelocity();
  30. record.origin = entity->GetVecOrigin();
  31. record.lower_body_yaw = entity->GetLowerBodyYaw();
  32. record.is_dormant = entity->GetIsDormant();
  33.  
  34. record.resolve_type = 0;
  35.  
  36. record.is_balance_adjust_triggered = false, record.is_balance_adjust_playing = false;
  37. for (int i = 0; i < 15; i++)
  38. {
  39. record.anim_layers[i] = entity->GetAnimOverlay(i);
  40.  
  41. if (entity->GetSequenceActivity(record.anim_layers[i].m_nSequence) == SDK::CSGO_ACTS::ACT_CSGO_IDLE_TURN_BALANCEADJUST)
  42. {
  43. record.is_balance_adjust_playing = true;
  44.  
  45. if (record.anim_layers[i].m_flWeight == 1 || record.anim_layers[i].m_flCycle > previous_record.anim_layers[i].m_flCycle)
  46. record.last_balance_adjust_trigger_time = UTILS::GetCurtime();
  47. if (fabs(UTILS::GetCurtime() - record.last_balance_adjust_trigger_time) < 0.5f)
  48. record.is_balance_adjust_triggered = true;
  49. }
  50. }
  51.  
  52. if (record.is_dormant)
  53. record.next_predicted_lby_update = FLT_MAX;
  54.  
  55. if (record.lower_body_yaw != previous_record.lower_body_yaw && !record.is_dormant && !previous_record.is_dormant)
  56. record.did_lby_flick = true;
  57.  
  58. const bool is_moving_on_ground = record.velocity.Length2D() > 50 && entity->GetFlags() & FL_ONGROUND;
  59. if (is_moving_on_ground && record.is_balance_adjust_triggered)
  60. record.is_fakewalking = true;
  61. else
  62. record.is_fakewalking = false;
  63.  
  64. if (is_moving_on_ground && !record.is_fakewalking && record.velocity.Length2D() > 1.f && !record.is_dormant)
  65. {
  66. record.is_last_moving_lby_valid = true;
  67. record.is_last_moving_lby_delta_valid = false;
  68. record.shots_missed_moving_lby = 0;
  69. record.shots_missed_moving_lby_delta = 0;
  70. record.last_moving_lby = record.lower_body_yaw + 45;
  71. record.last_time_moving = UTILS::GetCurtime();
  72. }
  73. if (!record.is_dormant && previous_record.is_dormant)
  74. {
  75. if ((record.origin - previous_record.origin).Length2D() > 16.f)
  76. record.is_last_moving_lby_valid = false;
  77. }
  78. if (!record.is_last_moving_lby_delta_valid && record.is_last_moving_lby_valid && record.velocity.Length2D() < 20 && fabs(UTILS::GetCurtime() - record.last_time_moving) < 1.0)
  79. {
  80. if (record.lower_body_yaw != previous_record.lower_body_yaw)
  81. {
  82. record.last_moving_lby_delta = MATH::NormalizeYaw(record.last_moving_lby - record.lower_body_yaw);
  83. record.is_last_moving_lby_delta_valid = true;
  84. }
  85. }
  86.  
  87. if (MATH::NormalizePitch(record.networked_angles.x) > 5.f)
  88. record.last_time_down_pitch = UTILS::GetCurtime();
  89.  
  90. }
  91.  
  92. int CResolver::GetResolveTypeIndex(unsigned short resolve_type)
  93. {
  94. if (resolve_type & RESOLVE_TYPE_OVERRIDE)
  95. return 0;
  96. else if (resolve_type & RESOLVE_TYPE_NO_FAKE)
  97. return 1;
  98. else if (resolve_type & RESOLVE_TYPE_LBY)
  99. return 2;
  100. else if (resolve_type & RESOLVE_TYPE_LBY_UPDATE)
  101. return 3;
  102. else if (resolve_type & RESOLVE_TYPE_PREDICTED_LBY_UPDATE)
  103. return 4;
  104. else if (resolve_type & RESOLVE_TYPE_LAST_MOVING_LBY)
  105. return 5;
  106. else if (resolve_type & RESOLVE_TYPE_NOT_BREAKING_LBY)
  107. return 6;
  108. else if (resolve_type & RESOLVE_TYPE_BRUTEFORCE)
  109. return 7;
  110. else if (resolve_type & RESOLVE_TYPE_LAST_MOVING_LBY_DELTA)
  111. return 8;
  112. else if (resolve_type & RESOLVE_TYPE_ANTI_FREESTANDING)
  113. return 9;
  114.  
  115. return 0;
  116. }
  117.  
  118. void CResolver::ProcessSnapShots()
  119. {
  120. if (shot_snapshots.size() <= 0)
  121. return;
  122.  
  123. const auto snapshot = shot_snapshots.front();
  124. if (fabs(UTILS::GetCurtime() - snapshot.time) > 1.f)
  125. {
  126.  
  127. shot_snapshots.erase(shot_snapshots.begin());
  128. return;
  129. }
  130.  
  131. const int player_index = snapshot.entity->GetIndex();
  132. if (snapshot.hitgroup_hit != -1)
  133. {
  134. for (int i = 0; i < RESOLVE_TYPE_NUM; i++)
  135. {
  136. if (snapshot.resolve_record.resolve_type & (1 << i))
  137. {
  138. player_resolve_records[player_index].shots_fired[i]++;
  139. player_resolve_records[player_index].shots_hit[i]++;
  140. }
  141. }
  142.  
  143.  
  144. }
  145. else if (snapshot.first_processed_time != 0.f && fabs(UTILS::GetCurtime() - snapshot.first_processed_time) > 0.1f)
  146. {
  147. for (int i = 0; i < RESOLVE_TYPE_NUM; i++)
  148. {
  149. if (snapshot.resolve_record.resolve_type & (1 << i))
  150. player_resolve_records[player_index].shots_fired[i]++;
  151. }
  152.  
  153. if (snapshot.resolve_record.resolve_type & RESOLVE_TYPE_LAST_MOVING_LBY)
  154. player_resolve_records[player_index].shots_missed_moving_lby++;
  155.  
  156. if (snapshot.resolve_record.resolve_type & RESOLVE_TYPE_LAST_MOVING_LBY_DELTA)
  157. player_resolve_records[player_index].shots_missed_moving_lby_delta++;
  158.  
  159. }
  160. else
  161. return;
  162.  
  163. shot_snapshots.erase(shot_snapshots.begin());
  164. }
  165.  
  166. void CResolver::ResolveYawBruteforce(SDK::CBaseEntity* entity)
  167. {
  168. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  169. if (!local_player)
  170. return;
  171.  
  172. auto& resolve_record = player_resolve_records[entity->GetIndex()];
  173. resolve_record.resolve_type |= RESOLVE_TYPE_BRUTEFORCE;
  174.  
  175. const float at_target_yaw = UTILS::CalcAngle(entity->GetVecOrigin(), local_player->GetVecOrigin()).y;
  176.  
  177. const int shots_missed = resolve_record.shots_fired[GetResolveTypeIndex(resolve_record.resolve_type)] -
  178. resolve_record.shots_hit[GetResolveTypeIndex(resolve_record.resolve_type)];
  179. switch (shots_missed % 3)
  180. {
  181. case 0:
  182. resolve_record.resolved_angles.y = UTILS::GetLBYRotatedYaw(entity->GetLowerBodyYaw(), at_target_yaw + 60.f);
  183. break;
  184. case 1:
  185. resolve_record.resolved_angles.y = at_target_yaw + 140.f;
  186. break;
  187. case 2:
  188. resolve_record.resolved_angles.y = at_target_yaw - 75.f;
  189. break;
  190. }
  191. }
  192.  
  193. bool CResolver::AntiFreestanding(SDK::CBaseEntity* entity, float& yaw)
  194. {
  195. const auto freestanding_record = player_resolve_records[entity->GetIndex()].anti_freestanding_record;
  196.  
  197. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  198. if (!local_player)
  199. return false;
  200.  
  201. if (freestanding_record.left_damage >= 20 && freestanding_record.right_damage >= 20)
  202. return false;
  203.  
  204. const float at_target_yaw = UTILS::CalcAngle(local_player->GetVecOrigin(), entity->GetVecOrigin()).y;
  205. if (freestanding_record.left_damage <= 0 && freestanding_record.right_damage <= 0)
  206. {
  207. if (freestanding_record.right_fraction < freestanding_record.left_fraction)
  208. yaw = at_target_yaw + 125.f;
  209. else
  210. yaw = at_target_yaw - 73.f;
  211. }
  212. else
  213. {
  214. if (freestanding_record.left_damage > freestanding_record.right_damage)
  215. yaw = at_target_yaw + 130.f;
  216. else
  217. yaw = at_target_yaw - 49.f;
  218. }
  219.  
  220. return true;
  221. }
  222.  
  223. Vector old_calcangle(Vector dst, Vector src)
  224. {
  225. Vector angles;
  226.  
  227. double delta[3] = { (src.x - dst.x), (src.y - dst.y), (src.z - dst.z) };
  228. double hyp = sqrt(delta[0] * delta[0] + delta[1] * delta[1]);
  229. angles.x = (float)(atan(delta[2] / hyp) * 180.0 / 3.14159265);
  230. angles.y = (float)(atanf(delta[1] / delta[0]) * 57.295779513082f);
  231. angles.z = 0.0f;
  232.  
  233. if (delta[0] >= 0.0)
  234. {
  235. angles.y += 180.0f;
  236. }
  237.  
  238. return angles;
  239. }
  240.  
  241. float old_normalize(float Yaw)
  242. {
  243. if (Yaw > 180)
  244. {
  245. Yaw -= (round(Yaw / 360) * 360.f);
  246. }
  247. else if (Yaw < -180)
  248. {
  249. Yaw += (round(Yaw / 360) * -360.f);
  250. }
  251. return Yaw;
  252. }
  253.  
  254. float curtime(SDK::CUserCmd* cmd) {
  255. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  256.  
  257. if (!local_player)
  258. return 0;
  259.  
  260. int g_tick = 0;
  261. SDK::CUserCmd* g_pLastCmd = nullptr;
  262. if (!g_pLastCmd || g_pLastCmd->hasbeenpredicted) {
  263. g_tick = (float)local_player->GetTickBase();
  264. }
  265. else {
  266. ++g_tick;
  267. }
  268. g_pLastCmd = cmd;
  269. float curtime = g_tick * INTERFACES::Globals->interval_per_tick;
  270. return curtime;
  271. }
  272.  
  273. bool find_layer(SDK::CBaseEntity* entity, int act, SDK::CAnimationLayer *set)
  274. {
  275. for (int i = 0; i < 13; i++)
  276. {
  277. SDK::CAnimationLayer layer = entity->GetAnimOverlay(i);
  278. const int activity = entity->GetSequenceActivity(layer.m_nSequence);
  279. if (activity == act) {
  280. *set = layer;
  281. return true;
  282. }
  283. }
  284. return false;
  285. }
  286.  
  287. bool IsAdjustingBalance(SDK::CBaseEntity* player, SDK::CAnimationLayer *layer)
  288. {
  289. for (int i = 0; i < 15; i++)
  290. {
  291. const int activity = player->GetSequenceActivity(layer[i].m_nSequence);
  292. if (activity == 979)
  293. {
  294. return true;
  295. }
  296. }
  297. return false;
  298. }
  299.  
  300. void VectorAngles(Vector forward, Vector &angles)
  301. {
  302. float tmp, yaw, pitch;
  303.  
  304. if (forward[2] == 0 && forward[0] == 0)
  305. {
  306. yaw = 0;
  307.  
  308. if (forward[2] > 0)
  309. pitch = 90;
  310. else
  311. pitch = 270;
  312. }
  313. else
  314. {
  315. yaw = (atan2(forward[1], forward[0]) * 180 / pitch);
  316.  
  317. if (yaw < 0)
  318. yaw += 360;
  319.  
  320. tmp = sqrt(forward[0] * forward[0] + forward[1] * forward[1]);
  321. pitch = (atan2(-forward[2], tmp) * 180 / pitch);
  322.  
  323. if (pitch < 0)
  324. pitch += 360;
  325. }
  326.  
  327. if (pitch > 180)
  328. pitch -= 360;
  329. else if (pitch < -180)
  330. pitch += 360;
  331.  
  332. if (yaw > 180)
  333. yaw -= 360;
  334. else if (yaw < -180)
  335. yaw += 360;
  336.  
  337. if (pitch > 89)
  338. pitch = 89;
  339. else if (pitch < -89)
  340. pitch = -89;
  341.  
  342. if (yaw > 180)
  343. yaw = 180;
  344. else if (yaw < -180)
  345. yaw = -180;
  346.  
  347. angles[0] = pitch;
  348. angles[1] = yaw;
  349. angles[2] = 0;
  350. }
  351.  
  352. void CResolver::record(SDK::CBaseEntity* entity, float new_yaw)
  353. {
  354. if (entity->GetVelocity().Length2D() > 36) return;
  355.  
  356. auto c_baseweapon = reinterpret_cast<SDK::CBaseWeapon*>(INTERFACES::ClientEntityList->GetClientEntity(entity->GetActiveWeaponIndex()));
  357. if (!c_baseweapon) return;
  358.  
  359. auto &info = player_info[entity->GetIndex()];
  360. if (entity->GetActiveWeaponIndex() && info.last_ammo < c_baseweapon->GetLoadedAmmo()) {
  361. info.last_ammo = c_baseweapon->GetLoadedAmmo();
  362. return;
  363. }
  364.  
  365. info.unresolved_yaw.insert(info.unresolved_yaw.begin(), new_yaw);
  366. if (info.unresolved_yaw.size() > 20) info.unresolved_yaw.pop_back();
  367. if (info.unresolved_yaw.size() < 2) return;
  368.  
  369. auto average_unresolved_yaw = 0;
  370. for (auto val : info.unresolved_yaw)
  371. average_unresolved_yaw += val;
  372. average_unresolved_yaw /= info.unresolved_yaw.size();
  373.  
  374. int delta = average_unresolved_yaw - entity->GetLowerBodyYaw();
  375. auto big_math_delta = abs((((delta + 180) % 360 + 360) % 360 - 180));
  376.  
  377. info.lby_deltas.insert(info.lby_deltas.begin(), big_math_delta);
  378. if (info.lby_deltas.size() > 10) {
  379. info.lby_deltas.pop_back();
  380. }
  381. }
  382. void CResolver::resolve(SDK::CBaseEntity* entity)
  383. {
  384. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  385. if (!entity) return;
  386. if (!local_player) return;
  387.  
  388. auto &info = player_info[entity->GetIndex()];
  389.  
  390. float v18 = entity->GetEyeAngles().y + 180.0;
  391. float v19 = entity->GetEyeAngles().y + 180.0;
  392. double v20;
  393. if (v19 <= 180.0)
  394. {
  395. if (v18 < -180.0)
  396. v19 = v18 + 360.0;
  397. }
  398. else
  399. {
  400. v19 = v18 - 360.0;
  401. }
  402.  
  403. float v22;//lets assume v20 = viewangles or some shit
  404. v22 = entity->GetEyeAngles().y + 180.0;
  405. float v23; float v24;
  406. {
  407. if ((entity->GetEyeAngles().y + 180.0) <= 180.0)
  408. {
  409. if (v22 < -180.0)
  410. v22 = v22 + 360.0;
  411. }
  412. else
  413. {
  414. v22 = v22 - 360.0;
  415. }
  416. v23 = v22 - entity->GetLowerBodyYaw();
  417. if (v23 <= 180.0)
  418. {
  419. if (v23 < -180.0)
  420. v23 = v23 + 360.0;
  421. }
  422. else
  423. {
  424. v23 = v23 - 360.0;
  425. }
  426. }
  427.  
  428. auto EyeAngles = entity->GetEyeAnglesPointer();
  429. if (entity->GetVelocity().Length() > 1 && (entity->GetFlags() & (int)entity->GetFlags() & FL_ONGROUND))
  430. EyeAngles->y = entity->GetLowerBodyYaw();
  431.  
  432. bool IsFast;
  433.  
  434. if (entity->GetFlags() & FL_ONGROUND & entity->GetVelocity().Length2D() >= 0.9)
  435. IsFast = true;
  436. else
  437. IsFast = false;
  438.  
  439. bool MeetsLBYReq;
  440.  
  441. if (entity->GetFlags() & FL_ONGROUND)
  442. MeetsLBYReq = true;
  443. else
  444. MeetsLBYReq = false;
  445.  
  446.  
  447. bool IsMoving;
  448.  
  449. if (entity->GetVelocity().Length2D() >= 0.09)
  450. IsMoving = true;
  451. else
  452. IsMoving = false;
  453.  
  454.  
  455. entity->GetEyeAnglesPointer()->y = 160.f;
  456. {
  457. if ((shots_missed[entity->GetIndex()] % 1))
  458. {
  459. if (MeetsLBYReq && RESOLVE_TYPE_LBY_UPDATE)
  460. {
  461. entity->GetEyeAnglesPointer()->y = entity->GetLowerBodyYaw();
  462. }
  463. else if (!MeetsLBYReq && RESOLVE_TYPE_LBY_UPDATE)
  464. {
  465. switch (shots_missed[entity->GetIndex()] % 1)
  466. {
  467. case 1:
  468. entity->GetEyeAnglesPointer()->y = -30 + rand() % 45 - rand() % 51;
  469. break;
  470. case 2:
  471. entity->GetEyeAnglesPointer()->y = entity->GetLowerBodyYaw() + 20 - rand() % 35;
  472. break;
  473. case 3:
  474. entity->GetEyeAnglesPointer()->y = entity->GetLowerBodyYaw() + 45 % 30 - rand() % 90;
  475. break;
  476. case 4:
  477. entity->GetEyeAnglesPointer()->y = entity->GetLowerBodyYaw() - 90 - rand() % 90 - rand() % 40;
  478. break;
  479. case 5:
  480. entity->GetEyeAnglesPointer()->y = -160 - rand() % 90 - rand() % 40;
  481. break;
  482. }
  483. }
  484. else
  485. entity->GetEyeAnglesPointer()->y = rand() % 180 - rand() % 45;
  486. }
  487.  
  488. }
  489.  
  490. //--- Variable Defenitions/Checks ---//
  491. float fl_lby = entity->GetLowerBodyYaw();
  492.  
  493. bool is_local_player = entity == local_player;
  494. bool is_teammate = local_player->GetTeam() == entity->GetTeam() && !is_local_player;
  495. if (is_local_player) return;
  496. if (is_teammate) return;
  497. if (entity->GetHealth() <= 0) return;
  498. if (local_player->GetHealth() <= 0) return;
  499.  
  500. if ((SETTINGS::settings.overridemethod == 1 && GetAsyncKeyState(UTILS::INPUT::input_handler.keyBindings(SETTINGS::settings.overridekey))) || (SETTINGS::settings.overridemethod == 0 && SETTINGS::settings.overridething))
  501. {
  502. Vector viewangles; INTERFACES::Engine->GetViewAngles(viewangles);
  503. auto at_target_yaw = UTILS::CalcAngle(entity->GetVecOrigin(), local_player->GetVecOrigin()).y;
  504.  
  505. auto delta = MATH::NormalizeYaw(viewangles.y - at_target_yaw);
  506. auto rightDelta = Vector(entity->GetEyeAngles().x, at_target_yaw + 90, entity->GetEyeAngles().z);
  507. auto leftDelta = Vector(entity->GetEyeAngles().x, at_target_yaw - 90, entity->GetEyeAngles().z);
  508.  
  509. if (delta > 0)
  510. entity->SetEyeAngles(rightDelta);
  511. else
  512. entity->SetEyeAngles(leftDelta);
  513. return;
  514. }
  515.  
  516. info.lby = Vector(entity->GetEyeAngles().x, entity->GetLowerBodyYaw(), 0.f);
  517. info.inverse = Vector(entity->GetEyeAngles().x, entity->GetLowerBodyYaw() + 180.f, 0.f);
  518. info.last_lby = Vector(entity->GetEyeAngles().x, info.last_moving_lby, 0.f);
  519. info.inverse_left = Vector(entity->GetEyeAngles().x, entity->GetLowerBodyYaw() + 115.f, 0.f);
  520. info.inverse_right = Vector(entity->GetEyeAngles().x, entity->GetLowerBodyYaw() - 115.f, 0.f);
  521.  
  522. info.back = Vector(entity->GetEyeAngles().x, UTILS::CalcAngle(entity->GetVecOrigin(), local_player->GetVecOrigin()).y + 180.f, 0.f);
  523. info.right = Vector(entity->GetEyeAngles().x, UTILS::CalcAngle(entity->GetVecOrigin(), local_player->GetVecOrigin()).y + 70.f, 0.f);
  524. info.left = Vector(entity->GetEyeAngles().x, UTILS::CalcAngle(entity->GetVecOrigin(), local_player->GetVecOrigin()).y - 70.f, 0.f);
  525.  
  526. info.backtrack = Vector(entity->GetEyeAngles().x, lby_to_back[entity->GetIndex()], 0.f);
  527.  
  528. shots_missed[entity->GetIndex()] = shots_fired[entity->GetIndex()] - shots_hit[entity->GetIndex()];
  529.  
  530. if (SETTINGS::settings.fakefix_bool) info.is_moving = entity->GetVelocity().Length2D() > 0.1 && entity->GetFlags() & FL_ONGROUND && !info.could_be_slowmo;
  531. else info.is_moving = entity->GetVelocity().Length2D() > 0.1 && entity->GetFlags() & FL_ONGROUND;
  532.  
  533. info.is_jumping = !entity->GetFlags() & FL_ONGROUND;
  534. info.could_be_slowmo = entity->GetVelocity().Length2D() > 6 && entity->GetVelocity().Length2D() < 36 && !info.is_crouching;
  535. info.is_crouching = entity->GetFlags() & FL_DUCKING;
  536. update_time[entity->GetIndex()] = info.next_lby_update_time;
  537.  
  538. {
  539. Vector viewangles; INTERFACES::Engine->GetViewAngles(viewangles);
  540. auto at_target_yaw = UTILS::CalcAngle(entity->GetVecOrigin(), local_player->GetVecOrigin()).y;
  541.  
  542. auto delta = MATH::NormalizeYaw(viewangles.y - at_target_yaw);
  543. auto rightDelta = Vector(entity->GetEyeAngles().x, at_target_yaw + 90, entity->GetEyeAngles().z);
  544. auto leftDelta = Vector(entity->GetEyeAngles().x, at_target_yaw - 90, entity->GetEyeAngles().z);
  545.  
  546. if (delta > 0)
  547. entity->SetEyeAngles(rightDelta);
  548. else
  549. entity->SetEyeAngles(leftDelta);
  550. return;
  551. }
  552.  
  553. shots_missed[entity->GetIndex()] = shots_fired[entity->GetIndex()] - shots_hit[entity->GetIndex()];
  554.  
  555. int i = entity->GetIndex();
  556.  
  557. auto player_move = entity->GetVelocity().Length2D() > 36 && !entity->GetFlags() & FL_ONGROUND;
  558. float player_lastmove[65], player_lastmove_active[65];
  559. float bruteforce_angle[65];
  560. player_lastmove_active[i] = false;
  561.  
  562. float banana6 = 1337.f, banana7 = 228.f, banana8 = 007.f,
  563. banana4 = 180.f, banana1 = 90.f, banana2 = -47.f, // ????????? ??????
  564. banana3 = 46.f, banana5 = -777.f; // ??? float ??? ?????)
  565.  
  566. switch (shots_missed[i] % 8)
  567. {
  568. case 0: bruteforce_angle[i] = banana1; break;
  569. case 1: bruteforce_angle[i] = banana2; break;
  570. case 2: bruteforce_angle[i] = banana3; break;
  571. case 3: bruteforce_angle[i] = banana4; break;
  572. case 4: bruteforce_angle[i] = banana5; break;
  573. case 5: bruteforce_angle[i] = banana6; break;
  574. case 6: bruteforce_angle[i] = banana7; break;
  575. case 7: bruteforce_angle[i] = banana8; break;
  576. }
  577.  
  578. if (player_move)
  579. {
  580. entity->GetEyeAnglesPointer()->y = entity->GetLowerBodyYaw();
  581. player_lastmove[i] = entity->GetLowerBodyYaw();
  582. player_lastmove_active[i] = true;
  583. }
  584. else
  585. {
  586. if (player_lastmove_active[i])
  587. {
  588. if (shots_missed[i] <= 2) entity->GetEyeAnglesPointer()->y = player_lastmove[i];
  589. else entity->GetEyeAnglesPointer()->y = player_lastmove[i] + bruteforce_angle[i];
  590. }
  591. else
  592. {
  593. entity->GetEyeAnglesPointer()->y = entity->GetLowerBodyYaw();
  594. }
  595.  
  596. float ltmb[64]; // storing lastmove value
  597. bool breaking_lby; // breaking lby check
  598.  
  599. //@breaking lby check not prediction
  600. bool unforcelby;
  601. if (entity->GetLowerBodyYaw() > 0)
  602. {
  603.  
  604. entity->GetLowerBodyYaw() > INTERFACES::Globals->curtime > 2.2 / 2; // if curtime > 1.1 we / but its slowly then 1.1 and we can check double flicks credits @ zero
  605. breaking_lby = true;
  606.  
  607. }
  608.  
  609. else
  610.  
  611. {
  612. breaking_lby = false;
  613.  
  614. }
  615.  
  616.  
  617.  
  618. auto Yaws = entity->GetEyeAnglesPointer()->y / 6 + 45 / +24; MATH::GetYawDelta(34, -143) - 42 / 2 + 45; // calc last lastmove delta after landing
  619.  
  620. auto serverside = Yaws; // delta calculation credits @@ esoteric
  621.  
  622. auto angeldelta = entity->GetLowerBodyYaw() - entity->GetEyeAnglesPointer()->y;
  623.  
  624. auto tap = entity->GetLowerBodyYaw() + serverside + angeldelta; // delta abusing reversed aw by @@ zero
  625.  
  626. float GetFakeYaw = entity->GetSimTime(); // here we get fakes
  627.  
  628. float RealYaw = info.next_lby_update_time ? entity->GetEyeAnglesPointer()->y + 180 : entity->GetLowerBodyYaw() + RandomFloat(180, 23 * 4 / 2 - 3 * 1 / 1 * 3 / 2) + 180; // so here we can take their real ang but we need still manipulate with it
  629.  
  630. auto AnimSyncYaw = GetFakeYaw / RealYaw;
  631. auto BruteToRealYaw = AnimSyncYaw * angeldelta;
  632.  
  633.  
  634. if (fabs(RealYaw >= 45))
  635. RealYaw = entity->GetEyeAnglesPointer()->y + 90 * GetFakeYaw + RandomFloat(10, -15); // anti freestand and broken lastmove angels
  636. if (fabs(RealYaw < 45))
  637. RealYaw = entity->GetEyeAnglesPointer()->y - 90 / angeldelta - RandomFloat(-15, 10); // anti frestand right
  638.  
  639.  
  640.  
  641. if (entity->GetVelocity().Length2D() > 0.1f)
  642. {
  643. entity->GetEyeAnglesPointer()->y = entity->GetLowerBodyYaw();
  644. }
  645. else if (breaking_lby) // if we ghot delta stored delta and breaker
  646. {
  647. entity->GetEyeAnglesPointer()->y = Yaws; // tap if shaking real or stand more than 0.3 * curtime - simulation time isnt dormant and ghost
  648.  
  649. if (shots_missed[entity->GetIndex()] % 2)
  650. entity->GetEyeAnglesPointer()->y = Yaws - serverside; // if angel static or freestand
  651. else if (shots_missed[entity->GetIndex()] % 3)
  652. entity->GetEyeAnglesPointer()->y = Yaws + angeldelta; // if delta < 90
  653. else if (shots_missed[entity->GetIndex()] % 4)
  654. entity->GetEyeAnglesPointer()->y = Yaws + tap; // perfect deteck if delta > 90
  655. else if (shots_missed[entity->GetIndex()] % 5)
  656. entity->GetEyeAnglesPointer()->y = Yaws + tap + 180 - 45 / angeldelta + serverside; // if lby update cant shake lowercurtime to 0 but animlayer buggy in cs hook animdata hook
  657.  
  658.  
  659. }
  660.  
  661. else
  662. {
  663. entity->GetEyeAnglesPointer()->y = entity->GetLowerBodyYaw(); // if not break its real
  664. }
  665.  
  666. if (unforcelby && !breaking_lby && angeldelta <= 180)
  667. {
  668. entity->GetEyeAnglesPointer()->y = RealYaw;
  669. }
  670.  
  671. static float old_simtime[65];
  672. if (entity->GetSimTime() != old_simtime[entity->GetIndex()])
  673. {
  674. using_fake_angles[entity->GetIndex()] = entity->GetSimTime() - old_simtime[entity->GetIndex()] == INTERFACES::Globals->interval_per_tick;
  675. old_simtime[entity->GetIndex()] = entity->GetSimTime();
  676. }
  677.  
  678. if (!using_fake_angles[entity->GetIndex()])
  679. {
  680. if (backtrack_tick[entity->GetIndex()])
  681. {
  682. resolve_type[entity->GetIndex()] = 7;
  683. entity->SetEyeAngles(info.backtrack);
  684. }
  685. else if (info.stored_lby != entity->GetLowerBodyYaw())
  686. {
  687. entity->SetEyeAngles(info.lby);
  688. info.stored_lby = entity->GetLowerBodyYaw();
  689. resolve_type[entity->GetIndex()] = 3;
  690. }
  691. else if (info.is_moving)
  692. {
  693. entity->SetEyeAngles(info.lby);
  694. info.last_moving_lby = entity->GetLowerBodyYaw();
  695. info.stored_missed = shots_missed[entity->GetIndex()];
  696. resolve_type[entity->GetIndex()] = 1;
  697. }
  698. else
  699. {
  700. if (shots_missed[entity->GetIndex()] > info.stored_missed)
  701. {
  702. resolve_type[entity->GetIndex()] = 4;
  703. switch (shots_missed[entity->GetIndex()] % 4)
  704. {
  705. case 0: entity->SetEyeAngles(info.inverse); break;
  706. case 1: entity->SetEyeAngles(info.left); break;
  707. case 2: entity->SetEyeAngles(info.back); break;
  708. case 3: entity->SetEyeAngles(info.right); break;
  709. }
  710. }
  711. else
  712. {
  713. entity->SetEyeAngles(info.last_lby);
  714. resolve_type[entity->GetIndex()] = 5;
  715. }
  716. }
  717. }
  718. }
  719. }
  720. CResolver* resolver = new CResolver();
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!