API tools faq
paste
Guest User

CAntiaim.cpp

a guest
Jun 28th, 2016
2,455
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 11.47 KB | None | 0 0
raw download clone embed print report
  1. #include "main.h"
  2. #define M_PI 3.14159265358979323846f
  3. #define DEG2RAD( x ) ( ( float )( x ) * ( float )( ( float )( PI ) / 180.0f ) )
  4.  
  5. CAntiaim g_Antiaim;
  6.  
  7. void CAntiaim::EdgeAntiAim1(CBaseEntity *pLocal, float &fYawOut)
  8. {
  9. Vector vEyePos = pLocal->GetEyePosition();
  10.  
  11. ValveSDK::CTrace::ITraceFilter* tracefilter = (ValveSDK::CTrace::ITraceFilter*)&tfNoPlayers;
  12.  
  13. for (int y = 0; y < 360; y++)
  14. {
  15. Vector qTmp(10.0f, fYawOut, 0.0f);
  16. qTmp.y += y;
  17.  
  18. if (qTmp.y > 180.0)
  19. qTmp.y -= 360.0;
  20. else if (qTmp.y < -180.0)
  21. qTmp.y += 360.0;
  22.  
  23. g_Aimbot.ClampAngles(qTmp);
  24.  
  25. Vector vForward;
  26.  
  27. g_Math.vectorAnglesVec(qTmp, vForward);
  28.  
  29. float fLength = (19.0f + (19.0f * sinf(DEG2RAD(10.0f)))) + 7.0f;
  30. vForward *= fLength;
  31.  
  32. ValveSDK::CTrace::trace_t trData;
  33.  
  34. Vector vTraceEnd = vEyePos + vForward;
  35.  
  36. ValveSDK::CTrace::Ray_t ray;
  37.  
  38. ray.Init(vEyePos, vTraceEnd);
  39. g_Valve.pKoloTrace->TraceRay(ray, 0x4600400B, tracefilter, &trData);
  40.  
  41.  
  42. if (trData.fraction != 1.0f)
  43. {
  44. Vector angles;
  45.  
  46. Vector vNegative = Vector(trData.plane.normal.x * -1.0f, trData.plane.normal.y * -1.0f, trData.plane.normal.z * -1.0f);
  47.  
  48. g_Math.vectorAnglesVec(vNegative, angles);
  49.  
  50. g_Aimbot.NormalizeVector(angles);
  51.  
  52. qTmp.y = angles.y;
  53.  
  54. g_Aimbot.ClampAngles(qTmp);
  55.  
  56. ValveSDK::CTrace::trace_t trLeft, trRight;
  57.  
  58. Vector vLeft, vRight;
  59. g_Math.vectorAnglesVec(qTmp + Vector(0.0f, 30.0f, 0.0f), vLeft);
  60. g_Math.vectorAnglesVec(qTmp + Vector(0.0f, 30.0f, 0.0f), vRight);
  61.  
  62. vLeft *= (fLength + (fLength * sinf(DEG2RAD(30.0f))));
  63. vRight *= (fLength + (fLength * sinf(DEG2RAD(30.0f))));
  64.  
  65. vTraceEnd = vEyePos + vLeft;
  66.  
  67. ray.Init(vEyePos, vTraceEnd);
  68. g_Valve.pKoloTrace->TraceRay(ray, 0x4600400B, tracefilter, &trLeft);
  69.  
  70. vTraceEnd = vEyePos + vRight;
  71.  
  72. ray.Init(vEyePos, vTraceEnd);
  73. g_Valve.pKoloTrace->TraceRay(ray, 0x4600400B, tracefilter, &trRight);
  74.  
  75. if ((trLeft.fraction == 1.0f) && (trRight.fraction != 1.0f))
  76. qTmp.y -= 90.f;
  77. else if ((trLeft.fraction != 1.0f) && (trRight.fraction == 1.0f))
  78. qTmp.y += 90.f;
  79.  
  80. if (qTmp.y > 180.0)
  81. qTmp.y -= 360.0;
  82. else if (qTmp.y < -180.0)
  83. qTmp.y += 360.0;
  84.  
  85. fYawOut = qTmp.y;
  86.  
  87. if (fYawOut > 180.0)
  88. fYawOut -= 360.0;
  89. else if (fYawOut < -180.0)
  90. fYawOut += 360.0;
  91.  
  92. //if (!bHeadOnWall)
  93. // bHeadOnWall = true;
  94.  
  95. return;
  96. }
  97. }
  98.  
  99. fYawOut -= 180.0f;
  100.  
  101. if (fYawOut > 180.0)
  102. fYawOut -= 360.0;
  103. else if (fYawOut < -180.0)
  104. fYawOut += 360.0;
  105.  
  106. //if (bHeadOnWall)
  107. // bHeadOnWall = false;
  108. }
  109.  
  110. bool CAntiaim::EdgeAntiAim(CBaseEntity* pLocalBaseEntity, ValveSDK::CInput::CUserCmd* cmd, float flWall, float flCornor)
  111. {
  112. ValveSDK::CTrace::Ray_t ray;
  113. ValveSDK::CTrace::trace_t tr;
  114. //ValveSDK::EngineTraceClient::CTraceFilter traceFilter(pLocalBaseEntity);
  115. //ValveSDK::CTrace::ITraceFilter *pTraceFilter = (ValveSDK::CTrace::ITraceFilter*)&tfNoPlayers;
  116. //traceFilter.pSkip = pLocalBaseEntity;
  117.  
  118. bool ret = false;
  119.  
  120. Vector localPosition = pLocalBaseEntity->GetEyePosition();
  121.  
  122. for (int y = 0; y < 360; y++)
  123. {
  124. Vector tmp(10.0f, cmd->viewangles.y, 0.0f);
  125. tmp.y += y;
  126.  
  127. g_Aimbot.NormalizeVector(tmp);
  128.  
  129. Vector forward;
  130. g_Math.VectorAngles3D(forward, tmp);
  131.  
  132. float length = ((16.0f + 3.0f) + ((16.0f + 3.0f) * sin(DEG2RAD(10.0f)))) + 7.0f;
  133. forward *= length;
  134.  
  135. ray.Init(localPosition, (localPosition + forward));
  136. g_Valve.pKoloTrace->TraceRay(ray, 0x4600400B, (ValveSDK::CTrace::ITraceFilter*)&tfNoPlayers, &tr);
  137.  
  138. if (tr.fraction != 1.0f)
  139. {
  140. Vector angles;
  141. Vector Negate = tr.plane.normal;
  142.  
  143. Negate *= -1;
  144. g_Math.VectorAngles3D(Negate, angles);
  145.  
  146. tmp.y = angles.y;
  147.  
  148. g_Aimbot.NormalizeVector(tmp);
  149. ValveSDK::CTrace::trace_t leftTrace, rightTrace;
  150.  
  151. Vector left, right;
  152. g_Math.VectorAngles3D(left, tmp + Vector(0.0f, 30.0f, 0.0f));
  153. g_Math.VectorAngles3D(right, tmp - Vector(0.0f, 30.0f, 0.0f));
  154.  
  155. left *= (length + (length * sin(DEG2RAD(30.0f))));
  156. right *= (length + (length * sin(DEG2RAD(30.0f))));
  157.  
  158. ray.Init(localPosition, (localPosition + left));
  159. g_Valve.pKoloTrace->TraceRay(ray, 0x4600400B, (ValveSDK::CTrace::ITraceFilter*)&tfNoPlayers, &leftTrace);
  160.  
  161. ray.Init(localPosition, (localPosition + right));
  162. g_Valve.pKoloTrace->TraceRay(ray, 0x4600400B, (ValveSDK::CTrace::ITraceFilter*)&tfNoPlayers, &rightTrace);
  163.  
  164. if ((leftTrace.fraction == 1.0f)
  165. && (rightTrace.fraction != 1.0f))
  166. {
  167. tmp.y -= flCornor; // left
  168. }
  169. else if ((leftTrace.fraction != 1.0f)
  170. && (rightTrace.fraction == 1.0f))
  171. {
  172. tmp.y += flCornor; // right
  173. }
  174.  
  175. cmd->viewangles.y = tmp.y;
  176. cmd->viewangles.y -= flWall;
  177. ret = true;
  178. }
  179. }
  180. return ret;
  181. }
  182.  
  183. void CAntiaim::FakeOrigin(CBaseEntity* pLocal, ValveSDK::CInput::CUserCmd* cmd, bool &SendPacket)
  184. {
  185. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  186. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  187. Vector vMove2;
  188. Vector vRealView(cmd->viewangles);
  189. g_Math.VectorAngles3D(vMove, vMove2);
  190.  
  191. static int iChoked = -1;
  192. iChoked++;
  193. if (iChoked < g_pConsole->getValue("antiaim_choke"))
  194. {
  195. SendPacket = false;
  196. cmd->viewangles.y -= 92;
  197. }
  198. else
  199. {
  200. SendPacket = true;
  201. iChoked = -1;
  202. }
  203.  
  204. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  205. cmd->forwardmove = cos(flYaw) * flSpeed;
  206. cmd->sidemove = sin(flYaw) * flSpeed;
  207. }
  208.  
  209. void CAntiaim::Fake1(CBaseEntity* pLocal, ValveSDK::CInput::CUserCmd* cmd, bool &SendPacket)
  210. {
  211. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  212. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  213. Vector vMove2;
  214. Vector vRealView(cmd->viewangles);
  215. g_Math.VectorAngles3D(vMove, vMove2);
  216.  
  217. static int jitterangle = 0;
  218.  
  219. if (jitterangle <= 2)
  220. {
  221. cmd->viewangles.x = 89;
  222. jitterangle += 1;
  223. }
  224. else if (jitterangle > 2 && jitterangle <= 4)
  225. {
  226. cmd->viewangles.x = 70;
  227. jitterangle += 1;
  228. }
  229. else
  230. {
  231. jitterangle = 0;
  232. }
  233. cmd->viewangles.y += 90;
  234.  
  235. static int iChoked = -1;
  236. iChoked++;
  237. if (iChoked < g_pConsole->getValue("antiaim_choke"))
  238. {
  239. SendPacket = false;
  240. cmd->viewangles.y -= 180;
  241. }
  242. else
  243. {
  244. SendPacket = true;
  245. iChoked = -1;
  246. }
  247.  
  248. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  249. cmd->forwardmove = cos(flYaw) * flSpeed;
  250. cmd->sidemove = sin(flYaw) * flSpeed;
  251. }
  252.  
  253. void CAntiaim::Fake2(CBaseEntity* pLocal, ValveSDK::CInput::CUserCmd* cmd, bool &SendPacket)
  254. {
  255. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  256. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  257. Vector vMove2;
  258. Vector vRealView(cmd->viewangles);
  259. g_Math.VectorAngles3D(vMove, vMove2);
  260.  
  261. cmd->viewangles.x = 88;
  262. cmd->viewangles.y += 180;
  263.  
  264. static int iChoked = -1;
  265. iChoked++;
  266. if (iChoked < g_pConsole->getValue("antiaim_choke"))
  267. {
  268. SendPacket = false;
  269. cmd->viewangles.y += 90;
  270. }
  271. else
  272. {
  273. SendPacket = true;
  274. iChoked = -1;
  275. }
  276.  
  277. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  278. cmd->forwardmove = cos(flYaw) * flSpeed;
  279. cmd->sidemove = sin(flYaw) * flSpeed;
  280. }
  281.  
  282. void CAntiaim::Fake3(CBaseEntity* pLocal, ValveSDK::CInput::CUserCmd* cmd, bool &SendPacket)
  283. {
  284. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  285. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  286. Vector vMove2;
  287. Vector vRealView(cmd->viewangles);
  288. g_Math.VectorAngles3D(vMove, vMove2);
  289.  
  290. cmd->viewangles.x = 88;
  291. cmd->viewangles.y += 180;
  292.  
  293. static int iChoked = -1;
  294. iChoked++;
  295. if (iChoked < g_pConsole->getValue("antiaim_choke"))
  296. {
  297. SendPacket = false;
  298. cmd->viewangles.y -= 180;
  299. }
  300. else
  301. {
  302. SendPacket = true;
  303. iChoked = -1;
  304. }
  305.  
  306. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  307. cmd->forwardmove = cos(flYaw) * flSpeed;
  308. cmd->sidemove = sin(flYaw) * flSpeed;
  309. }
  310.  
  311. void CAntiaim::FakeJitter1(CBaseEntity* pLocal, ValveSDK::CInput::CUserCmd* cmd, bool &SendPacket)
  312. {
  313. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  314. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  315. Vector vMove2;
  316. Vector vRealView(cmd->viewangles);
  317. g_Math.VectorAngles3D(vMove, vMove2);
  318.  
  319. static int jitterangle = 0;
  320.  
  321. if (jitterangle <= 1)
  322. {
  323. cmd->viewangles.x = 88;
  324. cmd->viewangles.y += 135;
  325. }
  326. else if (jitterangle > 1 && jitterangle <= 3)
  327. {
  328. cmd->viewangles.x = 88;
  329. cmd->viewangles.y += 225;
  330. }
  331.  
  332. static int iChoked = -1;
  333. iChoked++;
  334. if (iChoked < g_pConsole->getValue("antiaim_choke"))
  335. {
  336. SendPacket = false;
  337. if (jitterangle <= 1)
  338. {
  339. cmd->viewangles.y += 45;
  340. jitterangle += 1;
  341. }
  342. else if (jitterangle > 1 && jitterangle <= 3)
  343. {
  344. cmd->viewangles.y -= 45;
  345. jitterangle += 1;
  346. }
  347. else
  348. {
  349. jitterangle = 0;
  350. }
  351. }
  352. else
  353. {
  354. SendPacket = true;
  355. iChoked = -1;
  356. }
  357. g_Aimbot.NormalizeVector(cmd->viewangles);
  358.  
  359. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  360. cmd->forwardmove = cos(flYaw) * flSpeed;
  361. cmd->sidemove = sin(flYaw) * flSpeed;
  362. }
  363.  
  364. void CAntiaim::FakeJitter2(CBaseEntity* pLocal, ValveSDK::CInput::CUserCmd* cmd, bool &SendPacket)
  365. {
  366. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  367. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  368. Vector vMove2;
  369. Vector vRealView(cmd->viewangles);
  370. g_Math.VectorAngles3D(vMove, vMove2);
  371.  
  372. static int jitterangle = 0;
  373.  
  374. if (jitterangle <= 1)
  375. {
  376. cmd->viewangles.x = 88;
  377. cmd->viewangles.y += 90;
  378. }
  379. else if (jitterangle > 1 && jitterangle <= 3)
  380. {
  381. cmd->viewangles.x = 88;
  382. cmd->viewangles.y -= 90;
  383. }
  384.  
  385. static int iChoked = -1;
  386. iChoked++;
  387. if (iChoked < g_pConsole->getValue("antiaim_choke"))
  388. {
  389. SendPacket = false;
  390. if (jitterangle <= 1)
  391. {
  392. cmd->viewangles.y += 180;
  393. jitterangle += 1;
  394. }
  395. else if (jitterangle > 1 && jitterangle <= 3)
  396. {
  397. cmd->viewangles.y -= 180;
  398. jitterangle += 1;
  399. }
  400. else
  401. {
  402. jitterangle = 0;
  403. }
  404. }
  405. else
  406. {
  407. SendPacket = true;
  408. iChoked = -1;
  409. }
  410. g_Aimbot.NormalizeVector(cmd->viewangles);
  411.  
  412. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  413. cmd->forwardmove = cos(flYaw) * flSpeed;
  414. cmd->sidemove = sin(flYaw) * flSpeed;
  415. }
  416.  
  417. void CAntiaim::Jitter(CBaseEntity* pLocal, ValveSDK::CInput::CUserCmd* cmd)
  418. {
  419. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  420. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  421. Vector vMove2;
  422. Vector vRealView(cmd->viewangles);
  423. g_Math.VectorAngles3D(vMove, vMove2);
  424.  
  425. static int jitterangle = 0;
  426.  
  427. if (jitterangle <= 1)
  428. {
  429. cmd->viewangles.x = 89;
  430. cmd->viewangles.y += 91;
  431. jitterangle += 1;
  432. }
  433. else if (jitterangle > 1 && jitterangle <= 3)
  434. {
  435. cmd->viewangles.x = 87;
  436. cmd->viewangles.y -= 89;
  437. jitterangle += 1;
  438. }
  439. else
  440. {
  441. jitterangle = 0;
  442. }
  443.  
  444. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  445. cmd->forwardmove = cos(flYaw) * flSpeed;
  446. cmd->sidemove = sin(flYaw) * flSpeed;
  447. }
  448.  
  449. void CAntiaim::doAntiaim(CBaseEntity* pLocal, ValveSDK::CInput::CUserCmd* cmd, bool &SendPacket)
  450. {
  451. if (g_pConsole->getValue("antiaim_fake") == 1)
  452. FakeOrigin(pLocal, cmd, SendPacket);
  453. if (g_pConsole->getValue("antiaim_fake") == 2)
  454. Fake1(pLocal, cmd, SendPacket);
  455. if (g_pConsole->getValue("antiaim_fake") == 3)
  456. Fake2(pLocal, cmd, SendPacket);
  457. if (g_pConsole->getValue("antiaim_fake") == 4)
  458. Fake3(pLocal, cmd, SendPacket);
  459. if (g_pConsole->getValue("antiaim_fake") == 5)
  460. FakeJitter1(pLocal, cmd, SendPacket);
  461. if (g_pConsole->getValue("antiaim_fake") == 6)
  462. FakeJitter2(pLocal, cmd, SendPacket);
  463. if (g_pConsole->getValue("antiaim_fake") == 7)
  464. Jitter(pLocal, cmd);
  465. }
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!