API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 20th, 2018
78
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 20.48 KB | None | 0 0
raw download clone embed print report
  1. #include "../includes.h"
  2.  
  3. #include "../UTILS/interfaces.h"
  4. #include "../UTILS/render.h"
  5. #include "../SDK/CClientEntityList.h"
  6. #include "../SDK/IEngine.h"
  7. #include "../SDK/CBaseAnimState.h"
  8. #include "../SDK/CGlobalVars.h"
  9. #include "../SDK/GameEvents.h"
  10. #include "../SDK/CTrace.h"
  11. #include "../SDK/Collideable.h"
  12.  
  13. #include "../FEATURES/Backtracking.h"
  14. #include "../FEATURES/Autowall.h"
  15.  
  16. #include "Resolver.h"
  17. #include "Backtracking.h"
  18.  
  19. #define enc_str(s) std::string(s)
  20. #define enc_char(s) enc_str(s).c_str()
  21. #define enc_wstr(s) std::wstring(enc_str(s).begin(), enc_str(s).end())
  22. #define enc_wchar(s) enc_wstr(s).c_str()
  23.  
  24. namespace FEATURES
  25. {
  26. namespace RAGEBOT
  27. {
  28. Resolver resolver;
  29.  
  30. Resolver::Resolver() { }
  31.  
  32. void Resolver::DoFSN()
  33. {
  34. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  35. if (!local_player || local_player->GetHealth() <= 0)
  36. return;
  37.  
  38. for (int i = 0; i < 64; i++)
  39. {
  40. auto entity = INTERFACES::ClientEntityList->GetClientEntity(i);
  41. if (!entity || entity->GetHealth() <= 0 || entity->GetTeam() == local_player->GetTeam())
  42. continue;
  43.  
  44. UpdateResolveRecord(entity);
  45.  
  46. /// make sure to do dormant check AFTER calling UpdateResolveRecord()
  47. if (entity->GetIsDormant())
  48. continue;
  49.  
  50. ResolveYaw(entity);
  51. ResolvePitch(entity);
  52.  
  53. const auto resolve_record = player_resolve_records[i];
  54. entity->SetEyeAngles(resolve_record.resolved_angles);
  55. }
  56. }
  57.  
  58. void Resolver::DoCM()
  59. {
  60. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  61. if (!local_player || local_player->GetHealth() <= 0)
  62. return;
  63.  
  64. ProcessSnapShots();
  65.  
  66. last_eye_positions.insert(last_eye_positions.begin(), local_player->GetVecOrigin() + local_player->GetViewOffset());
  67. if (last_eye_positions.size() > 128)
  68. last_eye_positions.pop_back();
  69.  
  70. auto nci = INTERFACES::Engine->GetNetChannelInfo();
  71. if (!nci)
  72. return;
  73.  
  74. const int latency_ticks = TIME_TO_TICKS(nci->GetLatency(FLOW_OUTGOING));
  75. const auto latency_based_eye_pos = last_eye_positions.size() <= latency_ticks ? last_eye_positions.back() : last_eye_positions[latency_ticks];
  76. // RENDER::render_queue.AddDrawCircle(latency_based_eye_pos, 2, 50, RED);
  77. for (int i = 0; i < 64; i++)
  78. {
  79. auto entity = INTERFACES::ClientEntityList->GetClientEntity(i);
  80. if (!entity || entity->GetHealth() <= 0 || entity->GetTeam() == local_player->GetTeam() || entity->GetIsDormant())
  81. continue;
  82.  
  83. auto& resolve_record = player_resolve_records[i];
  84.  
  85. const float height = 64;
  86.  
  87. Vector direction_1, direction_2;
  88. MATH::AngleVectors(Vector(0.f, UTILS::CalcAngle(local_player->GetVecOrigin(), entity->GetVecOrigin()).y - 90.f, 0.f), &direction_1);
  89. MATH::AngleVectors(Vector(0.f, UTILS::CalcAngle(local_player->GetVecOrigin(), entity->GetVecOrigin()).y + 90.f, 0.f), &direction_2);
  90.  
  91. const auto left_eye_pos = entity->GetVecOrigin() + Vector(0, 0, height) + (direction_1 * 16.f);
  92. const auto right_eye_pos = entity->GetVecOrigin() + Vector(0, 0, height) + (direction_2 * 16.f);
  93.  
  94. resolve_record.anti_freestanding_record.left_damage = autowall->CalculateDamage(latency_based_eye_pos,
  95. left_eye_pos, local_player, entity).damage;
  96. resolve_record.anti_freestanding_record.right_damage = autowall->CalculateDamage(latency_based_eye_pos,
  97. right_eye_pos, local_player, entity).damage;
  98.  
  99. SDK::Ray_t ray;
  100. SDK::trace_t trace;
  101. SDK::CTraceWorldOnly filter;
  102.  
  103. ray.Init2(left_eye_pos, latency_based_eye_pos);
  104. INTERFACES::Trace->TraceRay(ray, MASK_ALL, &filter, &trace);
  105. resolve_record.anti_freestanding_record.left_fraction = trace.flFraction;
  106.  
  107. ray.Init2(right_eye_pos, latency_based_eye_pos);
  108. INTERFACES::Trace->TraceRay(ray, MASK_ALL, &filter, &trace);
  109. resolve_record.anti_freestanding_record.right_fraction = trace.flFraction;
  110.  
  111. resolve_record.did_predicted_lby_flick = false;
  112. resolve_record.did_lby_flick = false;
  113. }
  114. }
  115.  
  116. void Resolver::AddShotSnapshot(SDK::CBaseEntity* entity, PlayerResolveRecord resolve_record)
  117. {
  118. ShotSnapshot snapshot;
  119.  
  120. snapshot.entity = entity;
  121. snapshot.time = UTILS::GetCurtime();
  122. snapshot.resolve_record = resolve_record;
  123. snapshot.first_processed_time = 0.f;
  124. snapshot.was_shot_processed = false;
  125. snapshot.hitgroup_hit = -1;
  126.  
  127. shot_snapshots.push_back(snapshot);
  128. }
  129.  
  130. void Resolver::EventCallback(SDK::IGameEvent* game_event)
  131. {
  132. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  133. if (!local_player || local_player->GetHealth() <= 0 || !game_event)
  134. return;
  135.  
  136. if (shot_snapshots.size() <= 0)
  137. return;
  138.  
  139. auto& snapshot = shot_snapshots.front();
  140. switch (UTILS::FNVHashEx(game_event->GetName()))
  141. {
  142. case UTILS::FNVHashEx("player_hurt"):
  143. {
  144. /// it wasn't us who shot
  145. if (INTERFACES::Engine->GetPlayerForUserID(game_event->GetInt(enc_char("attacker"))) != INTERFACES::Engine->GetLocalPlayer())
  146. return;
  147.  
  148. if (!snapshot.was_shot_processed)
  149. {
  150. snapshot.was_shot_processed = true;
  151. snapshot.first_processed_time = UTILS::GetCurtime();
  152. }
  153.  
  154. snapshot.hitgroup_hit = game_event->GetInt(enc_char("hitgroup"));
  155.  
  156. break;
  157. }
  158. case UTILS::FNVHashEx("bullet_impact"):
  159. case UTILS::FNVHashEx("weapon_fire"):
  160. {
  161. /// it wasn't us who shot
  162. if (INTERFACES::Engine->GetPlayerForUserID(game_event->GetInt(enc_char("userid"))) != INTERFACES::Engine->GetLocalPlayer())
  163. return;
  164.  
  165. if (!snapshot.was_shot_processed)
  166. {
  167. snapshot.was_shot_processed = true;
  168. snapshot.first_processed_time = UTILS::GetCurtime();
  169. }
  170.  
  171. break;
  172. }
  173. }
  174. }
  175.  
  176. void Resolver::ProcessSnapShots()
  177. {
  178. if (shot_snapshots.size() <= 0)
  179. return;
  180.  
  181. const auto snapshot = shot_snapshots.front();
  182. if (fabs(UTILS::GetCurtime() - snapshot.time) > 1.f)
  183. {
  184. LOG(enc_char("** Unhandled shot snapshot!"));
  185. //FEATURES::MISC::in_game_logger.AddLog(FEATURES::MISC::InGameLogger::Log(enc_char("Unhandled shot snapshot!"), RED));
  186.  
  187. shot_snapshots.erase(shot_snapshots.begin());
  188. return;
  189. }
  190.  
  191. const int player_index = snapshot.entity->GetIndex();
  192. if (snapshot.hitgroup_hit != -1) /// hit
  193. {
  194. /// increment shots fired and shots hit
  195. for (int i = 0; i < RESOLVE_TYPE_NUM; i++)
  196. {
  197. if (snapshot.resolve_record.resolve_type & (1 << i))
  198. {
  199. player_resolve_records[player_index].shots_fired[i]++;
  200. player_resolve_records[player_index].shots_hit[i]++;
  201. }
  202. }
  203.  
  204. //FEATURES::MISC::in_game_logger.AddLog(FEATURES::MISC::InGameLogger::Log("Hit shot at " + TranslateResolveRecord(snapshot.resolve_record.resolve_type), GREEN));
  205. }
  206. else if (snapshot.first_processed_time != 0.f && fabs(UTILS::GetCurtime() - snapshot.first_processed_time) > 0.1f) /// missed
  207. {
  208. /// increment shots fired but not shots hit
  209. for (int i = 0; i < RESOLVE_TYPE_NUM; i++)
  210. {
  211. if (snapshot.resolve_record.resolve_type & (1 << i))
  212. player_resolve_records[player_index].shots_fired[i]++;
  213. }
  214.  
  215. if (snapshot.resolve_record.resolve_type & RESOLVE_TYPE_LAST_MOVING_LBY)
  216. player_resolve_records[player_index].shots_missed_moving_lby++;
  217.  
  218. if (snapshot.resolve_record.resolve_type & RESOLVE_TYPE_LAST_MOVING_LBY_DELTA)
  219. player_resolve_records[player_index].shots_missed_moving_lby_delta++;
  220.  
  221. //FEATURES::MISC::in_game_logger.AddLog(FEATURES::MISC::InGameLogger::Log("Missed shot at " + TranslateResolveRecord(snapshot.resolve_record.resolve_type), RED));
  222. }
  223. else
  224. return;
  225.  
  226. shot_snapshots.erase(shot_snapshots.begin());
  227. }
  228.  
  229. void Resolver::UpdateResolveRecord(SDK::CBaseEntity* entity)
  230. {
  231. /// a copy of the previous record for comparisons and shit
  232. const auto previous_record = player_resolve_records[entity->GetIndex()];
  233. auto& record = player_resolve_records[entity->GetIndex()];
  234.  
  235. record.resolved_angles = record.networked_angles;
  236. record.velocity = entity->GetVelocity();
  237. record.origin = entity->GetVecOrigin();
  238. record.lower_body_yaw = entity->GetLowerBodyYaw();
  239. record.is_dormant = entity->GetIsDormant();
  240. record.has_fake = IsFakingYaw(entity);
  241. record.resolve_type = 0;
  242.  
  243. record.is_balance_adjust_triggered = false, record.is_balance_adjust_playing = false;
  244. for (int i = 0; i < 15; i++) /// go through each animation layer
  245. {
  246. record.anim_layers[i] = entity->GetAnimOverlay(i);
  247.  
  248. /// balanceadjust act
  249. if (entity->GetSequenceActivity(record.anim_layers[i].m_nSequence) == SDK::CSGO_ACTS::ACT_CSGO_IDLE_TURN_BALANCEADJUST)
  250. {
  251. record.is_balance_adjust_playing = true;
  252.  
  253. /// balance adjust is being triggered
  254. if (record.anim_layers[i].m_flWeight == 1 || record.anim_layers[i].m_flCycle > previous_record.anim_layers[i].m_flCycle)
  255. record.last_balance_adjust_trigger_time = UTILS::GetCurtime();
  256. if (fabs(UTILS::GetCurtime() - record.last_balance_adjust_trigger_time) < 0.5f)
  257. record.is_balance_adjust_triggered = true;
  258. }
  259. }
  260.  
  261. if (record.is_dormant)
  262. record.next_predicted_lby_update = FLT_MAX;
  263.  
  264. /// if lby updated
  265. if (record.lower_body_yaw != previous_record.lower_body_yaw && !record.is_dormant && !previous_record.is_dormant)
  266. record.did_lby_flick = true;
  267.  
  268. /// fakewalk
  269. const bool is_moving_on_ground = record.velocity.Length2D() > 50 && entity->GetFlags() & FL_ONGROUND;
  270. if (is_moving_on_ground && record.is_balance_adjust_triggered)
  271. record.is_fakewalking = true;
  272. else
  273. record.is_fakewalking = false;
  274.  
  275. /// last moving lby, using a high velocity check ***just in case*** of fakewalkers
  276. if (is_moving_on_ground && !record.is_fakewalking && record.velocity.Length2D() > 1.f && !record.is_dormant)
  277. {
  278. record.is_last_moving_lby_valid = true;
  279. record.is_last_moving_lby_delta_valid = false;
  280. record.shots_missed_moving_lby = 0;
  281. record.shots_missed_moving_lby_delta = 0;
  282. record.last_moving_lby = record.lower_body_yaw + 45;
  283. record.last_time_moving = UTILS::GetCurtime();
  284. }
  285.  
  286. /// just came out of dormancy
  287. if (!record.is_dormant && previous_record.is_dormant)
  288. {
  289. /// if moved more than 32 units
  290. if ((record.origin - previous_record.origin).Length2D() > 16.f)
  291. record.is_last_moving_lby_valid = false;
  292. }
  293.  
  294. /// get last moving lby delta
  295. 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)
  296. {
  297. /// if lby updated
  298. if (record.lower_body_yaw != previous_record.lower_body_yaw)
  299. {
  300. record.last_moving_lby_delta = MATH::NormalizeYaw(record.last_moving_lby - record.lower_body_yaw);
  301. record.is_last_moving_lby_delta_valid = true;
  302. }
  303. }
  304.  
  305. if (MATH::NormalizePitch(record.networked_angles.x) > 5.f)
  306. record.last_time_down_pitch = UTILS::GetCurtime();
  307. }
  308.  
  309. void Resolver::ResolveYaw(SDK::CBaseEntity* entity)
  310. {
  311. auto& resolve_record = player_resolve_records[entity->GetIndex()];
  312.  
  313. if (resolve_record.did_lby_flick)
  314. {
  315. resolve_record.resolved_angles.y = resolve_record.lower_body_yaw;
  316. resolve_record.resolve_type |= RESOLVE_TYPE_LBY_UPDATE;
  317. }
  318. else if (resolve_record.did_predicted_lby_flick)
  319. {
  320. resolve_record.resolved_angles.y = resolve_record.lower_body_yaw;
  321. resolve_record.resolve_type |= RESOLVE_TYPE_PREDICTED_LBY_UPDATE;
  322. }
  323. else if (IsMovingOnGround(entity) && !IsFakewalking(entity)) /// moving
  324. {
  325. resolve_record.resolved_angles.y = resolve_record.last_moving_lby;
  326. resolve_record.resolve_type |= RESOLVE_TYPE_LBY;
  327. }
  328. else if (resolve_record.is_last_moving_lby_valid && resolve_record.shots_missed_moving_lby < 1 && IsYawSideways(entity, resolve_record.last_moving_lby)) /// last moving lby if sideways prioritizes over antiurine
  329. {
  330. resolve_record.resolved_angles.y = resolve_record.last_moving_lby;
  331. resolve_record.resolve_type |= RESOLVE_TYPE_LAST_MOVING_LBY;
  332. }
  333. else if (AntiFreestanding(entity, resolve_record.resolved_angles.y))
  334. {
  335. resolve_record.resolve_type |= RESOLVE_TYPE_ANTI_FREESTANDING;
  336. }
  337. else if (resolve_record.is_last_moving_lby_valid && resolve_record.shots_missed_moving_lby < 1) /// last moving lby
  338. {
  339. resolve_record.resolved_angles.y = resolve_record.last_moving_lby;
  340. resolve_record.resolve_type |= RESOLVE_TYPE_LAST_MOVING_LBY;
  341. }
  342. else /// bruteforce as last resort
  343. ResolveYawBruteforce(entity);
  344. }
  345.  
  346. void Resolver::ResolvePitch(SDK::CBaseEntity* entity)
  347. {
  348. auto& resolve_record = player_resolve_records[entity->GetIndex()];
  349.  
  350. if (resolve_record.resolve_type & RESOLVE_TYPE_LBY_UPDATE || resolve_record.resolve_type & RESOLVE_TYPE_PREDICTED_LBY_UPDATE ||
  351. resolve_record.resolve_type & RESOLVE_TYPE_NO_FAKE)
  352. resolve_record.resolved_angles.x = resolve_record.networked_angles.x;
  353. else
  354. {
  355. /// super fucking ghetto fix to stop their pitch from going to 0 when they're shooting (only neccesary when they're using psilent)
  356. if (fabs(UTILS::GetCurtime() - resolve_record.last_time_down_pitch) < 0.5f)
  357. resolve_record.resolved_angles.x = 70.f;
  358. else
  359. resolve_record.resolved_angles.x = resolve_record.networked_angles.x;
  360. }
  361.  
  362. resolve_record.resolved_angles.x = MATH::NormalizePitch(resolve_record.resolved_angles.x);
  363. }
  364.  
  365. float GetLBYRotatedYaw(float lby, float yaw)
  366. {
  367. float delta = MATH::NormalizeYaw(yaw - lby);
  368. if (fabs(delta) < 25.f)
  369. return lby;
  370.  
  371. if (delta > 0.f)
  372. return yaw + 25.f;
  373.  
  374. return yaw;
  375. }
  376.  
  377. void Resolver::ResolveYawBruteforce(SDK::CBaseEntity* entity)
  378. {
  379. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  380. if (!local_player)
  381. return;
  382.  
  383. auto& resolve_record = player_resolve_records[entity->GetIndex()];
  384. resolve_record.resolve_type |= RESOLVE_TYPE_BRUTEFORCE;
  385.  
  386. const float at_target_yaw = UTILS::CalcAngle(entity->GetVecOrigin(), local_player->GetVecOrigin()).y;
  387.  
  388. const int shots_missed = resolve_record.shots_fired[GetResolveTypeIndex(resolve_record.resolve_type)] -
  389. resolve_record.shots_hit[GetResolveTypeIndex(resolve_record.resolve_type)];
  390. switch (shots_missed % 3)
  391. {
  392. case 0:
  393. resolve_record.resolved_angles.y = GetLBYRotatedYaw(entity->GetLowerBodyYaw(), at_target_yaw + 60.f);
  394. break;
  395. case 1:
  396. resolve_record.resolved_angles.y = at_target_yaw + 140.f;
  397. break;
  398. case 2:
  399. resolve_record.resolved_angles.y = at_target_yaw - 75.f;
  400. break;
  401. }
  402. }
  403.  
  404. float Resolver::ResolveYawOverride(SDK::CBaseEntity* entity)
  405. {
  406. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  407. if (!local_player)
  408. return FLT_MAX;
  409.  
  410.  
  411.  
  412. Vector viewangles;
  413. INTERFACES::Engine->GetViewAngles(viewangles);
  414.  
  415. const float at_target_yaw = UTILS::CalcAngle(local_player->GetVecOrigin(), entity->GetVecOrigin()).y;
  416. if (fabs(MATH::NormalizeYaw(viewangles.y - at_target_yaw)) > 10.f)
  417. return FLT_MAX;
  418.  
  419. return GetLBYRotatedYaw(entity->GetLowerBodyYaw(), (MATH::NormalizeYaw(viewangles.y - at_target_yaw) > 0) ? at_target_yaw + 90.f : at_target_yaw - 90.f);
  420. }
  421.  
  422. bool Resolver::AntiFreestanding(SDK::CBaseEntity* entity, float& yaw)
  423. {
  424. const auto freestanding_record = player_resolve_records[entity->GetIndex()].anti_freestanding_record;
  425.  
  426. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  427. if (!local_player)
  428. return false;
  429.  
  430. if (freestanding_record.left_damage >= 20 && freestanding_record.right_damage >= 20)
  431. return false;
  432.  
  433. const float at_target_yaw = UTILS::CalcAngle(local_player->GetVecOrigin(), entity->GetVecOrigin()).y;
  434. if (freestanding_record.left_damage <= 0 && freestanding_record.right_damage <= 0)
  435. {
  436. if (freestanding_record.right_fraction < freestanding_record.left_fraction)
  437. yaw = at_target_yaw + 125.f;
  438. else
  439. yaw = at_target_yaw - 73.f;
  440. }
  441. else
  442. {
  443. if (freestanding_record.left_damage > freestanding_record.right_damage)
  444. yaw = at_target_yaw + 130.f;
  445. else
  446. yaw = at_target_yaw - 49.f;
  447. }
  448.  
  449. return true;
  450. }
  451.  
  452. bool Resolver::IsYawSideways(SDK::CBaseEntity* entity, float yaw)
  453. {
  454. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  455. if (!local_player)
  456. return false;
  457.  
  458. const auto at_target_yaw = UTILS::CalcAngle(local_player->GetVecOrigin(), entity->GetVecOrigin()).y;
  459. const float delta = fabs(MATH::NormalizeYaw(at_target_yaw - yaw));
  460.  
  461. return delta > 20.f && delta < 160.f;
  462. }
  463.  
  464. bool Resolver::IsFakingYaw(SDK::CBaseEntity* entity)
  465. {
  466. const auto bt_records = backtracking->GetRecords(entity);
  467. if (bt_records.size() < 2)
  468. return true;
  469.  
  470. if (bt_records.front().is_exploiting)
  471. return true;
  472.  
  473. if (fabs(bt_records[0].simulation_time - bt_records[1].simulation_time) == INTERFACES::Globals->interval_per_tick)
  474. return false;
  475.  
  476. return true;
  477. }
  478.  
  479. std::string Resolver::TranslateResolveRecord(unsigned short resolve_type)
  480. {
  481. std::vector<std::string> resolve_strings;
  482.  
  483. /// gonna have to use lorge if statements cuz fuck you
  484. if (resolve_type & RESOLVE_TYPE_OVERRIDE)
  485. resolve_strings.push_back(enc_str("OVERRIDE"));
  486. if (resolve_type & RESOLVE_TYPE_NO_FAKE)
  487. resolve_strings.push_back(enc_str("NO FAKE"));
  488. if (resolve_type & RESOLVE_TYPE_LBY)
  489. resolve_strings.push_back(enc_str("LBY"));
  490. if (resolve_type & RESOLVE_TYPE_LBY_UPDATE)
  491. resolve_strings.push_back(enc_str("LBY UPDATE"));
  492. if (resolve_type & RESOLVE_TYPE_PREDICTED_LBY_UPDATE)
  493. resolve_strings.push_back(enc_str("PREDICTED LBY UPDATE"));
  494. if (resolve_type & RESOLVE_TYPE_NOT_BREAKING_LBY)
  495. resolve_strings.push_back(enc_str("NOT BREAKING LBY"));
  496. if (resolve_type & RESOLVE_TYPE_BRUTEFORCE)
  497. resolve_strings.push_back(enc_str("BRUTEFORCE"));
  498. if (resolve_type & RESOLVE_TYPE_LAST_MOVING_LBY_DELTA)
  499. resolve_strings.push_back(enc_str("LAST MOVING LBY DELTA"));
  500. if (resolve_type & RESOLVE_TYPE_LAST_MOVING_LBY)
  501. resolve_strings.push_back(enc_str("LAST MOVING LBY"));
  502. if (resolve_type & RESOLVE_TYPE_ANTI_FREESTANDING)
  503. resolve_strings.push_back(enc_str("ANTI FREESTAND"));
  504.  
  505. if (resolve_strings.size() <= 0)
  506. return "GAY";
  507.  
  508. std::string buffer;
  509. for (const auto& str : resolve_strings)
  510. buffer.size() ? (buffer += " / " + str) : (buffer = str);
  511.  
  512. return buffer;
  513. }
  514.  
  515. CColor Resolver::GetResolveColor(unsigned short resolve_type)
  516. {
  517. /// gonna have to use lorge if statements cuz fuck you
  518. if (resolve_type & RESOLVE_TYPE_OVERRIDE)
  519. return RED;
  520. else if (resolve_type & RESOLVE_TYPE_NO_FAKE)
  521. return GREEN;
  522. else if (resolve_type & RESOLVE_TYPE_LBY)
  523. return GREEN;
  524. else if (resolve_type & RESOLVE_TYPE_LBY_UPDATE)
  525. return GREEN;
  526. else if (resolve_type & RESOLVE_TYPE_PREDICTED_LBY_UPDATE)
  527. return GREEN;
  528.  
  529. else if (resolve_type & RESOLVE_TYPE_NOT_BREAKING_LBY)
  530. return RED;
  531. else if (resolve_type & RESOLVE_TYPE_BRUTEFORCE)
  532. return RED;
  533. else if (resolve_type & RESOLVE_TYPE_LAST_MOVING_LBY_DELTA)
  534. return RED;
  535. else if (resolve_type & RESOLVE_TYPE_LAST_MOVING_LBY)
  536. return RED;
  537. else if (resolve_type & RESOLVE_TYPE_ANTI_FREESTANDING)
  538. return RED;
  539.  
  540. return WHITE;
  541. }
  542.  
  543. int Resolver::GetResolveTypeIndex(unsigned short resolve_type)
  544. {
  545. /// gonna have to use lorge if statements cuz fuck you
  546. if (resolve_type & RESOLVE_TYPE_OVERRIDE)
  547. return 0;
  548. else if (resolve_type & RESOLVE_TYPE_NO_FAKE)
  549. return 1;
  550. else if (resolve_type & RESOLVE_TYPE_LBY)
  551. return 2;
  552. else if (resolve_type & RESOLVE_TYPE_LBY_UPDATE)
  553. return 3;
  554. else if (resolve_type & RESOLVE_TYPE_PREDICTED_LBY_UPDATE)
  555. return 4;
  556. else if (resolve_type & RESOLVE_TYPE_LAST_MOVING_LBY)
  557. return 5;
  558. else if (resolve_type & RESOLVE_TYPE_NOT_BREAKING_LBY)
  559. return 6;
  560. else if (resolve_type & RESOLVE_TYPE_BRUTEFORCE)
  561. return 7;
  562. else if (resolve_type & RESOLVE_TYPE_LAST_MOVING_LBY_DELTA)
  563. return 8;
  564. else if (resolve_type & RESOLVE_TYPE_ANTI_FREESTANDING)
  565. return 9;
  566.  
  567. return 0;
  568. }
  569.  
  570. int Resolver::GetShotsMissed(SDK::CBaseEntity* entity, unsigned short resolve_type)
  571. {
  572. const int resolve_index = GetResolveTypeIndex(resolve_type);
  573.  
  574. return player_resolve_records[entity->GetIndex()].shots_fired[resolve_index] - player_resolve_records[entity->GetIndex()].shots_hit[resolve_index];
  575. }
  576. }
  577. }
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!