API tools faq
paste
Guest User

Untitled

a guest
May 18th, 2019
687
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 34.36 KB | None | 0 0
raw download clone embed print report
  1.  
  2. #include "utils/math.hpp"
  3.  
  4.  
  5. #define NETVAROFFS(type, name, table, netvar) \
  6. int name##() const { \
  7. static int _##name = NetMngr::Get().getOffs(table, netvar); \
  8. return _##name; \
  9. }
  10.  
  11. int override_hitchance;
  12. float override_mindmg;
  13. QAngle visualAngles = QAngle(0.f, 0.f, 0.f);
  14.  
  15. void AimRage::Work(CUserCmd * m_pcmd, csweaponinfo_t *weapt)
  16. {
  17. if (!g_ctx.m_local->is_alive())
  18. return;
  19.  
  20. if (!g_cfg.ragebot.rage_enabled)
  21. return;
  22.  
  23. this->local_weapon = g_ctx.m_local->m_hActiveWeapon().Get();
  24. this->m_pcmd = m_pcmd;
  25. this->cur_time = this->GetTickbase() * g_csgo.m_globals()->m_interval_per_tick;
  26.  
  27. g_cfg.ragebot.bAimbotting = false;
  28. g_cfg.ragebot.bVisualAimbotting = false;
  29.  
  30. if (g_cfg.ragebot.rage_autocockrevolver)
  31. {
  32. if (!this->CockRevolver())
  33. return;
  34. }
  35.  
  36. if (!local_weapon)
  37. return;
  38.  
  39. if (g_ctx.m_local->m_flNextAttack() > this->cur_time)
  40. return;
  41.  
  42. // Also add checks for grenade throw time if we dont have that yet.
  43. if (g_ctx.m_local->m_hActiveWeapon().Get()->IsWeaponNonAim() || g_ctx.m_local->m_hActiveWeapon().Get()->m_iClip1() < 1)
  44. return;
  45.  
  46. TargetEntities(weapt);
  47.  
  48. if (g_ctx.m_local->m_hActiveWeapon().Get()->IsAssaultRifle())
  49. {
  50. override_hitchance = g_cfg.ragebot.rage_hitchance_amount_assaultrifle;
  51. override_mindmg = g_cfg.ragebot.rage_mindmg_amount_assaultrifle;
  52. }
  53.  
  54. if (g_ctx.m_local->m_hActiveWeapon().Get()->IsPistolNotDeagR8())
  55. {
  56. override_hitchance = g_cfg.ragebot.rage_hitchance_amount_pistol;
  57. override_mindmg = g_cfg.ragebot.rage_mindmg_amount_pistol;
  58. }
  59.  
  60. if (g_ctx.m_local->m_hActiveWeapon().Get()->IsAutoSniper())
  61. {
  62. override_hitchance = *g_cfg.ragebot.rage_hitchance_amount_auto;
  63. override_mindmg = *g_cfg.ragebot.rage_mindmg_amount_auto;
  64. }
  65.  
  66. if (g_ctx.m_local->m_hActiveWeapon().Get()->IsDeagR8())
  67. {
  68. override_hitchance = g_cfg.ragebot.rage_hitchance_amount_deagr8;
  69. override_mindmg = g_cfg.ragebot.rage_mindmg_amount_deagr8;
  70. }
  71.  
  72. if (g_ctx.m_local->m_hActiveWeapon().Get()->IsAWP())
  73. {
  74. override_hitchance = g_cfg.ragebot.rage_hitchance_amount_awp;
  75. override_mindmg = g_cfg.ragebot.rage_mindmg_amount_awp;
  76. }
  77.  
  78. if (g_ctx.m_local->m_hActiveWeapon().Get()->IsScout())
  79. {
  80. override_hitchance = g_cfg.ragebot.rage_hitchance_amount_scout;
  81. override_mindmg = g_cfg.ragebot.rage_mindmg_amount_scout;
  82. }
  83.  
  84. if (g_ctx.m_local->m_hActiveWeapon().Get()->IsMG())
  85. {
  86. override_hitchance = g_cfg.ragebot.rage_hitchance_amount_mg;
  87. override_mindmg = g_cfg.ragebot.rage_mindmg_amount_mg;
  88. }
  89.  
  90. if (g_ctx.m_local->m_hActiveWeapon().Get()->IsSMG())
  91. {
  92. override_hitchance = g_cfg.ragebot.rage_hitchance_amount_smg;
  93. override_mindmg = g_cfg.ragebot.rage_mindmg_amount_smg;
  94. }
  95.  
  96. if (g_ctx.m_local->m_hActiveWeapon().Get()->IsShotgun())
  97. {
  98. override_hitchance = g_cfg.ragebot.rage_hitchance_amount_shotgun;
  99. override_mindmg = g_cfg.ragebot.rage_mindmg_amount_shotgun;
  100. }
  101. }
  102.  
  103. bool AimRage::TargetSpecificEnt(player_t* pEnt, csweaponinfo_t *weapt)
  104. {
  105.  
  106. int i = pEnt->EntIndex();
  107. auto firedShots = g_ctx.m_local->m_iShotsFired();
  108.  
  109. Vector vecTarget;
  110. int realHitboxSpot[] = { 0, 1, 2, 3 };
  111.  
  112. // Disgusting ass codes, can't think of a cleaner way now though. FIX ME.
  113. bool LagComp_Hitchanced = false;
  114. if (g_cfg.ragebot.rage_lagcompensation) //&& g_ctx.m_local->m_hActiveWeapon().Get()->IsNotPistol() && pEnt->m_vecVelocity().Length2D() > 0.1)
  115. {
  116. if (pEnt->m_vecVelocity().Length2D() > 0.1)
  117. {
  118. Global::CanDoBacktrack = true;
  119. CMBacktracking::Get().RageBacktrack(pEnt, m_pcmd, vecTarget, LagComp_Hitchanced);
  120. }
  121. else
  122. {
  123. //Global::CanDoBacktrack = false;
  124. matrix3x4_t matrix[128];
  125. if (!pEnt->SetupBones(matrix, 128, 256, pEnt->m_flSimulationTime()))
  126. return false;
  127.  
  128. if (g_cfg.ragebot.rage_autobaim && firedShots > g_cfg.ragebot.rage_baim_after_x_shots)
  129. vecTarget = CalculateBestPoint(pEnt, HITBOX_PELVIS, override_mindmg, true, matrix, weapt);
  130. else
  131. {
  132. if (g_ctx.m_local->m_hActiveWeapon()->IsPistolNotDeagR8())
  133. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_pistol], override_mindmg, g_cfg.ragebot.bRage_prioritize_pistol, matrix, weapt);
  134. if (g_ctx.m_local->m_hActiveWeapon()->IsDeagR8())
  135. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_deagr8], override_mindmg, g_cfg.ragebot.bRage_prioritize_deagr8, matrix, weapt);
  136. if (g_ctx.m_local->m_hActiveWeapon()->IsSMG())
  137. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_smg], override_mindmg, g_cfg.ragebot.bRage_prioritize_smg, matrix, weapt);
  138. if (g_ctx.m_local->m_hActiveWeapon()->IsMG())
  139. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_mg], override_mindmg, g_cfg.ragebot.bRage_prioritize_mg, matrix, weapt);
  140. if (g_ctx.m_local->m_hActiveWeapon()->IsShotgun())
  141. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_shotgun], override_mindmg, g_cfg.ragebot.bRage_prioritize_shotgun, matrix, weapt);
  142. if (g_ctx.m_local->m_hActiveWeapon()->IsAssaultRifle())
  143. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_assaultrifle], override_mindmg, g_cfg.ragebot.bRage_prioritize_assaultrifle, matrix, weapt);
  144. if (g_ctx.m_local->m_hActiveWeapon()->IsScout())
  145. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_scout], override_mindmg, g_cfg.ragebot.bRage_prioritize_scout, matrix, weapt);
  146. if (g_ctx.m_local->m_hActiveWeapon()->IsAWP())
  147. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_awp], override_mindmg, g_cfg.ragebot.bRage_prioritize_awp, matrix, weapt);
  148. if (g_ctx.m_local->m_hActiveWeapon()->IsAutoSniper())
  149. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_auto], override_mindmg, g_cfg.ragebot.bRage_prioritize_auto, matrix, weapt);
  150. }
  151. }
  152. }
  153. else
  154. {
  155. //Global::CanDoBacktrack = false;
  156. matrix3x4_t matrix[128];
  157. if (!pEnt->SetupBones(matrix, 128, 256, pEnt->m_flSimulationTime()))
  158. return false;
  159.  
  160. if (g_cfg.ragebot.rage_autobaim && firedShots > g_cfg.ragebot.rage_baim_after_x_shots)
  161. vecTarget = CalculateBestPoint(pEnt, HITBOX_PELVIS, override_mindmg, true, matrix, weapt);
  162. else
  163. {
  164. if (g_ctx.m_local->m_hActiveWeapon()->IsPistolNotDeagR8())
  165. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_pistol], override_mindmg, g_cfg.ragebot.bRage_prioritize_pistol, matrix, weapt);
  166. if (g_ctx.m_local->m_hActiveWeapon()->IsDeagR8())
  167. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_deagr8], override_mindmg, g_cfg.ragebot.bRage_prioritize_deagr8, matrix, weapt);
  168. if (g_ctx.m_local->m_hActiveWeapon()->is_smg())
  169. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_smg], override_mindmg, g_cfg.ragebot.bRage_prioritize_smg, matrix, weapt);
  170. if (g_ctx.m_local->m_hActiveWeapon()->IsMG())
  171. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_mg], override_mindmg, g_cfg.ragebot.bRage_prioritize_mg, matrix, weapt);
  172. if (g_ctx.m_local->m_hActiveWeapon()->IsShotgun())
  173. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_shotgun], override_mindmg, g_cfg.ragebot.bRage_prioritize_shotgun, matrix, weapt);
  174. if (g_ctx.m_local->m_hActiveWeapon()->IsAssaultRifle())
  175. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_assaultrifle], override_mindmg, g_cfg.ragebot.bRage_prioritize_assaultrifle, matrix, weapt);
  176. if (g_ctx.m_local->m_hActiveWeapon()->IsScout())
  177. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_scout], override_mindmg, g_cfg.ragebot.bRage_prioritize_scout, matrix, weapt);
  178. if (g_ctx.m_local->m_hActiveWeapon()->IsAWP())
  179. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_awp], override_mindmg, g_cfg.ragebot.bRage_prioritize_awp, matrix, weapt);
  180. if (g_ctx.m_local->m_hActiveWeapon()->IsAutoSniper())
  181. vecTarget = CalculateBestPoint(pEnt, realHitboxSpot[g_cfg.ragebot.iRage_hitbox_auto], override_mindmg, g_cfg.ragebot.bRage_prioritize_auto, matrix, weapt);
  182. }
  183. }
  184.  
  185. // Invalid target/no hitable points at all.
  186. if (!vecTarget.IsValid())
  187. return false;
  188.  
  189. //AutoStop();
  190. //AutoCrouch();
  191.  
  192. QAngle new_aim_angles = math::CalcAngle(g_ctx.m_local->get_eye_pos(), vecTarget) - (g_cfg.ragebot.rage_norecoil ? g_ctx.m_local->m_aimPunchAngle1() * 2.f : QAngle(0, 0, 0));
  193. this->m_viewangles1 = g_cfg.ragebot.vecVisualAimbotAngs = new_aim_angles;
  194. g_cfg.ragebot.vecVisualAimbotAngs += (g_cfg.misc.removals_novisualrecoil ? g_ctx.m_local->m_aimPunchAngle1() * 2.f : QAngle(0, 0, 0));
  195. g_cfg.ragebot.bVisualAimbotting = true;
  196.  
  197. if (this->can_fire_weapon)
  198. {
  199. // Save more fps by remembering to try the same entity again next time.
  200. prev_aimtarget = pEnt->EntIndex();
  201.  
  202. if (g_cfg.ragebot.rage_autoscope && g_ctx.m_local->m_hActiveWeapon().Get()->IsAutoScopeable() && g_ctx.m_local->m_hActiveWeapon().Get()->m_zoomLevel() == 0)
  203. {
  204. m_pcmd->m_buttons |= IN_ATTACK2;
  205. }
  206. else if ((g_cfg.ragebot.rage_lagcompensation && LagComp_Hitchanced) || (!LagComp_Hitchanced && HitChance(m_viewangles1, pEnt, override_hitchance)))
  207. {
  208. g_cfg.ragebot.bAimbotting = true;
  209.  
  210. if (g_cfg.ragebot.rage_autoshoot)
  211. {
  212. m_pcmd->m_buttons |= IN_ATTACK;
  213. }
  214. }
  215. }
  216.  
  217. return true;
  218. }
  219.  
  220. void AimRage::TargetEntities(csweaponinfo_t *weapt)
  221. {
  222. static weapon_t *oldWeapon; // what is this for?
  223. if (local_weapon != oldWeapon)
  224. {
  225. oldWeapon = local_weapon;
  226. m_pcmd->m_buttons &= ~IN_ATTACK;
  227. return;
  228. }
  229.  
  230. if (local_weapon->IsPistolNotDeagR8() && m_pcmd->m_tickcount % 2)
  231. {
  232. static int lastshot;
  233. if (m_pcmd->m_buttons & IN_ATTACK)
  234. lastshot++;
  235.  
  236. if (!m_pcmd->m_buttons & IN_ATTACK || lastshot > 1)
  237. {
  238. m_pcmd->m_buttons &= ~IN_ATTACK;
  239. lastshot = 0;
  240. }
  241. return;
  242. }
  243.  
  244. /*
  245. We should also add those health/fov based memes and only check newest record. Good enough IMO
  246. */
  247.  
  248. this->can_fire_weapon = local_weapon->can_fire();
  249.  
  250. if (prev_aimtarget && CheckTarget(prev_aimtarget))
  251. {
  252. if (TargetSpecificEnt(player_t::GetPlayerByIndex(prev_aimtarget),weapt))
  253. return;
  254. }
  255.  
  256. for (int i = 1; i < g_csgo.m_engine()->GetMaxClients(); i++)
  257. {
  258. // Failed to shoot at him again, reset him and try others.
  259. if (prev_aimtarget && prev_aimtarget == i)
  260. {
  261. prev_aimtarget = NULL;
  262. continue;
  263. }
  264.  
  265. if (!CheckTarget(i))
  266. continue;
  267.  
  268. player_t *player = player_t::GetPlayerByIndex(i);
  269.  
  270. if (TargetSpecificEnt(player, weapt))
  271. return;
  272. }
  273. }
  274.  
  275. float AimRage::BestHitPoint(player_t *player, int prioritized, float minDmg, mstudiohitboxset_t *hitset, matrix3x4_t matrix[], Vector &vecOut, csweaponinfo_t *weapt)
  276. {
  277. mstudiobbox_t *hitbox = hitset->pHitbox(prioritized);
  278. if (!hitbox)
  279. return 0.f;
  280.  
  281. std::vector<Vector> vecArray;
  282. float flHigherDamage = 0.f;
  283.  
  284. float mod = hitbox->m_flRadius != -1.f ? hitbox->m_flRadius : 0.f;
  285.  
  286. Vector max;
  287. Vector min;
  288.  
  289. math::vector_transform(hitbox->bbmax + mod, matrix[hitbox->bone], max);
  290. math::vector_transform(hitbox->bbmin - mod, matrix[hitbox->bone], min);
  291.  
  292. auto center = (min + max) * 0.5f;
  293.  
  294. QAngle curAngles = math::CalcAngle(center, g_ctx.m_local->get_eye_pos());
  295.  
  296. Vector forward;
  297. math::angle_vectors(curAngles, forward);
  298.  
  299. Vector right = forward.Cross(Vector(0, 0, 1));
  300. Vector left = Vector(-right.x, -right.y, right.z);
  301.  
  302. Vector top = Vector(0, 0, 1);
  303. Vector bot = Vector(0, 0, -1);
  304.  
  305. float POINT_SCALE;// = g_Options.rage_pointscale_amount_pistol;
  306. if (g_ctx.m_local->m_hActiveWeapon()->IsPistolNotDeagR8())
  307. POINT_SCALE = g_cfg.ragebot.rage_pointscale_amount_pistol;
  308.  
  309. if (g_ctx.m_local->m_hActiveWeapon()->IsDeagR8())
  310. POINT_SCALE = g_cfg.ragebot.rage_pointscale_amount_deagr8;
  311.  
  312. if (g_ctx.m_local->m_hActiveWeapon()->IsSMG())
  313. POINT_SCALE = g_cfg.ragebot.rage_pointscale_amount_smg;
  314.  
  315. if (g_ctx.m_local->m_hActiveWeapon()->IsMG())
  316. POINT_SCALE = g_cfg.ragebot.rage_pointscale_amount_mg;
  317.  
  318. if (g_ctx.m_local->m_hActiveWeapon()->IsShotgun())
  319. POINT_SCALE = g_cfg.ragebot.rage_pointscale_amount_shotgun;
  320.  
  321. if (g_ctx.m_local->m_hActiveWeapon()->IsAssaultRifle())
  322. POINT_SCALE = g_cfg.ragebot.rage_pointscale_amount_assaultrifle;
  323.  
  324. if (g_ctx.m_local->m_hActiveWeapon()->IsScout())
  325. POINT_SCALE = g_cfg.ragebot.rage_pointscale_amount_scout;
  326.  
  327. if (g_ctx.m_local->m_hActiveWeapon()->IsAWP())
  328. POINT_SCALE = g_cfg.ragebot.rage_pointscale_amount_awp;
  329.  
  330. if (g_ctx.m_local->m_hActiveWeapon()->IsAutoSniper())
  331. POINT_SCALE = g_cfg.ragebot.rage_pointscale_amount_auto;
  332.  
  333. if (g_ctx.m_local->m_hActiveWeapon()->IsPistolNotDeagR8() && g_cfg.ragebot.bRage_multipoint_pistol ||
  334. g_ctx.m_local->m_hActiveWeapon()->IsDeagR8() && g_cfg.ragebot.bRage_multipoint_deagr8 ||
  335. g_ctx.m_local->m_hActiveWeapon()->IsSMG() && g_cfg.ragebot.bRage_multipoint_smg ||
  336. g_ctx.m_local->m_hActiveWeapon()->IsMG() && g_cfg.ragebot.bRage_multipoint_mg ||
  337. g_ctx.m_local->m_hActiveWeapon()->IsShotgun() && g_cfg.ragebot.bRage_multipoint_shotgun ||
  338. g_ctx.m_local->m_hActiveWeapon()->IsAssaultRifle() && g_cfg.ragebot.bRage_multipoint_assaultrifle ||
  339. g_ctx.m_local->m_hActiveWeapon()->IsScout() && g_cfg.ragebot.bRage_multipoint_scout ||
  340. g_ctx.m_local->m_hActiveWeapon()->IsAWP() && g_cfg.ragebot.bRage_multipoint_awp ||
  341. g_ctx.m_local->m_hActiveWeapon()->IsAutoSniper() && g_cfg.ragebot.bRage_multipoint_auto)
  342. {
  343. switch (prioritized)
  344. {
  345. case HITBOX_HEAD:
  346. for (auto i = 0; i < 4; ++i)
  347. {
  348. vecArray.emplace_back(center);
  349. }
  350. vecArray[1] += top * (hitbox->m_flRadius * POINT_SCALE);
  351. vecArray[2] += right * (hitbox->m_flRadius * POINT_SCALE);
  352. vecArray[3] += left * (hitbox->m_flRadius * POINT_SCALE);
  353. break;
  354.  
  355. default:
  356.  
  357. for (auto i = 0; i < 2; ++i)
  358. {
  359. vecArray.emplace_back(center);
  360. }
  361. vecArray[0] += right * (hitbox->m_flRadius * POINT_SCALE);
  362. vecArray[1] += left * (hitbox->m_flRadius * POINT_SCALE);
  363. break;
  364. }
  365. }
  366. else
  367. vecArray.emplace_back(center);
  368.  
  369. for (Vector cur : vecArray)
  370. {
  371. float flCurDamage = GetDamageVec(cur, player, prioritized, weapt);
  372.  
  373. if (!flCurDamage)
  374. continue;
  375.  
  376. if ((flCurDamage > flHigherDamage) && (flCurDamage > minDmg))
  377. {
  378. flHigherDamage = flCurDamage;
  379. vecOut = cur;
  380. }
  381. }
  382. return flHigherDamage;
  383. }
  384.  
  385. Vector AimRage::CalculateBestPoint(player_t *player, int prioritized, float minDmg, bool onlyPrioritized, matrix3x4_t matrix[], csweaponinfo_t *weapt)
  386. {
  387. studiohdr_t *studioHdr = g_csgo.m_modelinfo()->GetStudiomodel(player->GetModel());
  388. mstudiohitboxset_t *set = studioHdr->pHitboxSet(player->m_nHitboxSet());
  389. Vector vecOutput;
  390.  
  391. if (BestHitPoint(player, prioritized, minDmg, set, matrix, vecOutput, weapt) > minDmg && onlyPrioritized)
  392. {
  393. return vecOutput;
  394. }
  395. else
  396. {
  397. float flHigherDamage = 0.f;
  398.  
  399. Vector vecCurVec;
  400.  
  401. // why not use all the hitboxes then
  402. //static Hitboxes hitboxesLoop;
  403. static int hitboxesLoop[] =
  404. {
  405. HITBOX_HEAD,
  406. HITBOX_PELVIS,
  407. HITBOX_UPPER_CHEST,
  408. HITBOX_CHEST,
  409. HITBOX_NECK,
  410. HITBOX_LEFT_FOREARM,
  411. HITBOX_RIGHT_FOREARM,
  412. HITBOX_RIGHT_HAND,
  413. HITBOX_LEFT_THIGH,
  414. HITBOX_RIGHT_THIGH,
  415. HITBOX_LEFT_CALF,
  416. HITBOX_RIGHT_CALF,
  417. HITBOX_LEFT_FOOT,
  418. HITBOX_RIGHT_FOOT
  419. };
  420.  
  421. int loopSize = ARRAYSIZE(hitboxesLoop);
  422. for (int i = 0; i < loopSize; ++i)
  423. {
  424. if (g_ctx.m_local->m_hActiveWeapon()->IsPistolNotDeagR8())
  425. if (!g_cfg.ragebot.rage_multiHitboxesPistol[i])
  426. continue;
  427. if (g_ctx.m_local->m_hActiveWeapon()->IsDeagR8())
  428. if (!g_cfg.ragebot.rage_multiHitboxesDeagR8[i])
  429. continue;
  430. if (g_ctx.m_local->m_hActiveWeapon()->IsSMG())
  431. if (!g_cfg.ragebot.rage_multiHitboxesSMG[i])
  432. continue;
  433. if (g_ctx.m_local->m_hActiveWeapon()->IsShotgun())
  434. if (!g_cfg.ragebot.rage_multiHitboxesShotgun[i])
  435. continue;
  436. if (g_ctx.m_local->m_hActiveWeapon()->IsMG())
  437. if (!g_cfg.ragebot.rage_multiHitboxesMG[i])
  438. continue;
  439. if (g_ctx.m_local->m_hActiveWeapon()->IsScout())
  440. if (!g_cfg.ragebot.rage_multiHitboxesScout[i])
  441. continue;
  442. if (g_ctx.m_local->m_hActiveWeapon()->IsAWP())
  443. if (!g_cfg.ragebot.rage_multiHitboxesAWP[i])
  444. continue;
  445. if (g_ctx.m_local->m_hActiveWeapon()->IsAutoSniper())
  446. if (!g_cfg.ragebot.rage_multiHitboxesAuto[i])
  447. continue;
  448. if (g_ctx.m_local->m_hActiveWeapon()->IsAssaultRifle())
  449. if (!g_cfg.ragebot.rage_multiHitboxesAssaultRifle[i])
  450. continue;
  451.  
  452. float flCurDamage = BestHitPoint(player, hitboxesLoop[i], minDmg, set, matrix, vecCurVec, weapt);
  453.  
  454. if (!flCurDamage)
  455. continue;
  456.  
  457. if (flCurDamage > flHigherDamage)
  458. {
  459. flHigherDamage = flCurDamage;
  460. vecOutput = vecCurVec;
  461. if (static_cast<int32_t>(flHigherDamage) >= player->m_iHealth())
  462. break;
  463. }
  464. }
  465. return vecOutput;
  466. }
  467. }
  468.  
  469. bool AimRage::CheckTarget(int i)
  470. {
  471. player_t *player = player_t::GetPlayerByIndex(i);
  472.  
  473. if (!player || player == nullptr)
  474. return false;
  475.  
  476. if (player == g_ctx.m_local)
  477. return false;
  478.  
  479. //if (player->IsTeamMate())
  480. // return false;
  481.  
  482. if (player->IsDormant())
  483. return false;
  484.  
  485. if (player->m_bGunGameImmunity())
  486. return false;
  487.  
  488. if (!player->is_alive())
  489. return false;
  490.  
  491. return true;
  492. }
  493.  
  494. bool AimRage::HitChance(QAngle angles, player_t *ent, float chance)
  495. {
  496. auto weapon = ent->m_hActiveWeapon();
  497.  
  498. if (!weapon)
  499. return false;
  500.  
  501. Vector forward, right, up;
  502. Vector src = g_ctx.m_local->get_eye_pos();
  503. math::AngleVectors(angles, forward, right, up);
  504.  
  505. int cHits = 0;
  506. int cNeededHits = static_cast<int>(150.f * (chance / 100.f));
  507.  
  508. weapon->update_accuracy_penality();
  509. float weap_spread = weapon->get_spread();
  510. float weap_inaccuracy = weapon->get_innacuracy();
  511.  
  512. for (int i = 0; i < 150; i++)
  513. {
  514. float a = math::random_float(0.f, 1.f);
  515. float b = math::random_float(0.f, 2.f * M_PI);
  516. float c = math::random_float(0.f, 1.f);
  517. float d = math::random_float(0.f, 2.f * M_PI);
  518.  
  519. float inaccuracy = a * weap_inaccuracy;
  520. float spread = c * weap_spread;
  521.  
  522. if (weapon->m_iItemDefinitionIndex() == 64)
  523. {
  524. a = 1.f - a * a;
  525. a = 1.f - c * c;
  526. }
  527.  
  528. Vector spreadView((cos(b) * inaccuracy) + (cos(d) * spread), (sin(b) * inaccuracy) + (sin(d) * spread), 0), direction;
  529.  
  530. direction.x = forward.x + (spreadView.x * right.x) + (spreadView.y * up.x);
  531. direction.y = forward.y + (spreadView.x * right.y) + (spreadView.y * up.y);
  532. direction.z = forward.z + (spreadView.x * right.z) + (spreadView.y * up.z);
  533. direction.Normalized();
  534.  
  535. QAngle viewAnglesSpread;
  536. math::VectorAngles(direction, up, viewAnglesSpread);
  537. math::NormalizeAngles(viewAnglesSpread);
  538.  
  539. Vector viewForward;
  540. math::angle_vectors(viewAnglesSpread, viewForward);
  541. viewForward.NormalizeInPlace();
  542.  
  543. viewForward = src + (viewForward * local_weapon->get_csweapon_info()->range);
  544.  
  545. trace_t tr;
  546. Ray_t ray;
  547.  
  548. ray.Init(src, viewForward);
  549. g_csgo.m_trace()->ClipRayToEntity(ray, MASK_SHOT | CONTENTS_GRATE, ent, &tr);
  550.  
  551. if (tr.hit_entity == ent)
  552. ++cHits;
  553.  
  554. if (static_cast<int>((static_cast<float>(cHits) / 150.f) * 100.f) >= chance)
  555. return true;
  556.  
  557. if ((150 - i + cHits) < cNeededHits)
  558. return false;
  559. }
  560. return false;
  561. }
  562.  
  563. //void AimRage::AutoStop()
  564. //{
  565. // if (!g_cfg.ragebot.rage_autostop)
  566. // return;
  567. //
  568. // if (g_InputSystem->IsButtonDown(g_Options.misc_fakewalk_bind))
  569. // return;
  570. //
  571. // m_pcmd->m_forwardmove = 0;
  572. // m_pcmd->m_sidemove = 0;
  573. //}
  574.  
  575. bool AimRage::CockRevolver()
  576. {
  577. // 0.234375f to cock and shoot, 15 ticks in 64 servers, 30(31?) in 128
  578.  
  579. // THIS DOESNT WORK, WILL WORK ON LATER AGAIN WHEN I FEEL LIKE KILLING MYSELF
  580.  
  581. // DONT USE TIME_TO_TICKS as these values aren't good for it. it's supposed to be 0.2f but that's also wrong
  582. constexpr float REVOLVER_COCK_TIME = 0.234375f;// 0.2421875f;
  583. const int count_needed = floor(REVOLVER_COCK_TIME / g_csgo.m_globals()->m_interval_per_tick);
  584. static int cocks_done = 0;
  585.  
  586. if (!local_weapon ||
  587. local_weapon->m_iItemDefinitionIndex() != WEAPON_REVOLVER ||
  588. g_ctx.m_local->m_flNextAttack() > g_csgo.m_globals()->m_curtime ||
  589. local_weapon->IsReloading())
  590. {
  591. if (local_weapon && local_weapon->m_iItemDefinitionIndex() == WEAPON_REVOLVER)
  592. m_pcmd->m_buttons &= ~IN_ATTACK;
  593. cocks_done = 0;
  594. return true;
  595. }
  596.  
  597. if (cocks_done < count_needed)
  598. {
  599. m_pcmd->m_buttons |= IN_ATTACK;
  600. ++cocks_done;
  601. return false;
  602. }
  603. else
  604. {
  605. m_pcmd->m_buttons &= ~IN_ATTACK;
  606. cocks_done = 0;
  607. return true;
  608. }
  609.  
  610. // 0.0078125 - 128ticks - 31 - 0.2421875
  611. // 0.015625 - 64 ticks - 16 - 0.234375f
  612.  
  613. m_pcmd->m_buttons |= IN_ATTACK;
  614.  
  615. /*
  616. 3 steps:
  617.  
  618. 1. Come, not time for update, cock and return false;
  619.  
  620. 2. Come, completely outdated, cock and set time, return false;
  621.  
  622. 3. Come, time is up, cock and return true;
  623.  
  624. Notes:
  625. Will I not have to account for high ping when I shouldn't send another update?
  626. Lower framerate than ticks = riperino? gotta check if lower then account by sending earlier | frametime memes
  627. */
  628.  
  629. float curtime = TICKS_TO_TIME(g_ctx.m_local->m_nTickBase());
  630. static float next_shoot_time = 0.f;
  631.  
  632. bool ret = false;
  633.  
  634. if (next_shoot_time - curtime < -0.5)
  635. next_shoot_time = curtime + 0.2f - g_csgo.m_globals()->m_interval_per_tick; // -1 because we already cocked THIS tick ???
  636.  
  637. if (next_shoot_time - curtime - g_csgo.m_globals()->m_interval_per_tick <= 0.f) {
  638. next_shoot_time = curtime + 0.2f;
  639. ret = true;
  640.  
  641. // should still go for one more tick but if we do, we're gonna shoot sooo idk how2do rn, its late
  642. // the aimbot should decide whether to shoot or not yeh
  643. }
  644.  
  645. return ret;
  646. }
  647.  
  648. //void AimRage::AutoCrouch()
  649. //{
  650. // if (!g_ctx.rage_autocrouch)
  651. // return;
  652. //
  653. // m_pcmd->m_buttons |= IN_DUCK;
  654. //}
  655.  
  656. float AimRage::GetDamageVec(const Vector &vecPoint, player_t *player, int hitbox, csweaponinfo_t *weapt)
  657. {
  658. float damage = 0.f;
  659.  
  660. Vector rem = vecPoint;
  661.  
  662. FireBulletData data;
  663.  
  664. data.src = g_ctx.m_local->get_eye_pos();
  665. data.filter.pSkip = g_ctx.m_local;
  666.  
  667. QAngle angle = math::CalcAngle(data.src, rem);
  668. math::angle_vectors(angle, data.direction);
  669.  
  670. data.direction.Normalized();
  671.  
  672. auto weap = g_ctx.m_local->m_hActiveWeapon().Get();
  673. if (SimulateFireBullet(weap, data, player, hitbox, weapt))
  674. damage = data.current_damage;
  675.  
  676. return damage;
  677. }
  678.  
  679. bool AimRage::SimulateFireBullet(weapon_t *weap, FireBulletData &data, player_t *player, int hitbox, csweaponinfo_t *weapt)
  680. {
  681. if (!weap)
  682. return false;
  683.  
  684. auto GetHitgroup = [](int hitbox) -> int
  685. {
  686. switch (hitbox)
  687. {
  688. case HITBOX_HEAD:
  689. case HITBOX_NECK:
  690. return HITGROUP_HEAD;
  691. case HITBOX_LOWER_CHEST:
  692. case HITBOX_CHEST:
  693. case HITBOX_UPPER_CHEST:
  694. return HITGROUP_CHEST;
  695. case HITBOX_STOMACH:
  696. case HITBOX_PELVIS:
  697. return HITGROUP_STOMACH;
  698. case HITBOX_LEFT_HAND:
  699. case HITBOX_LEFT_UPPER_ARM:
  700. case HITBOX_LEFT_FOREARM:
  701. return HITGROUP_LEFTARM;
  702. case HITBOX_RIGHT_HAND:
  703. case HITBOX_RIGHT_UPPER_ARM:
  704. case HITBOX_RIGHT_FOREARM:
  705. return HITGROUP_RIGHTARM;
  706. case HITBOX_LEFT_THIGH:
  707. case HITBOX_LEFT_CALF:
  708. case HITBOX_LEFT_FOOT:
  709. return HITGROUP_LEFTLEG;
  710. case HITBOX_RIGHT_THIGH:
  711. case HITBOX_RIGHT_CALF:
  712. case HITBOX_RIGHT_FOOT:
  713. return HITGROUP_RIGHTLEG;
  714. default:
  715. return -1;
  716. }
  717. };
  718.  
  719. data.penetrate_count = 4;
  720. data.trace_length = 0.0f;
  721.  
  722.  
  723. //weap = g_ctx.m_local->m_hActiveWeapon();
  724. //csweaponinfo_t* weaponData = g_ctx.m_local->m_hActiveWeapon()->get_csweapon_info();
  725. //weapt = g_ctx.m_local->m_hActiveWeapon()->get_csweapon_info();
  726. csweaponinfo_t *weaponData = g_ctx.m_local->m_hActiveWeapon().Get()->GetWeapInfo();
  727.  
  728. if (weaponData == NULL)
  729. return false;
  730.  
  731. data.current_damage = (float)weaponData->m_iDamage();
  732. while ((data.penetrate_count > 0) && (data.current_damage >= 1.0f))
  733. {
  734. data.trace_length_remaining = weaponData->range - data.trace_length;
  735.  
  736. Vector end = data.src + data.direction * data.trace_length_remaining;
  737.  
  738. traceIt(data.src, end, MASK_SHOT | CONTENTS_GRATE, g_ctx.m_local, &data.enter_trace);
  739. ClipTraceToPlayers(data.src, end + data.direction * 40.f, MASK_SHOT | CONTENTS_GRATE, &data.filter, &data.enter_trace);
  740.  
  741. if (data.enter_trace.fraction == 1.0f)
  742. {
  743. if (player && !(player->m_fFlags() & FL_ONGROUND))
  744. {
  745. data.enter_trace.hitgroup = GetHitgroup(hitbox);
  746. data.enter_trace.hit_entity = player;
  747. }
  748. else
  749. break;
  750. }
  751.  
  752. surfacedata_t * enter_surface_data = g_csgo.m_physsurface()->GetSurfaceData(data.enter_trace.surface.surfaceProps);
  753. unsigned short enter_material = enter_surface_data->game.material;
  754. float enter_surf_penetration_mod = enter_surface_data->game.flPenetrationModifier;
  755.  
  756. data.trace_length += data.enter_trace.fraction * data.trace_length_remaining;
  757. data.current_damage *= pow(weaponData->range, data.trace_length * 0.002);
  758.  
  759. if (data.trace_length > 3000.f && weaponData->penetration > 0.f || enter_surf_penetration_mod < 0.1f)
  760. break;
  761.  
  762. if ((data.enter_trace.hitgroup <= 7) && (data.enter_trace.hitgroup > 0))
  763. {
  764. player_t *pPlayer = reinterpret_cast<player_t*>(data.enter_trace.hit_entity);
  765. if (pPlayer->is_player() && pPlayer->m_iTeamNum() == g_ctx.m_local->m_iTeamNum())
  766. return false;
  767.  
  768. ScaleDamage(data.enter_trace.hitgroup, pPlayer, weaponData->armor_ratio, data.current_damage);
  769.  
  770. return true;
  771. }
  772.  
  773. if (!HandleBulletPenetration(weaponData, data))
  774. break;
  775. }
  776.  
  777. return false;
  778. }
  779.  
  780. bool AimRage::HandleBulletPenetration(csweaponinfo_t *wpn_data, FireBulletData &data)
  781. {
  782. bool bSolidSurf = ((data.enter_trace.contents >> 3) & CONTENTS_SOLID);
  783. bool bLightSurf = (data.enter_trace.surface.flags >> 7) & SURF_LIGHT;
  784.  
  785. surfacedata_t * enter_surface_data = g_csgo.m_physsurface()->GetSurfaceData(data.enter_trace.surface.surfaceProps);
  786. unsigned short enter_material = enter_surface_data->game.material;
  787. float enter_surf_penetration_mod = enter_surface_data->game.flPenetrationModifier;
  788.  
  789. if (!data.penetrate_count && !bLightSurf && !bSolidSurf && enter_material != 89)
  790. {
  791. if (enter_material != 71)
  792. return false;
  793. }
  794.  
  795. if (data.penetrate_count <= 0 || wpn_data->penetration <= 0.f)
  796. return false;
  797.  
  798. Vector dummy;
  799. trace_t trace_exit;
  800.  
  801. if (!TraceToExit(dummy, &data.enter_trace, data.enter_trace.endpos, data.direction, &trace_exit))
  802. {
  803. if (!(g_csgo.m_trace()->GetPointContents(dummy, MASK_SHOT_HULL) & MASK_SHOT_HULL))
  804. return false;
  805. }
  806.  
  807. surfacedata_t * exit_surface_data = g_csgo.m_physsurface()->GetSurfaceData(trace_exit.surface.surfaceProps);
  808. unsigned short exit_material = exit_surface_data->game.material;
  809.  
  810. float exit_surf_penetration_mod = exit_surface_data->game.flPenetrationModifier;
  811. float exit_surf_damage_mod = exit_surface_data->game.flDamageModifier;
  812.  
  813. float final_damage_modifier = 0.16f;
  814. float combined_penetration_modifier = 0.0f;
  815.  
  816. if (enter_material == 89 || enter_material == 71)
  817. {
  818. combined_penetration_modifier = 3.0f;
  819. final_damage_modifier = 0.05f;
  820. }
  821. else if (bSolidSurf || bLightSurf)
  822. {
  823. combined_penetration_modifier = 1.0f;
  824. final_damage_modifier = 0.16f;
  825. }
  826. else
  827. {
  828. combined_penetration_modifier = (enter_surf_penetration_mod + exit_surf_penetration_mod) * 0.5f;
  829. }
  830.  
  831. if (enter_material == exit_material)
  832. {
  833. if (exit_material == 87 || exit_material == 85)
  834. combined_penetration_modifier = 3.0f;
  835. else if (exit_material == 76)
  836. combined_penetration_modifier = 2.0f;
  837. }
  838.  
  839. float modifier = fmaxf(0.0f, 1.0f / combined_penetration_modifier);
  840. float thickness = (trace_exit.endpos - data.enter_trace.endpos).LengthSqr();
  841. float taken_damage = ((modifier * 3.0f) * fmaxf(0.0f, (3.0f / wpn_data->penetration) * 1.25f) + (data.current_damage * final_damage_modifier)) + ((thickness * modifier) / 24.0f);
  842.  
  843. float lost_damage = fmaxf(0.0f, taken_damage);
  844.  
  845. if (lost_damage > data.current_damage)
  846. return false;
  847.  
  848. if (lost_damage > 0.0f)
  849. data.current_damage -= lost_damage;
  850.  
  851. if (data.current_damage < 1.0f)
  852. return false;
  853.  
  854. data.src = trace_exit.endpos;
  855. data.penetrate_count--;
  856.  
  857. return true;
  858. }
  859. bool CGameTrace::DidHitWorld() const
  860. {
  861. return hit_entity == g_csgo.m_entitylist()->GetClientEntity(0);
  862. }
  863. bool CGameTrace::DidHitNonWorldEntity() const
  864. {
  865. return hit_entity != nullptr && !DidHitWorld();
  866. }
  867. bool AimRage::TraceToExit(Vector &end, CGameTrace *enter_trace, Vector start, Vector dir, CGameTrace *exit_trace)
  868. {
  869. auto distance = 0.0f;
  870. int first_contents = 0;
  871.  
  872. while (distance < 90.0f)
  873. {
  874. distance += 4.0f;
  875. end = start + (dir * distance);
  876.  
  877. if (!first_contents)
  878. first_contents = g_csgo.m_trace()->GetPointContents(end, MASK_SHOT_HULL | CONTENTS_HITBOX);
  879.  
  880. auto point_contents = g_csgo.m_trace()->GetPointContents(end, MASK_SHOT_HULL | CONTENTS_HITBOX);
  881.  
  882. if (point_contents & MASK_SHOT_HULL && (!(point_contents & CONTENTS_HITBOX) || first_contents == point_contents))
  883. continue;
  884.  
  885. auto new_end = end - (dir * 4.0f);
  886.  
  887. traceIt(end, new_end, MASK_SHOT | CONTENTS_GRATE, nullptr, exit_trace);
  888.  
  889. if (exit_trace->startsolid && (exit_trace->surface.flags & SURF_HITBOX) < 0)
  890. {
  891. traceIt(end, start, MASK_SHOT_HULL, reinterpret_cast<player_t*>(exit_trace->hit_entity), exit_trace);
  892.  
  893. if (exit_trace->DidHit() && !exit_trace->startsolid)
  894. {
  895. end = exit_trace->endpos;
  896. return true;
  897. }
  898. continue;
  899. }
  900.  
  901. if (!exit_trace->DidHit() || exit_trace->startsolid)
  902. {
  903. if (enter_trace->hit_entity)
  904. {
  905. if (enter_trace->DidHitNonWorldEntity() && IsBreakableEntity(reinterpret_cast<player_t*>(enter_trace->hit_entity)))
  906. {
  907. *exit_trace = *enter_trace;
  908. exit_trace->endpos = start + dir;
  909. return true;
  910. }
  911. }
  912. continue;
  913. }
  914.  
  915. if ((exit_trace->surface.flags >> 7) & SURF_LIGHT)
  916. {
  917. if (IsBreakableEntity(reinterpret_cast<player_t*>(exit_trace->hit_entity)) && IsBreakableEntity(reinterpret_cast<player_t*>(enter_trace->hit_entity)))
  918. {
  919. end = exit_trace->endpos;
  920. return true;
  921. }
  922.  
  923. if (!((enter_trace->surface.flags >> 7) & SURF_LIGHT))
  924. continue;
  925. }
  926.  
  927. if (exit_trace->plane.normal.Dot(dir) <= 1.0f)
  928. {
  929. float fraction = exit_trace->fraction * 4.0f;
  930. end = end - (dir * fraction);
  931.  
  932. return true;
  933. }
  934. }
  935. return false;
  936. }
  937.  
  938. bool AimRage::IsBreakableEntity(player_t *ent)
  939. {
  940. typedef bool(__thiscall *isBreakbaleEntityFn)(player_t*);
  941. //static auto fn = reinterpret_cast<Fn>(util::pattern_scan("client_panorama.dll", "55 8B EC 51 56 8B F1 85 F6 74 68 83 BE"));
  942. static isBreakbaleEntityFn IsBreakableEntityFn = (isBreakbaleEntityFn)util::pattern_scan(("client_panorama.dll"), "55 8B EC 51 56 8B F1 85 F6 74 68");
  943.  
  944. if (IsBreakableEntityFn)
  945. {
  946. // 0x280 = m_takedamage
  947.  
  948. auto backupval = *reinterpret_cast<int*>((uint32_t)ent + 0x280);
  949. auto className = ent->GetClientClass()->m_pNetworkName;
  950.  
  951. if (ent != g_csgo.m_entitylist()->GetClientEntity(0))
  952. {
  953. // CFuncBrush:
  954. // (className[1] != 'F' || className[4] != 'c' || className[5] != 'B' || className[9] != 'h')
  955. if ((className[1] == 'B' && className[9] == 'e' && className[10] == 'S' && className[16] == 'e') // CBreakableSurface
  956. || (className[1] != 'B' || className[5] != 'D')) // CBaseDoor because fuck doors
  957. {
  958. *reinterpret_cast<int*>((uint32_t)ent + 0x280) = 2;
  959. }
  960. }
  961.  
  962. bool retn = IsBreakableEntityFn(ent);
  963.  
  964. *reinterpret_cast<int*>((uint32_t)ent + 0x280) = backupval;
  965.  
  966. return retn;
  967. }
  968. else
  969. return false;
  970. }
  971.  
  972. void AimRage::ClipTraceToPlayers(const Vector &vecAbsStart, const Vector &vecAbsEnd, unsigned int mask, ITraceFilter *filter, CGameTrace *tr)
  973. {
  974. trace_t playerTrace;
  975. Ray_t ray;
  976. float smallestFraction = tr->fraction;
  977. const float maxRange = 60.0f;
  978.  
  979. ray.Init(vecAbsStart, vecAbsEnd);
  980.  
  981. for (int i = 1; i <= g_csgo.m_engine()->GetMaxClients(); i++)
  982. {
  983. player_t *player = player_t::GetPlayerByIndex(i);
  984.  
  985. if (!player || !player->is_alive() || player->IsDormant())
  986. continue;
  987.  
  988. if (filter && filter->ShouldHitEntity(player, mask) == false)
  989. continue;
  990.  
  991. float range = math::DistanceToRay(player->WorldSpaceCenter(), vecAbsStart, vecAbsEnd);
  992. if (range < 0.0f || range > maxRange)
  993. continue;
  994.  
  995. g_csgo.m_trace()->ClipRayToEntity(ray, mask | CONTENTS_HITBOX, player, &playerTrace);
  996. if (playerTrace.fraction < smallestFraction)
  997. {
  998. *tr = playerTrace;
  999. smallestFraction = playerTrace.fraction;
  1000. }
  1001. }
  1002. }
  1003.  
  1004. void AimRage::ScaleDamage(int hitgroup, player_t *player, float weapon_armor_ratio, float &current_damage)
  1005. {
  1006. bool heavArmor = player->m_bHasHeavyArmor();
  1007. int armor = player->m_ArmorValue();
  1008.  
  1009. switch (hitgroup)
  1010. {
  1011. case HITGROUP_HEAD:
  1012.  
  1013. if (heavArmor)
  1014. current_damage *= (current_damage * 4.f) * 0.5f;
  1015. else
  1016. current_damage *= 4.f;
  1017.  
  1018. break;
  1019.  
  1020. case HITGROUP_CHEST:
  1021. case HITGROUP_LEFTARM:
  1022. case HITGROUP_RIGHTARM:
  1023.  
  1024. current_damage *= 1.f;
  1025. break;
  1026.  
  1027. case HITGROUP_STOMACH:
  1028.  
  1029. current_damage *= 1.25f;
  1030. break;
  1031.  
  1032. case HITGROUP_LEFTLEG:
  1033. case HITGROUP_RIGHTLEG:
  1034.  
  1035. current_damage *= 0.75f;
  1036. break;
  1037. }
  1038.  
  1039. if (IsArmored(player, armor, hitgroup))
  1040. {
  1041. float v47 = 1.f, armor_bonus_ratio = 0.5f, armor_ratio = weapon_armor_ratio * 0.5f;
  1042.  
  1043. if (heavArmor)
  1044. {
  1045. armor_bonus_ratio = 0.33f;
  1046. armor_ratio = (weapon_armor_ratio * 0.5f) * 0.5f;
  1047. v47 = 0.33f;
  1048. }
  1049.  
  1050. float new_damage = current_damage * armor_ratio;
  1051.  
  1052. if (heavArmor)
  1053. new_damage *= 0.85f;
  1054.  
  1055. if (((current_damage - (current_damage * armor_ratio)) * (v47 * armor_bonus_ratio)) > armor)
  1056. new_damage = current_damage - (armor / armor_bonus_ratio);
  1057.  
  1058. current_damage = new_damage;
  1059. }
  1060. }
  1061.  
  1062. bool AimRage::IsArmored(player_t *player, int armorVal, int hitgroup)
  1063. {
  1064. bool res = false;
  1065.  
  1066. if (armorVal > 0)
  1067. {
  1068. switch (hitgroup)
  1069. {
  1070. case HITGROUP_GENERIC:
  1071. case HITGROUP_CHEST:
  1072. case HITGROUP_STOMACH:
  1073. case HITGROUP_LEFTARM:
  1074. case HITGROUP_RIGHTARM:
  1075.  
  1076. res = true;
  1077. break;
  1078.  
  1079. case HITGROUP_HEAD:
  1080.  
  1081. res = player->m_bHasHelmet();
  1082. break;
  1083.  
  1084. }
  1085. }
  1086.  
  1087. return res;
  1088. }
  1089.  
  1090. void AimRage::traceIt(Vector &vecAbsStart, Vector &vecAbsEnd, unsigned int mask, player_t *ign, CGameTrace *tr)
  1091. {
  1092. Ray_t ray;
  1093.  
  1094. CTraceFilter filter;
  1095. filter.pSkip = ign;
  1096.  
  1097. ray.Init(vecAbsStart, vecAbsEnd);
  1098.  
  1099. g_csgo.m_trace()->TraceRay(ray, mask, &filter, tr);
  1100. }
  1101.  
  1102. int AimRage::GetTickbase(CUserCmd* ucmd) {
  1103.  
  1104. static int g_tick = 0;
  1105. static CUserCmd* g_pLastCmd = nullptr;
  1106.  
  1107. if (!ucmd)
  1108. return g_tick;
  1109.  
  1110. if (!g_pLastCmd || g_pLastCmd->m_predicted) {
  1111. g_tick = g_ctx.m_local->m_nTickBase();
  1112. }
  1113. else {
  1114. // Required because prediction only runs on frames, not ticks
  1115. // So if your framerate goes below tickrate, m_nTickBase won't update every tick
  1116. ++g_tick;
  1117. }
  1118.  
  1119. g_pLastCmd = ucmd;
  1120. return g_tick;
  1121. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!