API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 18th, 2018
79
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 20.34 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 "../SDK/CTrace.h"
  8. #include "../SDK/CGlobalVars.h"
  9. #include "../SDK/CBaseWeapon.h"
  10. #include "../SDK/ConVar.h"
  11. #include "../SDK/AnimLayer.h"
  12. #include "../UTILS/qangle.h"
  13. #include "../FEATURES/Aimbot.h"
  14. #include "../FEATURES/Resolver.h"
  15.  
  16. Vector old_calcangle(Vector dst, Vector src)
  17. {
  18. Vector angles;
  19.  
  20. double delta[3] = { (src.x - dst.x), (src.y - dst.y), (src.z - dst.z) };
  21. double hyp = sqrt(delta[0] * delta[0] + delta[1] * delta[1]);
  22. angles.x = (float)(atan(delta[2] / hyp) * 180.0 / 3.14159265);
  23. angles.y = (float)(atanf(delta[1] / delta[0]) * 57.295779513082f);
  24. angles.z = 0.0f;
  25.  
  26. if (delta[0] >= 0.0)
  27. {
  28. angles.y += 180.0f;
  29. }
  30.  
  31. return angles;
  32. }
  33.  
  34. float curtime(SDK::CUserCmd* ucmd) {
  35. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  36.  
  37. if (!local_player)
  38. return 0;
  39.  
  40. int g_tick = 0;
  41. SDK::CUserCmd* g_pLastCmd = nullptr;
  42. if (!g_pLastCmd || g_pLastCmd->hasbeenpredicted) {
  43. g_tick = (float)local_player->GetTickBase();
  44. }
  45. else {
  46. ++g_tick;
  47. }
  48. g_pLastCmd = ucmd;
  49. float curtime = g_tick * INTERFACES::Globals->interval_per_tick;
  50. return curtime;
  51. }
  52.  
  53. bool find_layer(SDK::CBaseEntity* entity, int act, SDK::CAnimationLayer *set)
  54. {
  55. for (int i = 0; i < 13; i++)
  56. {
  57. SDK::CAnimationLayer layer = entity->GetAnimOverlay(i);
  58. const int activity = entity->GetSequenceActivity(layer.m_nSequence);
  59. if (activity == act) {
  60. *set = layer;
  61. return true;
  62. }
  63. }
  64. return false;
  65. }
  66.  
  67. void CResolver::record(SDK::CBaseEntity* entity, float new_yaw)
  68. {
  69. if (entity->GetVelocity().Length2D() > 36)
  70. return;
  71.  
  72. auto c_baseweapon = reinterpret_cast<SDK::CBaseWeapon*>(INTERFACES::ClientEntityList->GetClientEntity(entity->GetActiveWeaponIndex()));
  73.  
  74. if (!c_baseweapon)
  75. return;
  76.  
  77. auto &info = player_info[entity->GetIndex()];
  78.  
  79. if (entity->GetActiveWeaponIndex() && info.last_ammo < c_baseweapon->GetLoadedAmmo()) {
  80. //ignore the yaw when it is from shooting (will be looking at you/other player)
  81. info.last_ammo = c_baseweapon->GetLoadedAmmo();
  82. return;
  83. }
  84.  
  85. info.unresolved_yaw.insert(info.unresolved_yaw.begin(), new_yaw);
  86. if (info.unresolved_yaw.size() > 20) {
  87. info.unresolved_yaw.pop_back();
  88. }
  89.  
  90. if (info.unresolved_yaw.size() < 2)
  91. return;
  92.  
  93. auto average_unresolved_yaw = 0;
  94. for (auto val : info.unresolved_yaw)
  95. average_unresolved_yaw += val;
  96. average_unresolved_yaw /= info.unresolved_yaw.size();
  97.  
  98. int delta = average_unresolved_yaw - entity->GetLowerBodyYaw();
  99. auto big_math_delta = abs((((delta + 180) % 360 + 360) % 360 - 180));
  100.  
  101. info.lby_deltas.insert(info.lby_deltas.begin(), big_math_delta);
  102. if (info.lby_deltas.size() > 10) {
  103. info.lby_deltas.pop_back();
  104. }
  105. }
  106.  
  107. static void nospread_resolve(SDK::CBaseEntity* player, int entID) //gay but very effective reversed aw air resolver
  108. {
  109. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  110.  
  111. if (!local_player)
  112. return;
  113.  
  114. Vector local_position = local_player->GetVecOrigin() + local_player->GetViewOffset();
  115.  
  116. float atTargetAngle = UTILS::CalcAngle(local_player->GetHealth() <= 0 ? local_player->GetVecOrigin() : local_position, player->GetVecOrigin()).y;
  117. Vector velocityAngle;
  118. MATH::VectorAngles(player->GetVelocity(), velocityAngle);
  119.  
  120. float primaryBaseAngle = player->GetLowerBodyYaw();
  121. float secondaryBaseAngle = velocityAngle.y;
  122.  
  123. switch ((shots_missed[entID]) % 15)
  124. {
  125. case 0:
  126. player->EasyEyeAngles()->yaw = atTargetAngle + 180.f;
  127. break;
  128. case 1:
  129. player->EasyEyeAngles()->yaw = velocityAngle.y + 180.f;
  130. break;
  131. case 2:
  132. player->EasyEyeAngles()->yaw = primaryBaseAngle;
  133. break;
  134. case 3:
  135. player->EasyEyeAngles()->yaw = primaryBaseAngle - 45.f;
  136. break;
  137. case 4:
  138. player->EasyEyeAngles()->yaw = primaryBaseAngle + 90.f;
  139. break;
  140. case 5:
  141. player->EasyEyeAngles()->yaw = primaryBaseAngle - 130.f;
  142. break;
  143. case 6:
  144. player->EasyEyeAngles()->yaw = primaryBaseAngle - 180.f;
  145. break;
  146. case 7:
  147. player->EasyEyeAngles()->yaw = secondaryBaseAngle;
  148. break;
  149. case 8:
  150. player->EasyEyeAngles()->yaw = secondaryBaseAngle - 40.f;
  151. break;
  152. case 9:
  153. player->EasyEyeAngles()->yaw = secondaryBaseAngle - 90.f;
  154. break;
  155. case 10:
  156. player->EasyEyeAngles()->yaw = secondaryBaseAngle - 130.f;
  157. break;
  158. case 11:
  159. player->EasyEyeAngles()->yaw = secondaryBaseAngle - 70.f;
  160. break;
  161. case 12:
  162. player->EasyEyeAngles()->yaw = primaryBaseAngle + 45.f;
  163. break;
  164. case 13:
  165. player->EasyEyeAngles()->yaw = primaryBaseAngle + 135.f;
  166. break;
  167. case 14:
  168. player->EasyEyeAngles()->yaw = primaryBaseAngle - 90.f;
  169. break;
  170. }
  171. }
  172.  
  173. void CResolver::Experimental(SDK::CBaseEntity* entity) {
  174. {
  175. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  176.  
  177. if (!entity)
  178. return;
  179.  
  180. if (!local_player)
  181. return;
  182.  
  183. bool is_local_player = entity == local_player;
  184. bool is_teammate = local_player->GetTeam() == entity->GetTeam() && !is_local_player;
  185.  
  186. if (is_local_player)
  187. return;
  188.  
  189. if (is_teammate)
  190. return;
  191.  
  192. if (entity->GetHealth() <= 0)
  193. return;
  194.  
  195. if (local_player->GetHealth() <= 0)
  196. return;
  197.  
  198. //--- Variable Declaration ---//;
  199. auto &info = player_info[entity->GetIndex()];
  200.  
  201. //--- Variable Defenitions/Checks ---//
  202. float fl_lby = entity->GetLowerBodyYaw();
  203. static float LatestLowerBodyYawUpdateTime[55];
  204. float movinglby[64];
  205. movinglby[entity->GetIndex()] = entity->GetLowerBodyYaw();
  206. info.lby = Vector(entity->GetEyeAngles().x, entity->GetLowerBodyYaw(), 0.f);
  207. info.inverse = Vector(entity->GetEyeAngles().x, entity->GetLowerBodyYaw() + 180.f, 0.f);
  208. info.last_lby = Vector(entity->GetEyeAngles().x, info.last_moving_lby, 0.f);
  209. info.last_lby2 = Vector(entity->GetEyeAngles().x, info.last_moving_lby, UTILS::CalcAngle(entity->GetVecOrigin(), local_player->GetVecOrigin()).y);
  210. info.inverse_left = Vector(entity->GetEyeAngles().x, entity->GetLowerBodyYaw() + 115.f, 0.f);
  211. info.inverse_right = Vector(entity->GetEyeAngles().x, entity->GetLowerBodyYaw() - 115.f, 0.f);
  212. info.back = Vector(entity->GetEyeAngles().x, UTILS::CalcAngle(entity->GetVecOrigin(), local_player->GetVecOrigin()).y + 180.f, 0.f);
  213. info.right = Vector(entity->GetEyeAngles().x, UTILS::CalcAngle(entity->GetVecOrigin(), local_player->GetVecOrigin()).y + 90.f, 0.f);
  214. info.left = Vector(entity->GetEyeAngles().x, UTILS::CalcAngle(entity->GetVecOrigin(), local_player->GetVecOrigin()).y - 90.f, 0.f);
  215. info.moving_lby = Vector(entity->GetEyeAngles().x, movinglby[entity->GetIndex()], 0.f);
  216. info.moving_lby2 = Vector(entity->GetEyeAngles().x, movinglby[entity->GetIndex()], UTILS::CalcAngle(entity->GetVecOrigin(), local_player->GetVecOrigin()).y);
  217. info.backtrack = Vector(entity->GetEyeAngles().x, lby_to_back[entity->GetIndex()], 0.f);
  218. info.is_fakewalking = entity->GetVelocity().Length2D() > 34 && entity->GetVelocity().Length2D() < 40 && SDK::ACT_CSGO_IDLE_ADJUST_STOPPEDMOVING && SDK::ACT_CSGO_IDLE_TURN_BALANCEADJUST;
  219. shots_missed[entity->GetIndex()] = shots_fired[entity->GetIndex()] - shots_hit[entity->GetIndex()];
  220. if (SETTINGS::settings.fakefix_bool) //fakelag fix ez pz
  221. info.is_moving = entity->GetVelocity().Length2D() > 0.1 && entity->GetFlags() & FL_ONGROUND && !info.could_be_slowmo;
  222. else
  223. info.is_moving = entity->GetVelocity().Length2D() > 0.1;
  224. entity->GetFlags() & FL_ONGROUND;
  225. info.is_jumping = !entity->GetFlags() & FL_ONGROUND;
  226. info.could_be_slowmo = entity->GetVelocity().Length2D() > 6 && entity->GetVelocity().Length2D() < 36 && !info.is_crouching;
  227. info.is_crouching = entity->GetFlags() & FL_DUCKING;
  228. update_time[entity->GetIndex()] = info.next_lby_update_time;
  229.  
  230. static float old_simtime[65];
  231. if (entity->GetSimTime() != old_simtime[entity->GetIndex()])
  232. {
  233. using_fake_angles[entity->GetIndex()] = entity->GetSimTime() - old_simtime[entity->GetIndex()] == INTERFACES::Globals->interval_per_tick; //entity->GetSimTime() - old_simtime[entity->GetIndex()] >= TICKS_TO_TIME(2)
  234. old_simtime[entity->GetIndex()] = entity->GetSimTime();
  235. }
  236.  
  237. auto pick_best = [](float primary, float secondary, float defined, bool accurate) -> float
  238. {
  239. if (accurate)
  240. {
  241. if (MATH::YawDistance(primary, defined) <= 50)
  242. return primary;
  243. else if (MATH::YawDistance(secondary, defined) <= 50)
  244. return secondary;
  245. else
  246. return defined;
  247. }
  248. else
  249. {
  250. if (MATH::YawDistance(primary, defined) <= 80)
  251. return primary;
  252. else if (MATH::YawDistance(secondary, defined) <= 80)
  253. return secondary;
  254. else
  255. return defined;
  256. }
  257. };
  258.  
  259. //--- Actual Angle Resolving ---//
  260. //if (!using_fake_angles[entity->GetIndex()])
  261. //{
  262. if (backtrack_tick[entity->GetIndex()])
  263. {
  264. resolve_type[entity->GetIndex()] = 7;
  265. entity->SetEyeAngles(info.backtrack);
  266. }
  267. else if (info.stored_lby != entity->GetLowerBodyYaw() || info.is_fakewalking) //lby prediction
  268. {
  269. entity->SetEyeAngles(info.last_lby2);
  270. //info.next_lby_update_time = entity->GetSimTime() + 1.1;
  271. info.stored_lby = entity->GetLowerBodyYaw();
  272. resolve_type[entity->GetIndex()] = 3;
  273. }
  274. else if (info.is_jumping)
  275. {
  276. nospread_resolve(entity, entity->GetIndex());
  277. }
  278. else if (info.is_moving) //while moving
  279. {
  280. entity->SetEyeAngles(info.lby);
  281. info.last_moving_lby = entity->GetLowerBodyYaw();
  282. info.stored_missed = shots_missed[entity->GetIndex()];
  283. movinglby[entity->GetIndex()] = entity->GetLowerBodyYaw();
  284. resolve_type[entity->GetIndex()] = 1;
  285. }
  286. else
  287. {
  288.  
  289. //first thing we shoot when they stop
  290.  
  291. entity->SetEyeAngles(info.moving_lby2);
  292. resolve_type[entity->GetIndex()] = 5;
  293. }
  294. }
  295. }
  296. void CResolver::Default(SDK::CBaseEntity* entity) {
  297. {
  298. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  299.  
  300. if (!entity)
  301. return;
  302.  
  303. if (!local_player)
  304. return;
  305.  
  306. bool is_local_player = entity == local_player;
  307. bool is_teammate = local_player->GetTeam() == entity->GetTeam() && !is_local_player;
  308.  
  309. if (is_local_player)
  310. return;
  311.  
  312. if (is_teammate)
  313. return;
  314.  
  315. if (entity->GetHealth() <= 0)
  316. return;
  317.  
  318. if (local_player->GetHealth() <= 0)
  319. return;
  320.  
  321. //--- Variable Declaration ---//;
  322. auto &info = player_info[entity->GetIndex()];
  323.  
  324. //--- Variable Defenitions/Checks ---//
  325. float fl_lby = entity->GetLowerBodyYaw();
  326.  
  327. info.lby = Vector(entity->GetEyeAngles().x, entity->GetLowerBodyYaw(), 0.f);
  328. info.inverse = Vector(entity->GetEyeAngles().x, entity->GetLowerBodyYaw() + 180.f, 0.f);
  329. info.last_lby = Vector(entity->GetEyeAngles().x, info.last_moving_lby, 0.f);
  330. info.inverse_left = Vector(entity->GetEyeAngles().x, entity->GetLowerBodyYaw() + 115.f, 0.f);
  331. info.inverse_right = Vector(entity->GetEyeAngles().x, entity->GetLowerBodyYaw() - 115.f, 0.f);
  332.  
  333. info.back = Vector(entity->GetEyeAngles().x, UTILS::CalcAngle(entity->GetVecOrigin(), local_player->GetVecOrigin()).y + 180.f, 0.f);
  334. info.right = Vector(entity->GetEyeAngles().x, UTILS::CalcAngle(entity->GetVecOrigin(), local_player->GetVecOrigin()).y + 70.f, 0.f);
  335. info.left = Vector(entity->GetEyeAngles().x, UTILS::CalcAngle(entity->GetVecOrigin(), local_player->GetVecOrigin()).y - 70.f, 0.f);
  336.  
  337. info.backtrack = Vector(entity->GetEyeAngles().x, lby_to_back[entity->GetIndex()], 0.f);
  338.  
  339. shots_missed[entity->GetIndex()] = shots_fired[entity->GetIndex()] - shots_hit[entity->GetIndex()];
  340. info.is_moving = entity->GetVelocity().Length2D() > 0.1 && entity->GetFlags() & FL_ONGROUND && !info.could_be_slowmo;
  341. info.is_jumping = !entity->GetFlags() & FL_ONGROUND;
  342. info.could_be_slowmo = entity->GetVelocity().Length2D() > 6 && entity->GetVelocity().Length2D() < 36 && !info.is_crouching;
  343. info.is_crouching = entity->GetFlags() & FL_DUCKING;
  344. update_time[entity->GetIndex()] = info.next_lby_update_time;
  345.  
  346. static float old_simtime[65];
  347. if (entity->GetSimTime() != old_simtime[entity->GetIndex()])
  348. {
  349. using_fake_angles[entity->GetIndex()] = entity->GetSimTime() - old_simtime[entity->GetIndex()] == INTERFACES::Globals->interval_per_tick; entity->GetSimTime() - old_simtime[entity->GetIndex()] >= TICKS_TO_TIME(2);
  350. old_simtime[entity->GetIndex()] = entity->GetSimTime();
  351. }
  352.  
  353. //--- Actual Angle Resolving ---//
  354. if (!using_fake_angles[entity->GetIndex()])
  355. {
  356. if (backtrack_tick[entity->GetIndex()])
  357. {
  358. resolve_type[entity->GetIndex()] = 7;
  359. entity->SetEyeAngles(info.backtrack);
  360. }
  361. else if (info.stored_lby != entity->GetLowerBodyYaw()) // || entity->GetSimTime() > info.next_lby_update_time) lby prediction
  362. {
  363. entity->GetSimTime() > info.next_lby_update_time;
  364. entity->SetEyeAngles(info.lby);
  365. info.next_lby_update_time = entity->GetSimTime() + 1.1;
  366. info.stored_lby = entity->GetLowerBodyYaw();
  367. resolve_type[entity->GetIndex()] = 3;
  368. }
  369. else if (info.is_jumping)
  370. {
  371. nospread_resolve(entity, entity->GetIndex());
  372. }
  373. else if (info.is_moving) //while moving
  374. {
  375. entity->SetEyeAngles(info.lby);
  376. info.last_moving_lby = entity->GetLowerBodyYaw();
  377. info.stored_missed = shots_missed[entity->GetIndex()];
  378. resolve_type[entity->GetIndex()] = 1;
  379. }
  380. else
  381. {
  382. if (shots_missed[entity->GetIndex()] > info.stored_missed) //if we have missed 1 shot since we have stopped moving
  383. {
  384. resolve_type[entity->GetIndex()] = 4;
  385. switch (shots_missed[entity->GetIndex()] % 4)
  386. {
  387. case 0: entity->SetEyeAngles(info.inverse); break;
  388. case 1: entity->SetEyeAngles(info.left); break;
  389. case 2: entity->SetEyeAngles(info.back); break;
  390. case 3: entity->SetEyeAngles(info.right); break;
  391. }
  392. }
  393. else //first thing we shoot when they stop
  394. {
  395. entity->SetEyeAngles(info.last_lby);
  396. resolve_type[entity->GetIndex()] = 5;
  397. }
  398. }
  399. }
  400.  
  401.  
  402. SDK::CAnimationLayer layer = entity->GetAnimOverlay(0);
  403. if (entity->GetSimTime() != info.stored_simtime)
  404. {
  405. info.stored_simtime = entity->GetSimTime();
  406. info.prev_layer = info.backup_layer;
  407. SDK::CAnimationLayer dummy;
  408. info.backup_layer = find_layer(entity, 979, &dummy) ? dummy : layer;
  409. }
  410.  
  411. SDK::CAnimationLayer prev = info.prev_layer;
  412. auto server_time = local_player->GetTickBase() * INTERFACES::Globals->interval_per_tick; //i have a global dedicated to curtime but am using this because lemon is gay
  413.  
  414. if (info.is_moving && !info.could_be_slowmo)
  415. {
  416. entity->SetEyeAngles(info.lby);
  417. info.last_moving_lby = entity->GetLowerBodyYaw();
  418. info.stored_missed = shots_missed[entity->GetIndex()];
  419. info.last_move_time = server_time;
  420. info.reset_state = true;
  421. resolve_type[entity->GetIndex()] = 1;
  422. }
  423. else
  424. {
  425. if (info.stored_lby != entity->GetLowerBodyYaw())
  426. {
  427. entity->SetEyeAngles(info.lby);
  428. info.stored_lby = entity->GetLowerBodyYaw();
  429. info.next_lby_update_time = entity->GetSimTime() + 1.1;
  430. resolve_type[entity->GetIndex()] = 7;
  431. }
  432. else if (server_time - info.last_move_time < 0.1 && info.reset_state)
  433. {
  434. info.pre_anim_lby = entity->GetLowerBodyYaw();
  435. info.reset_state = false;
  436. info.breaking_lby = false;
  437. //std::cout << "reset and lby break is false!" << std::endl;
  438. }
  439. auto previous_is_valid = entity->GetSequenceActivity(prev.m_nSequence) == 979;
  440.  
  441. if (info.unresolved_yaw.size() < 2 || info.lby_deltas.size() < 2)
  442. return;
  443.  
  444. auto average_unresolved_yaw = 0;
  445. for (auto val : info.unresolved_yaw)
  446. average_unresolved_yaw += val;
  447. average_unresolved_yaw /= info.unresolved_yaw.size();
  448.  
  449. auto average_lby_delta = 0;
  450. for (auto val : info.lby_deltas)
  451. average_lby_delta += val;
  452. average_lby_delta /= info.lby_deltas.size();
  453.  
  454. int deltaxd = average_unresolved_yaw - entity->GetLowerBodyYaw();
  455. auto current_lby_delta = abs((((deltaxd + 180) % 360 + 360) % 360 - 180));
  456.  
  457. int update_delta = info.pre_anim_lby - entity->GetLowerBodyYaw();
  458. auto lby_update_delta = abs((((update_delta + 180) % 360 + 360) % 360 - 180));
  459.  
  460. if (find_layer(entity, 979, &layer)
  461. && previous_is_valid
  462. && (layer.m_flCycle != prev.m_flCycle
  463. || layer.m_flWeight == 1.f
  464. || server_time - info.last_move_time < 1.4
  465. && !info.breaking_lby
  466. && layer.m_flCycle >= 0.01
  467. && lby_update_delta > 75))
  468. {
  469. if (server_time - info.last_move_time < 1.4)
  470. {
  471. info.breaking_lby = true;
  472. //std::cout << "breaking lby" << std::endl;
  473. }
  474. entity->SetEyeAngles(info.inverse);
  475. resolve_type[entity->GetIndex()] = 6;
  476. }
  477. else
  478. {
  479. if (info.breaking_lby)
  480. {
  481. if (current_lby_delta > 130 && average_lby_delta > 130) {
  482. entity->SetEyeAngles(info.lby);
  483. resolve_type[entity->GetIndex()] = 7;
  484. }
  485. else {
  486. if (info.next_lby_update_time < entity->GetSimTime())
  487. {
  488. entity->SetEyeAngles(info.lby);
  489. info.next_lby_update_time = entity->GetSimTime() + 1.1;
  490. resolve_type[entity->GetIndex()] = 3;
  491. }
  492. else if (info.is_moving)
  493. {
  494. resolve_type[entity->GetIndex()] = 5;
  495. switch (shots_missed[entity->GetIndex()] % 2)
  496. {
  497. case 0: entity->SetEyeAngles(info.last_lby); break;
  498. case 1: entity->SetEyeAngles(info.inverse); break;
  499. }
  500. }
  501. else
  502. {
  503. if (shots_missed[entity->GetIndex()] > info.stored_missed)
  504. {
  505. resolve_type[entity->GetIndex()] = 4;
  506. switch (shots_missed[entity->GetIndex()] % 3)
  507. {
  508. case 0: entity->SetEyeAngles(info.inverse); break; //180
  509. case 1: entity->SetEyeAngles(info.inverse_left); break; //115
  510. case 2: entity->SetEyeAngles(info.inverse_right); break; //-115
  511. }
  512. }
  513. //else
  514. //{
  515. // resolve_type[entity->GetIndex()] = 2;
  516. // entity->SetEyeAngles(info.last_lby);
  517. //}
  518. }
  519. }
  520. }
  521. else
  522. {
  523. entity->SetEyeAngles(info.lby);
  524. resolve_type[entity->GetIndex()] = 7;
  525. }
  526. }
  527. }
  528. if (info.stored_lby != fl_lby)
  529. {
  530. entity->SetEyeAngles(info.lby);
  531. info.stored_lby = fl_lby;
  532. info.next_lby_update_time = entity->GetSimTime() + 1.1;
  533. resolve_type[entity->GetIndex()] = 1;
  534. }
  535. else if (info.next_lby_update_time < entity->GetSimTime())
  536. {
  537. entity->SetEyeAngles(info.lby);
  538. info.next_lby_update_time = entity->GetSimTime() + 1.1;
  539. resolve_type[entity->GetIndex()] = 3;
  540. }
  541. else if (info.is_moving && !info.could_be_slowmo)
  542. {
  543. entity->SetEyeAngles(info.lby);
  544. info.last_moving_lby = fl_lby;
  545. info.stored_missed = shots_missed[entity->GetIndex()];
  546. INTERFACES::Globals->curtime;
  547. resolve_type[entity->GetIndex()] = 1;
  548. }
  549. else
  550. {
  551. if (info.breaking_lby)
  552. {
  553. if (info.is_moving && !info.is_crouching)
  554. {
  555. resolve_type[entity->GetIndex()] = 5;
  556. switch (shots_missed[entity->GetIndex()] % 2)
  557. {
  558. case 0: entity->SetEyeAngles(info.last_lby); break;
  559. case 1: entity->SetEyeAngles(info.inverse); break;
  560. }
  561. }
  562. else {
  563. if (shots_missed[entity->GetIndex()] > info.stored_missed)
  564. {
  565. resolve_type[entity->GetIndex()] = 4;
  566. switch (shots_missed[entity->GetIndex()] % 4)
  567. {
  568. case 0: entity->SetEyeAngles(info.inverse); break;
  569. case 1: entity->SetEyeAngles(info.right); break;
  570. case 2: entity->SetEyeAngles(info.left); break;
  571. case 3: entity->SetEyeAngles(info.back); break;
  572. }
  573. }
  574. else
  575. {
  576. resolve_type[entity->GetIndex()] = 2;
  577. entity->SetEyeAngles(info.last_lby);
  578. }
  579. }
  580. }
  581. else
  582. {
  583. entity->SetEyeAngles(info.lby);
  584. resolve_type[entity->GetIndex()] = 1;
  585. }
  586. }
  587. }
  588.  
  589.  
  590. //--- Actual Angle Resolving ---//
  591. switch (SETTINGS::settings.res_type) {
  592. case 0:
  593. CResolver::Default(entity);
  594. break;
  595. case 1:
  596. CResolver::Experimental(entity);
  597. break;
  598.  
  599. }
  600. }
  601.  
  602. void CResolver::Resolve(SDK::CBaseEntity * entity)
  603. {
  604. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  605.  
  606. if (!entity)
  607. return;
  608.  
  609. if (!local_player)
  610. return;
  611.  
  612. bool is_local_player = entity == local_player;
  613. bool is_teammate = local_player->GetTeam() == entity->GetTeam() && !is_local_player;
  614.  
  615. if (is_local_player)
  616. return;
  617.  
  618. if (is_teammate)
  619. return;
  620.  
  621. if (entity->GetHealth() <= 0)
  622. return;
  623.  
  624. if (local_player->GetHealth() <= 0)
  625. return;
  626. }
  627.  
  628. 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!