API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 22nd, 2020
128
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.78 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/CBaseWeapon.h"
  9. #include "../SDK/CGlobalVars.h"
  10. #include "../SDK/ConVar.h"
  11. #include "../FEATURES/AutoWall.h"
  12. #include "../FEATURES/Backtracking.h"
  13. #include "../FEATURES/bt.h"
  14. #include "../FEATURES/Aimbot.h"
  15. #include "../FEATURES/Movement.h"
  16. #include "../FEATURES/override.h"
  17.  
  18.  
  19. void CResolver::HandleBackUpResolve(SDK::CBaseEntity* player) {
  20.  
  21. auto local_player = INTERFACES::ClientEntityList->GetClientEntity(INTERFACES::Engine->GetLocalPlayer());
  22. auto animation_state = player->GetAnimState();
  23. auto animState = uintptr_t(local_player->GetAnimState());
  24.  
  25. if (!animState)
  26. return;
  27.  
  28. // Rebuild setup velocity to receive flMinBodyYaw and flMaxBodyYaw
  29. Vector velocity = player->GetVelocity();
  30. float spd = velocity.Length2D();
  31. if (spd > std::powf(1.2f * 260.0f, 2.f)) {
  32. Vector velocity_normalized = velocity.Normalize();
  33. velocity = velocity_normalized * (1.2f * 260.0f);
  34. }
  35.  
  36. float flDuckAmount = animation_state->m_fDuckAmount;
  37.  
  38. float m_flLastClientSideAnimationUpdateTimeDelta = fabs(animation_state->m_iLastClientSideAnimationUpdateFramecount - animation_state->m_flLastClientSideAnimationUpdateTime);
  39.  
  40. auto v48 = 0.f;
  41.  
  42. if (animation_state->m_flFeetSpeedForwardsOrSideWays >= 0.0f)
  43. {
  44. v48 = fminf(animation_state->m_flFeetSpeedForwardsOrSideWays, 1.0f);
  45. }
  46. else
  47. {
  48. v48 = 0.0f;
  49. }
  50.  
  51. float v49 = ((animation_state->m_flStopToFullRunningFraction * -0.30000001) - 0.19999999) * v48;
  52.  
  53. float flYawModifier = v49 + 1.0;
  54.  
  55. //float flYawModifier = (((animState->m_flUnknownFraction * -0.3f) - 0.2f) * flRunningSpeed) + 1.0f;
  56.  
  57. if (flDuckAmount > 0.0f) {
  58. float flDuckingSpeed = clamp(flDuckingSpeed, 0.0f, 1.0f);
  59. flYawModifier += (flDuckAmount * flDuckingSpeed) * (0.5f - flYawModifier);
  60. }
  61.  
  62. float flMinBodyYaw = std::fabsf(animation_state->pad10[516] * flYawModifier);
  63. float flMaxBodyYaw = std::fabsf(animation_state->pad10[512] * flYawModifier);
  64.  
  65. float flEyeYaw = animation_state->m_flEyeYaw;
  66. auto lbyYaw = animation_state->m_flGoalFeetYaw;
  67. float eye_feet_delta = fabs(flEyeYaw - lbyYaw);
  68.  
  69. float resolveYaw;
  70.  
  71. for (size_t i = 0; i < player->GetNumAnimOverlays(); i++)
  72. {
  73. auto currentLayer = player->GetAnimOverlay4(i);
  74.  
  75. auto previousLayer = player->GetAnimOverlay4(i - 1);
  76. if (player->GetSequenceActivity(currentLayer->m_nSequence) == 979) // the current layer must be triggering 979
  77. {
  78. if (player->GetSequenceActivity(previousLayer->m_nSequence) == 979) // the previous layer must be trigerring 979
  79. {
  80. //we can tell now that he is surely breaking lby in some sort
  81.  
  82. if ((previousLayer->m_flCycle != currentLayer->m_flCycle) || currentLayer->m_flWeight == 1.f)
  83. {
  84. animation_state->m_flGoalFeetYaw = player->GetLowerBodyYaw() - 180;
  85. }
  86. else if (currentLayer->m_flWeight == 0.f && (previousLayer->m_flCycle > 0.92f && currentLayer->m_flCycle > 0.92f)) // breaking lby with delta < 120; can fakewalk here aswell
  87. {
  88. float Left = fabs(flMinBodyYaw) + flEyeYaw;
  89. float Right = flEyeYaw - fabs(flMaxBodyYaw);
  90.  
  91. if (eye_feet_delta <= flMaxBodyYaw)
  92. {
  93. resolveYaw = Left;
  94. switch (shots_missed[player->GetIndex()] % 2)
  95. {
  96. case 0:
  97. resolveYaw = resolveYaw + 15.0;
  98. break;
  99. case 1:
  100. resolveYaw = resolveYaw + 30.0;
  101. break;
  102. case 2:
  103. resolveYaw = resolveYaw + 45.0;
  104. break;
  105. case 3:
  106. resolveYaw = resolveYaw + 58.0;
  107. break;
  108. case 4:
  109. resolveYaw = resolveYaw + 79.0;
  110. break;
  111. case 5:
  112. resolveYaw = resolveYaw + 90.0;
  113. break;
  114. case 6:
  115. resolveYaw = resolveYaw + 180.0;
  116. break;
  117. }
  118.  
  119. }
  120. else
  121. {
  122.  
  123. resolveYaw = Right;
  124.  
  125. switch (shots_missed[player->GetIndex()] % 2)
  126. {
  127. case 0:
  128. resolveYaw = resolveYaw - 15.0;
  129. break;
  130. case 1:
  131. resolveYaw = resolveYaw - 30.0;
  132. break;
  133. case 2:
  134. resolveYaw = resolveYaw - 45.0;
  135. break;
  136. case 3:
  137. resolveYaw = resolveYaw - 58.0;
  138. break;
  139. case 4:
  140. resolveYaw = resolveYaw - 79.0;
  141. break;
  142. case 5:
  143. resolveYaw = resolveYaw - 90.0;
  144. break;
  145. case 6:
  146. resolveYaw = resolveYaw - 180.0;
  147. break;
  148. }
  149. }
  150.  
  151. animation_state->m_flGoalFeetYaw = resolveYaw;
  152.  
  153. }
  154.  
  155. }
  156.  
  157.  
  158. resolveYaw = player->GetLowerBodyYaw();
  159.  
  160. if (shots_missed[player->GetIndex()] >= 1) {
  161.  
  162. auto eyeYaw = animation_state->m_flEyeYaw;
  163. auto lbyYaw = animation_state->m_flGoalFeetYaw;
  164. float eye_feet_delta = fabs(eyeYaw - lbyYaw);
  165.  
  166. if (eye_feet_delta <= flMaxBodyYaw)
  167. {
  168. if (flMinBodyYaw < eye_feet_delta)
  169. {
  170. resolveYaw = fabs(flMinBodyYaw) + eyeYaw;
  171. }
  172. }
  173. else
  174. {
  175. resolveYaw = eyeYaw - fabs(flMaxBodyYaw);
  176. }
  177. // was
  178. float resolveYaw = fmod(resolveYaw, 180.0);
  179.  
  180. if (resolveYaw > 180.0)
  181. {
  182. resolveYaw = resolveYaw - 360.0;
  183. }
  184.  
  185. if (resolveYaw < 180.0)
  186. {
  187. resolveYaw = resolveYaw + 360.0;
  188. }
  189.  
  190. if (shots_missed[player->GetIndex()] > 4) {
  191.  
  192. if (eye_feet_delta <= flMaxBodyYaw)
  193. {
  194. if (flMinBodyYaw < eye_feet_delta)
  195. {
  196.  
  197. switch (shots_missed[player->GetIndex()] % 2)
  198. {
  199. case 0:
  200. resolveYaw = resolveYaw + 15.0;
  201. break;
  202. case 1:
  203. resolveYaw = resolveYaw + 30.0;
  204. break;
  205. case 2:
  206. resolveYaw = resolveYaw + 45.0;
  207. break;
  208. case 3:
  209. resolveYaw = resolveYaw + 58.0;
  210. break;
  211. case 4:
  212. resolveYaw = resolveYaw + 79.0;
  213. break;
  214. case 5:
  215. resolveYaw = resolveYaw + 90.0;
  216. break;
  217. case 6:
  218. resolveYaw = resolveYaw + 180.0;
  219. break;
  220.  
  221. }
  222. }
  223. }
  224. else
  225. {
  226. switch (shots_missed[player->GetIndex()] % 2)
  227. {
  228. case 0:
  229. resolveYaw = resolveYaw - 15.0;
  230. break;
  231. case 1:
  232. resolveYaw = resolveYaw - 30.0;
  233. break;
  234. case 2:
  235. resolveYaw = resolveYaw - 45.0;
  236. break;
  237. case 3:
  238. resolveYaw = resolveYaw - 58.0;
  239. break;
  240. case 4:
  241. resolveYaw = resolveYaw - 79.0;
  242. break;
  243. case 5:
  244. resolveYaw = resolveYaw - 90.0;
  245. break;
  246. case 6:
  247. resolveYaw = resolveYaw - 180.0;
  248. break;
  249. }
  250. }
  251. }
  252. }
  253.  
  254. animation_state->m_flGoalFeetYaw = resolveYaw;
  255.  
  256.  
  257.  
  258.  
  259. float Left = fabs(flMinBodyYaw) + flEyeYaw;
  260. float Right = flEyeYaw - fabs(flMaxBodyYaw);
  261.  
  262. if (eye_feet_delta <= flMaxBodyYaw)
  263. {
  264. if (flMinBodyYaw < eye_feet_delta)
  265. {
  266. resolveYaw = Left;
  267.  
  268. switch (shots_missed[player->GetIndex()] % 2)
  269. {
  270. case 0:
  271. resolveYaw = resolveYaw + 15.0;
  272. break;
  273. case 1:
  274. resolveYaw = resolveYaw + 30.0;
  275. break;
  276. case 2:
  277. resolveYaw = resolveYaw + 45.0;
  278. break;
  279. case 3:
  280. resolveYaw = resolveYaw + 58.0;
  281. break;
  282. case 4:
  283. resolveYaw = resolveYaw + 79.0;
  284. break;
  285. case 5:
  286. resolveYaw = resolveYaw + 90.0;
  287. break;
  288. case 6:
  289. resolveYaw = resolveYaw + 180.0;
  290. break;
  291. }
  292. }
  293. }
  294. else
  295. {
  296.  
  297. resolveYaw = Right;
  298.  
  299. switch (shots_missed[player->GetIndex()] % 2)
  300. {
  301. case 0:
  302. resolveYaw = resolveYaw - 15.0;
  303. break;
  304. case 1:
  305. resolveYaw = resolveYaw - 30.0;
  306. break;
  307. case 2:
  308. resolveYaw = resolveYaw - 45.0;
  309. break;
  310. case 3:
  311. resolveYaw = resolveYaw - 58.0;
  312. break;
  313. case 4:
  314. resolveYaw = resolveYaw - 79.0;
  315. break;
  316. case 5:
  317. resolveYaw = resolveYaw - 90.0;
  318. break;
  319. case 6:
  320. resolveYaw = resolveYaw - 180.0;
  321. break;
  322. }
  323. }
  324.  
  325. animation_state->m_flGoalFeetYaw = resolveYaw;
  326.  
  327. }
  328. }
  329.  
  330. for (size_t a2a = 0; a2a < player->GetNumAnimOverlays(); ++a2a)
  331. {
  332. auto v32 = player->GetAnimOverlay4(a2a);
  333. if (v32 && player->GetSequenceActivity(v32->m_nSequence) == 979) {
  334. animation_state->m_flGoalFeetYaw = player->GetLowerBodyYaw();
  335. return;
  336. }
  337. }
  338.  
  339. float v20 = animation_state->m_vVelocityX * flYawModifier;
  340. float a1 = animation_state->m_vVelocityY * flYawModifier;
  341. float v30 = 0.0;
  342. float eye_angles_y = animation_state->m_flEyeYaw;
  343. float goal_feet_yaw = animation_state->m_flGoalFeetYaw;
  344. float v22 = fabs(eye_angles_y - goal_feet_yaw);
  345. if (v20 < v22)
  346. {
  347. float v11 = fabs((v20));
  348. v30 = eye_angles_y - v11;
  349. }
  350. else if (a1 > v22)
  351. {
  352. float v12 = fabs((a1));
  353. v30 = v12 + eye_angles_y;
  354. }
  355.  
  356. float v36 = std::fmodf((v30), 180.0);
  357. if (v36 > 180.0)
  358. v36 = v36 - 360.0;
  359. if (v36 < 180.0)
  360. v36 = v36 + 360.0;
  361.  
  362.  
  363. resolveYaw = v36;
  364.  
  365. float flEyeDiff = std::remainderf(flEyeYaw - animation_state->m_flGoalFeetYaw, 180.f);
  366.  
  367. if (flEyeDiff <= flMaxBodyYaw) {
  368. if (flMinBodyYaw > flEyeDiff)
  369. animation_state->m_flGoalFeetYaw = fabs(flMinBodyYaw) + flEyeYaw;
  370. }
  371. else {
  372. animation_state->m_flGoalFeetYaw = flEyeYaw - fabs(flMaxBodyYaw);
  373. }
  374.  
  375. animation_state->m_flGoalFeetYaw = std::remainderf(animation_state->m_flGoalFeetYaw, 180.f);
  376.  
  377. if (animation_state->speed_2d > 0.1f || fabs(velocity.z) > 100.0f) {
  378. animation_state->m_flGoalFeetYaw = (
  379. flEyeYaw,
  380. animation_state->m_flGoalFeetYaw,
  381. ((animation_state->m_flUnknownFraction * 20.0f) + 30.0f)
  382. *animation_state->m_flLastClientSideAnimationUpdateTime);
  383. }
  384. else {
  385. animation_state->m_flGoalFeetYaw = (
  386. player->GetLowerBodyYaw(),
  387. animation_state->m_flGoalFeetYaw,
  388. animation_state->m_flLastClientSideAnimationUpdateTime * 100.0f);
  389. }
  390.  
  391. }
  392. 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!