API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 14th, 2016
134
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 80.48 KB | None | 0 0
raw download clone embed print report
  1. #include "main.h"
  2. #include "menu.h"
  3. #include "Security.h"
  4. #include "interfaces.h"
  5. #include "reportbot.h"
  6. #include "Autowall.h"
  7.  
  8. #define EPS 1.2e-7
  9. #define IR 2836
  10. #define IQ 127773
  11. #define IM 2147483647
  12. #define IA 16807
  13. #define MAX_RANDOM_RANGE 0x7FFFFFFFUL
  14. #define NDIV (1+(IM-1)/NTAB)
  15. #define NTAB 32
  16. #define IR 2836
  17.  
  18. #define AM (1.0/IM)
  19. #define RNMX (1.0-EPS)
  20. #define MakePtr( Type, dwBase, dwOffset ) ( ( Type )( DWORD( dwBase ) + (DWORD)( dwOffset ) ) )
  21.  
  22. bool cOnce = false, twice = false, vcheck1 = false, vcheck2 = false;
  23. char * crypt(const char *key, const char *salt);
  24.  
  25. // DEFINING SHIT ENDS HERE DU HURENSOHN !
  26. // -----------------------------------------------
  27. // AIMBOOTY BEGINNS HERE FAGGOT !
  28.  
  29. void AngleVectorsx(const Vector angles, Vector* forward) {
  30. float sp, sy, cp, cy;
  31. sp = sin(DEG2RAD(angles.x));
  32. sy = sin(DEG2RAD(angles.y));
  33. cp = cos(DEG2RAD(angles.x));
  34. cy = cos(DEG2RAD(angles.y));
  35. forward->x = cp*cy;
  36. forward->y = cp*sy;
  37. forward->z = -sp;
  38. }
  39.  
  40. float GetFOV(Vector CmdViewAngle, Vector LocalEyePos, Vector Destination) {
  41. Vector ang, aim;
  42. CalcAngle(LocalEyePos, Destination, ang);
  43. AngleVectorsx(CmdViewAngle, &aim);
  44. AngleVectorsx(ang, &ang);
  45.  
  46. float mag_s = std::sqrt((aim[0] * aim[0]) + (aim[1] * aim[1]) + (aim[2] * aim[2]));
  47. float mag_d = mag_s;
  48. float u_dot_v = aim[0] * ang[0] + aim[1] * ang[1] + aim[2] * ang[2];
  49. float fov = std::acos(u_dot_v / (mag_s * mag_d)) * (180.f / M_PI_F);
  50. return fov;
  51. }
  52.  
  53. void NormaliseViewAngle(Vector &angle)
  54. {
  55. while (angle.y <= -180) angle.y += 360;
  56. while (angle.y > 180) angle.y -= 360;
  57. while (angle.x <= -180) angle.x += 360;
  58. while (angle.x > 180) angle.x -= 360;
  59.  
  60.  
  61. if (angle.x > 89.0) angle.x = 89;
  62. if (angle.x < -89.0) angle.x = -89;
  63. if (angle.y < -180) angle.y = -179.999;
  64. if (angle.y > 180) angle.y = 179.999;
  65.  
  66. angle.z = 0;
  67. }
  68.  
  69. bool IsVisible(C_BaseEntity* pEntity, C_BaseEntity* pLocal)
  70. {
  71. trace_t tr;
  72. Ray_t ray;
  73. CTraceFilter filter;
  74. filter.pSkip = pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  75.  
  76. ray.Init(pLocal->GetEyePos(), pEntity->GetEyePos());
  77. pEngineTrace->TraceRay(ray, 0x4600400B, &filter, &tr);
  78. return (tr.m_pEnt == pEntity || tr.fraction > 0.99f);
  79. }
  80.  
  81. bool BoneTrace(C_BaseEntity* pLocalClientBaseEntity, Vector vecOrigin, Vector vecFinal, C_BaseEntity* pClientBaseEntity)
  82. {
  83. Ray_t ray;
  84. ray.Init(vecOrigin, vecFinal);
  85.  
  86. CTraceFilter TraceFilter;
  87.  
  88. trace_t trace;
  89. pEngineTrace->TraceRay(ray, CONTENTS_GRATE | CONTENTS_WINDOW | CONTENTS_SOLID | CONTENTS_MOVEABLE | CONTENTS_MONSTER | CONTENTS_DEBRIS | CONTENTS_HITBOX, &TraceFilter, &trace);
  90.  
  91. return(trace.m_pEnt == pClientBaseEntity || trace.fraction > 0.99f);
  92. }
  93.  
  94. bool BoneTraceWall(C_BaseEntity* pLocalClientBaseEntity, Vector vecOrigin, Vector vecFinal, C_BaseEntity* pClientBaseEntity)
  95. {
  96. Ray_t ray;
  97. ray.Init(vecOrigin, vecFinal);
  98.  
  99. CTraceFilter TraceFilter;
  100.  
  101. trace_t trace;
  102. pEngineTrace->TraceRay(ray, CONTENTS_SOLID, &TraceFilter, &trace);
  103.  
  104. return(trace.m_pEnt == pClientBaseEntity || trace.fraction > 0.99f);
  105. }
  106.  
  107. bool GetBonePosition(C_BaseEntity* pEntity, Vector &Hitbox, int Bone) {
  108. matrix3x4 MatrixArray[128];
  109. if (!pEntity->SetupBones(MatrixArray, 128, 0x100, 0)) {
  110. return false;
  111. }
  112. Hitbox = Vector(MatrixArray[Bone][0][3], MatrixArray[Bone][1][3], MatrixArray[Bone][2][3]);
  113. return true;
  114. }
  115.  
  116. Vector Hitscans(C_BaseEntity* pEntity, C_BaseEntity* pLocal, Vector& Hitbox) {
  117.  
  118. int hitboxarray[18] = { 6, 7, 8, 9, 10, 11, 1, 4, 2, 5, 3, 6, 12, 15, 13, 16, 14, 17 };
  119.  
  120. for (int i = 0; i < 18; i++) {
  121.  
  122.  
  123. GetBonePosition(pEntity, Hitbox, hitboxarray[i]);
  124. if (BoneTrace(pLocal, pLocal->GetEyePos(), Hitbox, pEntity)) {
  125. return Hitbox;
  126. }
  127. }
  128. for (int i = 0; i < 18; i++) {
  129.  
  130.  
  131. GetBonePosition(pEntity, Hitbox, hitboxarray[i]);
  132. if (BoneTraceWall(pLocal, pLocal->GetEyePos(), Hitbox, pEntity)) {
  133. return Hitbox;
  134. }
  135. }
  136. GetBonePosition(pEntity, Hitbox, hitboxarray[0]);
  137. return Hitbox;
  138. }
  139.  
  140. Vector Normalized(Vector& vec) {
  141. if (vec.x > 180) vec.x -= 360;
  142. if (vec.y > 180) vec.y -= 360;
  143. if (vec.x < -180) vec.x += 360;
  144. if (vec.y < -180) vec.y += 360;
  145. vec.z = 0;
  146. return vec;
  147. }
  148.  
  149. void SetSmoothAngles(CUserCmd* pCmd, Vector& dst) {
  150. if (aimspeed.getValue()) {
  151. Vector delta = pCmd->viewangles - dst;
  152. Normalized(delta);
  153. int smoothx = aimspeed.getValue() * 3;
  154. dst = pCmd->viewangles - delta / smoothx;
  155. dst.z = 0, delta.z = 0;
  156. }
  157. }
  158.  
  159. bool AutoWall(Vector vPos, C_BaseEntity* pLocal, C_BaseEntity* pEntity) {
  160. trace_t tr;
  161. Ray_t ray;
  162. Vector vStart, vEnd, vEndPos[3];
  163. vStart = pLocal->GetEyePos();
  164. vEnd = vPos;
  165. CTraceFilter filter;
  166.  
  167. if (IsVisible(pEntity, pLocal))
  168. return true;
  169.  
  170. filter.pSkip = pLocal;
  171. ray.Init(vStart, vEnd);
  172.  
  173. pEngineTrace->TraceRay(ray, 0x4602400B, &filter, &tr);
  174.  
  175. vEndPos[0] = tr.endpos;
  176.  
  177. ray.Init(vEnd, vStart);
  178. filter.pSkip = pEntity;
  179. pEngineTrace->TraceRay(ray, 0x4602400B, &filter, &tr);
  180.  
  181. vEndPos[1] = tr.endpos;
  182.  
  183. VectorSubtract(vEndPos[0], vEndPos[1], vEndPos[2]);
  184.  
  185. float flLength = VectorLength(vEndPos[2]);
  186. float limit = 37;
  187. float pen = pLocal->GetActive()->WallPenetration() / 10.f - 1;
  188. if (limit > pen)limit = pen;
  189. if (tr.fraction != 0)
  190. if (flLength < (limit))
  191. return true;
  192.  
  193. return false;
  194. }
  195.  
  196. /* BECOZ WE DEFINED OUR BONES IN OUR AUTOWALL DOT H IM DOIN A SHORT HITSCAN! */
  197.  
  198. void LowHITSCAN(Vector &Bones)
  199. {
  200. int i;
  201. C_BaseEntity* Entity = pEntList->GetClientEntity(i);
  202.  
  203. /* IF THEIR HEAD ISNT VISIBLE BZW WE CANT GET THE BONE POSITION! */
  204.  
  205. if (!GetBonePosition(Entity, Bones, HEAD));
  206. {
  207. (GetBonePosition(Entity, Bones, CHEST));
  208. (GetBonePosition(Entity, Bones, STOMACH));
  209. (GetBonePosition(Entity, Bones, LEFTARM));
  210. (GetBonePosition(Entity, Bones, RIGHTARM));
  211. (GetBonePosition(Entity, Bones, LEFTLEG));
  212. (GetBonePosition(Entity, Bones, RIGHTLEG));
  213. }
  214. }
  215.  
  216. std::chrono::time_point<std::chrono::system_clock> last_shoot = std::chrono::system_clock::now();
  217.  
  218. void doAim(CUserCmd* pCmd, bool& bSendPacket) {
  219.  
  220. Vector oldView = pCmd->viewangles;
  221. Vector Hitbox;
  222. const Vector vecAbsStart;
  223. Vector vecAbsEnd;
  224. float flDamage;
  225. float oldForwardmove = pCmd->forwardmove;
  226. float oldSidemove = pCmd->sidemove;
  227.  
  228. if (aim_active.getValve() == 1) {
  229.  
  230. C_BaseEntity* pLocal = pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  231. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  232. int BestID = 6; // -1
  233. int best_prior = 0;
  234. float maxDistance = 99999;
  235.  
  236. for (int i = 1; i < pEntList->GetHighestEntityIndex(); i++) {
  237.  
  238. C_BaseEntity* pEntity = pEntList->GetClientEntity(i);
  239. int tid = pEntity->Team();
  240.  
  241. if (pEntity && pEntity->Health() > 0 && pLocal->Health() > 0 && !pEntity->IsDormant() && pEntity->Team() != pLocal->Team() && !pEntity->IsImmune()) {
  242.  
  243. Vector BoneFrom, BoneTo;
  244.  
  245. GetBonePosition(pEntity, BoneFrom, hitbox.getValue());
  246.  
  247. if (hitscan.getValve() == 1)
  248. {
  249. Hitscans(pEntity, pLocal, Hitbox); // BoneFrom = Hitscans blaaa blaa usually
  250.  
  251. //LowHITSCAN(BoneFrom);
  252. }
  253.  
  254. CalcAngle(pLocal->GetEyePos(), BoneFrom, BoneTo);
  255. SetSmoothAngles(pCmd, BoneTo);
  256. ClampAngles(BoneTo);
  257. NormalizeVector(BoneTo);
  258. player_info_t pInfo;
  259. pEngine->GetPlayerInfo(i, &pInfo);
  260. char guid[32];
  261. int l = sprintf(guid, "%s", pInfo.guid);
  262. int prior = l == 0 ? 0 : 1;
  263.  
  264. if (IsVisible(pEntity, pLocal) && !autowall.getValve())
  265. {
  266. if (pWeapon->isShootable())
  267. {
  268. if (GetFOV(pCmd->viewangles, pLocal->GetEyePos(), BoneFrom) < FOV.getValue()) {
  269. if ((GetFOV(pCmd->viewangles, pLocal->GetEyePos(), BoneFrom) < maxDistance || prior >= best_prior) && prior != 0) {
  270. maxDistance = GetFOV(pCmd->viewangles, pLocal->GetEyePos(), BoneFrom);
  271. BestID = i;
  272. best_prior = prior;
  273. }
  274. }
  275.  
  276. }
  277. }
  278. //else if (Shoot(BoneFrom, data) && autowall.getValve()) {
  279. else if (AutoWall(BoneFrom, pLocal, pEntity) && autowall.getValve())
  280. {
  281. if (pWeapon->isShootable())
  282. {
  283. if (GetFOV(pCmd->viewangles, pLocal->GetEyePos(), BoneFrom) < FOV.getValue()) {
  284. if ((GetFOV(pCmd->viewangles, pLocal->GetEyePos(), BoneFrom) < maxDistance || prior >= best_prior) && prior != 0) {
  285. maxDistance = GetFOV(pCmd->viewangles, pLocal->GetEyePos(), BoneFrom);
  286. BestID = i;
  287. best_prior = prior;
  288. }
  289. }
  290. }
  291. }
  292. }
  293. }
  294.  
  295. C_BaseEntity* pEntity = pEntList->GetClientEntity(BestID);
  296.  
  297. if (pEntity && pEntity->Health() > 0 && pLocal->Health() > 0 && !pEntity->IsDormant() && pEntity->Team() != pLocal->Team() && !pEntity->IsImmune()) {
  298.  
  299. Vector BoneFrom, BoneTo, BoneSilent;
  300.  
  301. GetBonePosition(pEntity, BoneFrom, hitbox.getValue());
  302.  
  303. if (hitscan.getValve() == 1)
  304. {
  305. Hitscans(pEntity, pLocal, Hitbox); // BoneFrom = Hitscans blaaa blaa usually
  306.  
  307. //LowHITSCAN(BoneFrom);
  308. }
  309.  
  310. CalcAngle(pLocal->GetEyePos(), BoneFrom, BoneTo);
  311. SetSmoothAngles(pCmd, BoneTo);
  312. ClampAngles(BoneTo);
  313. NormalizeVector(BoneTo);
  314. aimbotAngle = BoneTo;
  315.  
  316. if (IsVisible(pEntity, pLocal) && !autowall.getValve())
  317. {
  318. if (pWeapon->isShootable())
  319. {
  320. if (GetFOV(pCmd->viewangles, pLocal->GetEyePos(), BoneFrom) < FOV.getValue()) {
  321.  
  322. if (autoshoot.getValve() == 1 && pWeapon->ShootCooldown() > 0 && pWeapon->WeaponAmmo() > 0 && pWeapon->isPistol()) {
  323. std::chrono::duration<double> elapsed = std::chrono::system_clock::now() - last_shoot;
  324. double chdelay = pWeapon->ShootCooldown() / 2000.;
  325. if (elapsed.count() > chdelay) {
  326. pCmd->buttons |= IN_ATTACK;
  327. last_shoot = std::chrono::system_clock::now();
  328. }
  329. }
  330. else
  331. if (autoshoot.getValve() == 1 && pWeapon->WeaponAmmo() > 0) {
  332. pCmd->buttons |= IN_ATTACK;
  333. }
  334. if (autoduck.getValve() == 1)
  335. {
  336. pCmd->buttons |= IN_DUCK;
  337. pCmd->sidemove = 0.f;
  338. pCmd->forwardmove = 0.f;
  339. }
  340. if (pCmd->buttons & IN_ATTACK) {
  341. pCmd->viewangles = BoneTo;
  342. }
  343. if (!silentaim.getValve() == 1) {
  344. pEngine->SetViewAngles(BoneTo);
  345. }
  346. if (psilentaim.getValve() == 1)
  347. {
  348. Vector qOldView = pCmd->viewangles;
  349. Vector vMove(pCmd->forwardmove, pCmd->sidemove, pCmd->upmove);
  350. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  351. Vector vMove2;
  352. Vector vRealView(pCmd->viewangles);
  353. VectorAngles3D(vMove, vMove2);
  354.  
  355. // GAY SILENT BEGINNS HERE //
  356.  
  357. if (pCmd->buttons & IN_ATTACK)
  358. {
  359. if (ChokedPackets < 3)
  360. {
  361. bSendPacket = false;
  362. pCmd->viewangles = BoneSilent;
  363. ChokedPackets++;
  364. }
  365. else
  366. {
  367. bSendPacket = true;
  368. pCmd->viewangles = oldView;
  369. ChokedPackets = 0; // usually 0
  370. }
  371. }
  372.  
  373. // GAY SILENT STOPS HERE # ADDITIONAL //
  374.  
  375. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  376.  
  377. float flServerTime = (float)(*(int*)((DWORD)pLocal + 0x3414) * pGlobals->interval_per_tick);
  378. float flAttacke = pWeapon->GetNextPrimaryAttack();
  379. //float flAttacke = (*(float*)((DWORD)pWeapon + 0x31C8));
  380.  
  381. bool deinvadder = true;
  382.  
  383. if (flAttacke > flServerTime)
  384. flAttacke = false;
  385.  
  386. if (pCmd->buttons & IN_ATTACK && flAttacke)
  387. {
  388. ClampAngles(qOldView);
  389. pCmd->viewangles = qOldView;
  390.  
  391. flYaw = DEG2RAD(pCmd->viewangles.y - vRealView.y + vMove2.y);
  392. pCmd->forwardmove = cos(flYaw) * flSpeed;
  393. pCmd->sidemove = sin(flYaw) * flSpeed;
  394. }
  395. }
  396. if (onetapmode.getValve() == 1) {
  397.  
  398. }
  399. }
  400. }
  401. }
  402. //else if (Shoot(BoneFrom, data) && autowall.getValve()) {
  403. else if (AutoWall(BoneFrom, pLocal, pEntity) && autowall.getValve())
  404. {
  405. if (pWeapon->isShootable())
  406. {
  407.  
  408. if (GetFOV(pCmd->viewangles, pLocal->GetEyePos(), BoneFrom) < FOV.getValue()) {
  409.  
  410. if (autoshoot.getValve() == 1 && pWeapon->ShootCooldown() > 0 && pWeapon->WeaponAmmo() > 0 && pWeapon->isPistol()) {
  411. std::chrono::duration<double> elapsed = std::chrono::system_clock::now() - last_shoot;
  412. double chdelay = pWeapon->ShootCooldown() / 2000.;
  413. if (elapsed.count() > chdelay) {
  414. pCmd->buttons |= IN_ATTACK;
  415. last_shoot = std::chrono::system_clock::now();
  416. }
  417. }
  418. else
  419. if (autoshoot.getValve() == 1 && pWeapon->WeaponAmmo() > 0) {
  420. pCmd->buttons |= IN_ATTACK;
  421. }
  422. if (autoduck.getValve() == 1)
  423. {
  424. pCmd->buttons |= IN_DUCK;
  425. pCmd->sidemove = 0.f;
  426. pCmd->forwardmove = 0.f;
  427. }
  428. if (pCmd->buttons & IN_ATTACK) {
  429. pCmd->viewangles = BoneTo;
  430. }
  431. if (!silentaim.getValve() == 1) {
  432. pEngine->SetViewAngles(BoneTo);
  433. }
  434. if (psilentaim.getValve() == 1)
  435. {
  436. Vector qOldView = pCmd->viewangles;
  437. Vector vMove(pCmd->forwardmove, pCmd->sidemove, pCmd->upmove);
  438. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  439. Vector vMove2;
  440. Vector vRealView(pCmd->viewangles);
  441. VectorAngles3D(vMove, vMove2);
  442.  
  443. // GAY SILENT BEGINNS HERE //
  444.  
  445. if (pCmd->buttons & IN_ATTACK)
  446. {
  447. if (ChokedPackets < 3)
  448. {
  449. bSendPacket = false;
  450. pCmd->viewangles = BoneSilent;
  451. ChokedPackets++;
  452. }
  453. else
  454. {
  455. bSendPacket = true;
  456. pCmd->viewangles = oldView;
  457. ChokedPackets = 0; // usually 0
  458. }
  459. }
  460.  
  461. // GAY SILENT STOPS HERE # ADDITIONAL //
  462.  
  463. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  464.  
  465. float flServerTime = (float)(*(int*)((DWORD)pLocal + 0x3414) * pGlobals->interval_per_tick);
  466. float flAttacke = pWeapon->GetNextPrimaryAttack();
  467. //float flAttacke = (*(float*)((DWORD)pWeapon + 0x31C8));
  468.  
  469. bool deinvadder = true;
  470.  
  471. if (flAttacke > flServerTime)
  472. flAttacke = false;
  473.  
  474. if (pCmd->buttons & IN_ATTACK && flAttacke)
  475. {
  476. ClampAngles(qOldView);
  477. pCmd->viewangles = qOldView;
  478.  
  479. flYaw = DEG2RAD(pCmd->viewangles.y - vRealView.y + vMove2.y);
  480. pCmd->forwardmove = cos(flYaw) * flSpeed;
  481. pCmd->sidemove = sin(flYaw) * flSpeed;
  482. }
  483. }
  484. if (onetapmode.getValve() == 1) {
  485.  
  486. }
  487. }
  488. }
  489. }
  490. }
  491. }
  492. }
  493.  
  494. // AIMBOAT ENDS HERE BLYAT
  495. //--------------------------------------------------------
  496. // SOME ANTIAIM RECOURCES HERE!
  497.  
  498. void xBulletTime(CUserCmd * cmd)
  499. {
  500. C_BaseEntity* pLocal = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  501. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  502.  
  503. float flServerTime = (float)(*(int*)((DWORD)pLocal + 0x3414) * pGlobals->interval_per_tick);
  504. float flAttacke = pWeapon->GetNextPrimaryAttack();
  505. //float flAttacke = (*(float*)((DWORD)pWeapon + 0x31C8));
  506.  
  507. bool gBulletTime = true;
  508. if (flAttacke > flServerTime)
  509. flAttacke = false;
  510.  
  511. if (cmd->buttons & IN_ATTACK && flAttacke)
  512. {
  513.  
  514. }
  515. }
  516.  
  517. int Multiplier()
  518. {
  519. static bool multi = false;
  520.  
  521. if (multi)
  522. 1 * 2;
  523. else
  524. 1 * 4;
  525.  
  526. multi = !multi;
  527.  
  528. return true;
  529. }
  530.  
  531. // ANTIAIM RECOURCES ENDS HERE LAL
  532.  
  533. //--------------------------------------------------------
  534.  
  535. // SOME ANTIAIM MEMES LOLOLOLOLOL
  536.  
  537. void antimeme1ye(CUserCmd * cmd)
  538. {
  539. Vector qOldView = cmd->viewangles;
  540. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  541. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  542. Vector vMove2;
  543. Vector vRealView(cmd->viewangles);
  544. VectorAngles3D(vMove, vMove2);
  545. C_BaseEntity* pLocal = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  546.  
  547. //_______________________________________
  548.  
  549. ClampAngles(cmd->viewangles);
  550. NormalizeVector(cmd->viewangles);
  551.  
  552. bool yNightmare = false;
  553.  
  554. if (yNightmare)
  555. {
  556. cmd->viewangles.x = 89;
  557. cmd->viewangles.y -= 180;
  558. }
  559. else
  560. {
  561. cmd->viewangles.x = 89;
  562. cmd->viewangles.y += 180;
  563. }
  564.  
  565. yNightmare = !yNightmare;
  566.  
  567. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  568. cmd->forwardmove = cos(flYaw) * flSpeed;
  569. cmd->sidemove = sin(flYaw) * flSpeed;
  570.  
  571. ClampAngles(cmd->viewangles);
  572. NormalizeVector(cmd->viewangles);
  573.  
  574. //_______________________________________
  575.  
  576. if (cmd->buttons & IN_ATTACK)
  577. {
  578. int random = rand() % 100;
  579. int random2 = rand() % 1000;
  580.  
  581. static bool dir;
  582. static float current_y = cmd->viewangles.y;
  583.  
  584. if (random == 1) dir = !dir;
  585.  
  586. if (dir)
  587. current_y += 5;
  588. else
  589. current_y -= 5;
  590.  
  591. cmd->viewangles.y = current_y;
  592.  
  593. if (random == random2)
  594. cmd->viewangles.y += random;
  595.  
  596. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  597. cmd->forwardmove = cos(flYaw) * flSpeed;
  598. cmd->sidemove = sin(flYaw) * flSpeed;
  599. }
  600.  
  601. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  602.  
  603. float flServerTime = (float)(*(int*)((DWORD)pLocal + 0x3414) * pGlobals->interval_per_tick);
  604. float flAttacke = pWeapon->GetNextPrimaryAttack();
  605. //float flAttacke = (*(float*)((DWORD)pWeapon + 0x31C8));
  606.  
  607. bool deinvadder = true;
  608.  
  609. if (flAttacke > flServerTime)
  610. flAttacke = false;
  611.  
  612. if (cmd->buttons & IN_ATTACK && flAttacke)
  613. {
  614. ClampAngles(qOldView);
  615. cmd->viewangles = qOldView;
  616.  
  617. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  618. cmd->forwardmove = cos(flYaw) * flSpeed;
  619. cmd->sidemove = sin(flYaw) * flSpeed;
  620. }
  621. ClampAngles(cmd->viewangles);
  622. NormalizeVector(cmd->viewangles);
  623. }
  624.  
  625. void bJitter(CUserCmd * cmd)
  626. {
  627. Vector qOldView = cmd->viewangles;
  628. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  629. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  630. Vector vMove2;
  631. Vector vRealView(cmd->viewangles);
  632. VectorAngles3D(vMove, vMove2);
  633. C_BaseEntity* pLocal = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  634.  
  635. //_______________________________________
  636.  
  637. ClampAngles(cmd->viewangles);
  638. NormalizeVector(cmd->viewangles);
  639.  
  640. bool bJitter = false;
  641.  
  642. if (bJitter)
  643. {
  644. cmd->viewangles.x = 89;
  645. cmd->viewangles.y -= 170;
  646. }
  647. else
  648. {
  649. cmd->viewangles.x = 89;
  650. cmd->viewangles.y += 170;
  651. }
  652.  
  653. bJitter = !bJitter;
  654.  
  655. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  656. cmd->forwardmove = cos(flYaw) * flSpeed;
  657. cmd->sidemove = sin(flYaw) * flSpeed;
  658.  
  659. ClampAngles(cmd->viewangles);
  660. NormalizeVector(cmd->viewangles);
  661.  
  662. //_______________________________________
  663.  
  664. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  665.  
  666. float flServerTime = (float)(*(int*)((DWORD)pLocal + 0x3414) * pGlobals->interval_per_tick);
  667. float flAttacke = pWeapon->GetNextPrimaryAttack();
  668. //float flAttacke = (*(float*)((DWORD)pWeapon + 0x31C8));
  669.  
  670. bool deinvadder = true;
  671.  
  672. if (flAttacke > flServerTime)
  673. flAttacke = false;
  674.  
  675. if (cmd->buttons & IN_ATTACK && flAttacke)
  676. {
  677. ClampAngles(qOldView);
  678. cmd->viewangles = qOldView;
  679.  
  680. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  681. cmd->forwardmove = cos(flYaw) * flSpeed;
  682. cmd->sidemove = sin(flYaw) * flSpeed;
  683. }
  684. ClampAngles(cmd->viewangles);
  685. NormalizeVector(cmd->viewangles);
  686. }
  687.  
  688. void antimeme2ye(CUserCmd * cmd)
  689. {
  690. Vector qOldView = cmd->viewangles;
  691. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  692. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  693. Vector vMove2;
  694. Vector vRealView(cmd->viewangles);
  695. VectorAngles3D(vMove, vMove2);
  696. C_BaseEntity* pLocal = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  697.  
  698. //_______________________________________
  699.  
  700. ClampAngles(cmd->viewangles);
  701. NormalizeVector(cmd->viewangles);
  702.  
  703. bool yNightmare = false;
  704.  
  705. if (yNightmare)
  706. {
  707. cmd->viewangles.x = 66;
  708. cmd->viewangles.y -= 180;
  709. }
  710. else
  711. {
  712. cmd->viewangles.x = 66;
  713. cmd->viewangles.y += 180;
  714. }
  715.  
  716. yNightmare = !yNightmare;
  717.  
  718. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  719. cmd->forwardmove = cos(flYaw) * flSpeed;
  720. cmd->sidemove = sin(flYaw) * flSpeed;
  721.  
  722. ClampAngles(cmd->viewangles);
  723. NormalizeVector(cmd->viewangles);
  724.  
  725. //_______________________________________
  726.  
  727. /* if (cmd->buttons & IN_ATTACK)
  728. {
  729. cmd->viewangles.y = 140;
  730.  
  731. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  732. cmd->forwardmove = cos(flYaw) * flSpeed;
  733. cmd->sidemove = sin(flYaw) * flSpeed;
  734. } */
  735.  
  736. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  737.  
  738. float flServerTime = (float)(*(int*)((DWORD)pLocal + 0x3414) * pGlobals->interval_per_tick);
  739. float flAttacke = pWeapon->GetNextPrimaryAttack();
  740. //float flAttacke = (*(float*)((DWORD)pWeapon + 0x31C8));
  741.  
  742. bool deinvadder = true;
  743.  
  744. if (flAttacke > flServerTime)
  745. flAttacke = false;
  746.  
  747. if (cmd->buttons & IN_ATTACK && flAttacke)
  748. {
  749. ClampAngles(qOldView);
  750. cmd->viewangles = qOldView;
  751.  
  752. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  753. cmd->forwardmove = cos(flYaw) * flSpeed;
  754. cmd->sidemove = sin(flYaw) * flSpeed;
  755. }
  756. ClampAngles(cmd->viewangles);
  757. NormalizeVector(cmd->viewangles);
  758. }
  759.  
  760. void casualaa(CUserCmd * cmd)
  761. {
  762. /* Some Casual antiaim no vac error coz no tickbase! */
  763.  
  764. /* EDIT: did add tickbase, cuz we are calling it before everything! */
  765.  
  766. Vector qOldView = cmd->viewangles;
  767. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  768. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  769. Vector vMove2;
  770. Vector vRealView(cmd->viewangles);
  771. VectorAngles3D(vMove, vMove2);
  772. C_BaseEntity* pLocal = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  773. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  774.  
  775. //_______________________________________
  776.  
  777. ClampAngles(cmd->viewangles);
  778. NormalizeVector(cmd->viewangles);
  779.  
  780. bool CASAA = false;
  781.  
  782. if (CASAA)
  783. {
  784. cmd->viewangles.y -= 180;
  785. cmd->viewangles.x = 69;
  786. }
  787. else
  788. {
  789. cmd->viewangles.y += 180;
  790. cmd->viewangles.x = 69;
  791. }
  792.  
  793. CASAA = !CASAA;
  794.  
  795. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  796. cmd->forwardmove = cos(flYaw) * flSpeed;
  797. cmd->sidemove = sin(flYaw) * flSpeed;
  798.  
  799. ClampAngles(cmd->viewangles);
  800. NormalizeVector(cmd->viewangles);
  801.  
  802. //_______________________________________
  803.  
  804. float flServerTime = (float)(*(int*)((DWORD)pLocal + 0x3414) * pGlobals->interval_per_tick);
  805. float flAttacke = pWeapon->GetNextPrimaryAttack();
  806. //float flAttacke = (*(float*)((DWORD)pWeapon + 0x31C8));
  807.  
  808. bool deinvadder = true;
  809.  
  810. if (flAttacke > flServerTime)
  811. flAttacke = false;
  812.  
  813. if (cmd->buttons & IN_ATTACK && flAttacke)
  814. {
  815. ClampAngles(qOldView);
  816. cmd->viewangles = qOldView;
  817.  
  818. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  819. cmd->forwardmove = cos(flYaw) * flSpeed;
  820. cmd->sidemove = sin(flYaw) * flSpeed;
  821. }
  822.  
  823. ClampAngles(cmd->viewangles);
  824. NormalizeVector(cmd->viewangles);
  825. }
  826.  
  827. void antimeme3ye(CUserCmd * cmd)
  828. {
  829. Vector qOldView = cmd->viewangles;
  830. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  831. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  832. Vector vMove2;
  833. Vector vRealView(cmd->viewangles);
  834. VectorAngles3D(vMove, vMove2);
  835. C_BaseEntity* pLocal = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  836.  
  837. //_______________________________________
  838.  
  839. ClampAngles(cmd->viewangles);
  840. NormalizeVector(cmd->viewangles);
  841.  
  842. cmd->viewangles.x = 89;
  843.  
  844. int random = 140 + rand() % 40;
  845. static float current_y = cmd->viewangles.y;
  846. current_y += random;
  847. cmd->viewangles.y = current_y;
  848.  
  849. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  850. cmd->forwardmove = cos(flYaw) * flSpeed;
  851. cmd->sidemove = sin(flYaw) * flSpeed;
  852.  
  853. ClampAngles(cmd->viewangles);
  854. NormalizeVector(cmd->viewangles);
  855.  
  856. //_______________________________________
  857.  
  858. /* if (cmd->buttons & IN_ATTACK)
  859. {
  860. cmd->viewangles.y = 140;
  861.  
  862. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  863. cmd->forwardmove = cos(flYaw) * flSpeed;
  864. cmd->sidemove = sin(flYaw) * flSpeed;
  865. } */
  866.  
  867. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  868.  
  869. float flServerTime = (float)(*(int*)((DWORD)pLocal + 0x3414) * pGlobals->interval_per_tick);
  870. float flAttacke = pWeapon->GetNextPrimaryAttack();
  871. //float flAttacke = (*(float*)((DWORD)pWeapon + 0x31C8));
  872.  
  873. bool deinvadder = true;
  874.  
  875. if (flAttacke > flServerTime)
  876. flAttacke = false;
  877.  
  878. if (cmd->buttons & IN_ATTACK && flAttacke)
  879. {
  880. ClampAngles(qOldView);
  881. cmd->viewangles = qOldView;
  882.  
  883. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  884. cmd->forwardmove = cos(flYaw) * flSpeed;
  885. cmd->sidemove = sin(flYaw) * flSpeed;
  886. }
  887. ClampAngles(cmd->viewangles);
  888. NormalizeVector(cmd->viewangles);
  889. }
  890.  
  891. void fakeedge(CUserCmd * cmd, bool &bSendPacket)
  892. {
  893. Vector qOldView = cmd->viewangles;
  894. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  895. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  896. Vector vMove2;
  897. Vector vRealView(cmd->viewangles);
  898. VectorAngles3D(vMove, vMove2);
  899. C_BaseEntity* pLocal = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  900.  
  901. //_______________________________________
  902.  
  903. ClampAngles(cmd->viewangles);
  904. NormalizeVector(cmd->viewangles);
  905.  
  906. if (fakeedgetick < 3)
  907. {
  908. cmd->viewangles.x = 89;
  909. cmd->viewangles.y = 90;
  910. bSendPacket = false;
  911. fakeedgetick++;
  912. }
  913. else
  914. {
  915. cmd->viewangles.x = 89;
  916. cmd->viewangles.y = 90;
  917. bSendPacket = true;
  918. fakeedgetick = 0;
  919. }
  920.  
  921. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  922. cmd->forwardmove = cos(flYaw) * flSpeed;
  923. cmd->sidemove = sin(flYaw) * flSpeed;
  924.  
  925. ClampAngles(cmd->viewangles);
  926. NormalizeVector(cmd->viewangles);
  927.  
  928. //_______________________________________
  929.  
  930. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  931.  
  932. float flServerTime = (float)(*(int*)((DWORD)pLocal + 0x3414) * pGlobals->interval_per_tick);
  933. float flAttacke = pWeapon->GetNextPrimaryAttack();
  934. //float flAttacke = (*(float*)((DWORD)pWeapon + 0x31C8));
  935.  
  936. bool deinvadder = true;
  937.  
  938. if (flAttacke > flServerTime)
  939. flAttacke = false;
  940.  
  941. if (cmd->buttons & IN_ATTACK && flAttacke)
  942. {
  943. ClampAngles(qOldView);
  944. cmd->viewangles = qOldView;
  945.  
  946. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  947. cmd->forwardmove = cos(flYaw) * flSpeed;
  948. cmd->sidemove = sin(flYaw) * flSpeed;
  949. }
  950.  
  951. ClampAngles(cmd->viewangles);
  952. NormalizeVector(cmd->viewangles);
  953. }
  954.  
  955. void edge(CUserCmd * cmd, bool &bSendPacket)
  956. {
  957. Vector qOldView = cmd->viewangles;
  958. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  959. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  960. Vector vMove2;
  961. Vector vRealView(cmd->viewangles);
  962. VectorAngles3D(vMove, vMove2);
  963. C_BaseEntity* pLocal = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  964.  
  965. //_______________________________________
  966.  
  967. ClampAngles(cmd->viewangles);
  968. NormalizeVector(cmd->viewangles);
  969.  
  970. cmd->viewangles.x = 89;
  971. cmd->viewangles.y -= 90;
  972.  
  973. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  974. cmd->forwardmove = cos(flYaw) * flSpeed;
  975. cmd->sidemove = sin(flYaw) * flSpeed;
  976.  
  977. ClampAngles(cmd->viewangles);
  978. NormalizeVector(cmd->viewangles);
  979.  
  980. //_______________________________________
  981.  
  982. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  983.  
  984. float flServerTime = (float)(*(int*)((DWORD)pLocal + 0x3414) * pGlobals->interval_per_tick);
  985. float flAttacke = pWeapon->GetNextPrimaryAttack();
  986. //float flAttacke = (*(float*)((DWORD)pWeapon + 0x31C8));
  987.  
  988. bool deinvadder = true;
  989.  
  990. if (flAttacke > flServerTime)
  991. flAttacke = false;
  992.  
  993. if (cmd->buttons & IN_ATTACK && flAttacke)
  994. {
  995. ClampAngles(qOldView);
  996. cmd->viewangles = qOldView;
  997.  
  998. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  999. cmd->forwardmove = cos(flYaw) * flSpeed;
  1000. cmd->sidemove = sin(flYaw) * flSpeed;
  1001. }
  1002.  
  1003. ClampAngles(cmd->viewangles);
  1004. NormalizeVector(cmd->viewangles);
  1005.  
  1006. }
  1007.  
  1008. void ANGLELAFF(CUserCmd * cmd, bool &bSendPacket)
  1009. {
  1010. Vector qOldView = cmd->viewangles;
  1011. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  1012. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  1013. Vector vMove2;
  1014. Vector vRealView(cmd->viewangles);
  1015. VectorAngles3D(vMove, vMove2);
  1016. C_BaseEntity* pLocal = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  1017.  
  1018. //_______________________________________
  1019.  
  1020. int random = rand() % 100;
  1021. int random2 = rand() % 1000;
  1022. static bool dir;
  1023. static bool staticpitch = false;
  1024. static float current_y = cmd->viewangles.y;
  1025.  
  1026. if (angeltick < 3)
  1027. {
  1028. cmd->viewangles.x = 36000088;
  1029. if (random == 1) dir = !dir;
  1030. if (dir)
  1031. current_y += 180 * 10000000 * cmd->randomseed;
  1032. else
  1033. current_y -= 180 * 10000000 * cmd->randomseed;
  1034. cmd->viewangles.y = current_y;
  1035. if (random == random2)
  1036. cmd->viewangles.y += random;
  1037.  
  1038. bSendPacket = false;
  1039. angeltick++;
  1040. }
  1041. else
  1042. {
  1043. cmd->viewangles.x = 36000088;
  1044. if (random == 1) dir = !dir;
  1045. if (dir)
  1046. current_y += 180 * 10000000 * cmd->randomseed;
  1047. else
  1048. current_y -= 180 * 10000000 * cmd->randomseed;
  1049. cmd->viewangles.y = current_y;
  1050. if (random == random2)
  1051. cmd->viewangles.y += random;
  1052.  
  1053. bSendPacket = true;
  1054. angeltick = -1;
  1055. }
  1056.  
  1057. //_______________________________________
  1058.  
  1059. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  1060.  
  1061. float flServerTime = (float)(*(int*)((DWORD)pLocal + 0x3414) * pGlobals->interval_per_tick);
  1062. float flAttacke = pWeapon->GetNextPrimaryAttack();
  1063. //float flAttacke = (*(float*)((DWORD)pWeapon + 0x31C8));
  1064.  
  1065. bool deinvadder = true;
  1066.  
  1067. if (flAttacke > flServerTime)
  1068. flAttacke = false;
  1069.  
  1070. if (cmd->buttons & IN_ATTACK && flAttacke)
  1071. {
  1072. cmd->viewangles = qOldView;
  1073. }
  1074. }
  1075.  
  1076. void mattiazangel(CUserCmd * cmd, bool &bSendPacket)
  1077. {
  1078. Vector qOldView = cmd->viewangles;
  1079. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  1080. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  1081. Vector vMove2;
  1082. Vector vRealView(cmd->viewangles);
  1083. VectorAngles3D(vMove, vMove2);
  1084. C_BaseEntity* pLocal = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  1085.  
  1086. //_______________________________________
  1087.  
  1088. if (!pLocal->Team() == 1)
  1089. {
  1090. float xLisp = 36000088;
  1091. float pLisp = 18000089;
  1092. cmd->viewangles.y = pLisp * cmd->randomseed;
  1093. cmd->viewangles.x = xLisp * cmd->randomseed;
  1094. }
  1095. else
  1096. {
  1097. float xLisp = 36000088;
  1098. float pLisp = 18000089;
  1099. cmd->viewangles.y = -pLisp * cmd->randomseed;
  1100. cmd->viewangles.x = -xLisp * cmd->randomseed;
  1101. }
  1102.  
  1103. //_______________________________________
  1104.  
  1105. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  1106.  
  1107. float flServerTime = (float)(*(int*)((DWORD)pLocal + 0x3414) * pGlobals->interval_per_tick);
  1108. float flAttacke = pWeapon->GetNextPrimaryAttack();
  1109. //float flAttacke = (*(float*)((DWORD)pWeapon + 0x31C8));
  1110.  
  1111. bool deinvadder = true;
  1112.  
  1113. if (flAttacke > flServerTime)
  1114. flAttacke = false;
  1115.  
  1116. if (cmd->buttons & IN_ATTACK && flAttacke)
  1117. {
  1118. cmd->viewangles = qOldView;
  1119. }
  1120. }
  1121.  
  1122. void rekt1337(CUserCmd * cmd, bool &bSendPacket)
  1123. {
  1124. Vector qOldView = cmd->viewangles;
  1125. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  1126. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  1127. Vector vMove2;
  1128. Vector vRealView(cmd->viewangles);
  1129. VectorAngles3D(vMove, vMove2);
  1130. C_BaseEntity* pLocal = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  1131.  
  1132. //_______________________________________
  1133.  
  1134. if (!pLocal->Team() == 1)
  1135. {
  1136. bSendPacket = false;
  1137. }
  1138. else
  1139. {
  1140. float xLisp = 3600008888;
  1141. float pLisp = 1800008889;
  1142.  
  1143. bSendPacket = true;
  1144.  
  1145. cmd->viewangles.y = -pLisp * cmd->randomseed;
  1146. cmd->viewangles.x = -xLisp * cmd->randomseed;
  1147. }
  1148.  
  1149. //_______________________________________
  1150.  
  1151. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  1152.  
  1153. float flServerTime = (float)(*(int*)((DWORD)pLocal + 0x3414) * pGlobals->interval_per_tick);
  1154. float flAttacke = pWeapon->GetNextPrimaryAttack();
  1155. //float flAttacke = (*(float*)((DWORD)pWeapon + 0x31C8));
  1156.  
  1157. bool deinvadder = true;
  1158.  
  1159. if (flAttacke > flServerTime)
  1160. flAttacke = false;
  1161.  
  1162. if (cmd->buttons & IN_ATTACK && flAttacke)
  1163. {
  1164. cmd->viewangles = qOldView;
  1165. }
  1166. }
  1167.  
  1168. // CREDITS TO FIXED COMES AFTER THIS SENTENCE
  1169. //--------------------------------------------------------
  1170. // OUR FAKE ANTIAIM SECTION
  1171.  
  1172. void fBackwards(C_BaseEntity* pLocal, CUserCmd* cmd, bool &bSendPacket)
  1173. {
  1174. Vector qOldView = cmd->viewangles;
  1175. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  1176. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  1177. Vector vMove2;
  1178. Vector vRealView(cmd->viewangles);
  1179. VectorAngles3D(vMove, vMove2);
  1180.  
  1181. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  1182.  
  1183. auto flServerTime = (float)(*(int*)((DWORD)pLocal + 0x3414) * pGlobals->interval_per_tick);
  1184. auto flAttacke = pWeapon->GetNextPrimaryAttack();
  1185.  
  1186. bool bBulletTime = true;
  1187.  
  1188. if (flAttacke > flServerTime)
  1189. bBulletTime = false;
  1190.  
  1191. if (cmd->buttons & IN_ATTACK && bBulletTime)
  1192. {
  1193. bSendPacket = false;
  1194. }
  1195. else
  1196. {
  1197. bSendPacket = true;
  1198.  
  1199. if (!pLocal->Team() == 1)
  1200. {
  1201. cmd->viewangles.x = 89;
  1202. cmd->viewangles.y = -180;
  1203. }
  1204. else
  1205. {
  1206. cmd->viewangles.x = 89;
  1207. cmd->viewangles.y = -180;
  1208. }
  1209.  
  1210. flYaw = DEG2RAD(cmd->viewangles.y - vRealView.y + vMove2.y);
  1211. cmd->forwardmove = cos(flYaw) * flSpeed;
  1212. cmd->sidemove = sin(flYaw) * flSpeed;
  1213.  
  1214. ClampAngles(cmd->viewangles);
  1215. NormalizeVector(cmd->viewangles);
  1216. }
  1217. }
  1218.  
  1219. void fHead(C_BaseEntity* pLocal, CUserCmd* cmd, bool &bSendPacket)
  1220. {
  1221. Vector qOldView = cmd->viewangles;
  1222. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  1223. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  1224. Vector vMove2;
  1225. Vector vRealView(cmd->viewangles);
  1226. VectorAngles3D(vMove, vMove2);
  1227.  
  1228. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  1229.  
  1230. auto flServerTime = (float)(*(int*)((DWORD)pLocal + 0x3414) * pGlobals->interval_per_tick);
  1231. auto flAttacke = pWeapon->GetNextPrimaryAttack();
  1232.  
  1233. bool bBulletTime = true;
  1234.  
  1235. if (flAttacke > flServerTime)
  1236. bBulletTime = false;
  1237.  
  1238. if (cmd->buttons & IN_ATTACK && bBulletTime)
  1239. {
  1240. bSendPacket = false;
  1241. }
  1242. else
  1243. {
  1244. bSendPacket = true;
  1245.  
  1246. static bool flip;
  1247. int veloc = pLocal->GetVelocity().Length();
  1248.  
  1249. cmd->viewangles.y += 1801188099 * veloc;
  1250.  
  1251. if (flip)
  1252. {
  1253. cmd->viewangles.x = 1800000089;
  1254. cmd->viewangles.y = 42000000120 * cmd->randomseed;
  1255. flip = !flip;
  1256. }
  1257. else
  1258. {
  1259. cmd->viewangles.x = 1800000089;
  1260. cmd->viewangles.y = 42000000210 * cmd->randomseed;
  1261. flip = !flip;
  1262. }
  1263. }
  1264. }
  1265.  
  1266. void fLisp(C_BaseEntity* pLocal, CUserCmd* cmd, bool &bSendPacket)
  1267. {
  1268. Vector qOldView = cmd->viewangles;
  1269. Vector vMove(cmd->forwardmove, cmd->sidemove, cmd->upmove);
  1270. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  1271. Vector vMove2;
  1272. Vector vRealView(cmd->viewangles);
  1273. VectorAngles3D(vMove, vMove2);
  1274.  
  1275. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  1276.  
  1277. auto flServerTime = (float)(*(int*)((DWORD)pLocal + 0x3414) * pGlobals->interval_per_tick);
  1278. auto flAttacke = pWeapon->GetNextPrimaryAttack();
  1279.  
  1280. bool bBulletTime = true;
  1281.  
  1282. if (flAttacke > flServerTime)
  1283. bBulletTime = false;
  1284.  
  1285. if (cmd->buttons & IN_ATTACK && bBulletTime)
  1286. {
  1287. bSendPacket = false;
  1288. }
  1289. else
  1290. {
  1291. bSendPacket = true;
  1292.  
  1293. static bool Switch = false;
  1294. int veloc = pLocal->GetVelocity().Length();
  1295.  
  1296. if (Switch)
  1297. {
  1298. cmd->viewangles.x = 1800000089;
  1299. cmd->viewangles.y -= 1003004000 * veloc;
  1300. }
  1301. else
  1302. {
  1303. cmd->viewangles.x = 1800000089;
  1304. cmd->viewangles.y += 1801188099 * veloc;
  1305. }
  1306.  
  1307. Switch = !Switch;
  1308. }
  1309. }
  1310.  
  1311. // ANTI AIM ENDS HERE
  1312. //--------------------------------------------------------
  1313. // MUCH RESOLVER KOTENZ
  1314.  
  1315.  
  1316.  
  1317. // RESOLVERS ENDS HERE
  1318. //--------------------------------------------------------
  1319. // MUCH VISUAL CODENZ BIG HARDKOTET BY REFLEXUS MASTIKUS
  1320.  
  1321. void Watermarkyo()
  1322. {
  1323. if (watermark.getValve() == 1)
  1324. {
  1325. DrawString(8, 8, Color(150, 0, 30, 255), Watermarkfont, "zer0ine v1.0");
  1326. DrawString(8, 24, Color(150, 0, 30, 255), Watermarkfont, "BY REFLEX");
  1327. }
  1328. }
  1329.  
  1330. void UserMark()
  1331. {
  1332. if (hwid->hwidCheck(0x9C5FD31E))
  1333. {
  1334. DrawString(8, 40, Color(150, 0, 30, 255), Watermarkfont, "USER: REFLEX");
  1335. }
  1336. }
  1337.  
  1338. void inEdge()
  1339. {
  1340. C_BaseEntity* Local = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  1341. C_BaseCombatWeapon* pWeapon = Local->GetActive();
  1342.  
  1343. if (!Local)
  1344. return;
  1345.  
  1346. if (!pWeapon)
  1347. return;
  1348.  
  1349. if (Local->GetVelocity().Length() < 5 && pWeapon->isSomething())
  1350. {
  1351. DrawString(8, 550, Color(150, 0, 30, 255), Watermarkfont, "IN EDGE: TRUE");
  1352. }
  1353. else if (Local->GetVelocity().Length() > 5 && pWeapon->isSomething())
  1354. {
  1355. DrawString(8, 550, Color(150, 0, 30, 255), Watermarkfont, "IN EDGE: FALSE");
  1356. }
  1357. }
  1358.  
  1359. void AIMWAREESP()
  1360. {
  1361. C_BaseEntity* Local = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  1362. if (!Local)
  1363. return;
  1364.  
  1365. for (int i = 1; i < pEntList->GetHighestEntityIndex(); i++) {
  1366. C_BaseEntity* Entity = (C_BaseEntity*)pEntList->GetClientEntity(i);
  1367.  
  1368. if (!Entity)
  1369. continue;
  1370.  
  1371. if (Entity->IsDormant())
  1372. continue;
  1373.  
  1374. if (Entity->Health() < 1)
  1375. continue;
  1376.  
  1377. if (Entity == Local)
  1378. continue;
  1379.  
  1380. Vector mon, nom;
  1381.  
  1382. nom = Entity->GetAbsOrigin();
  1383.  
  1384. if (Entity->Flags() & FL_DUCKING) {
  1385. mon = nom + Vector(0, 0, 50.f);
  1386. }
  1387. else {
  1388. mon = nom + Vector(0, 0, 70.f);
  1389. }
  1390.  
  1391. Vector bot, top;
  1392. player_info_t pInfo;
  1393. pEngine->GetPlayerInfo(i, &pInfo);
  1394. if (WorldToScreen(nom, bot) && WorldToScreen(mon, top)) {
  1395. float h = (bot.y - top.y);
  1396. float w = h / 3.5f;
  1397. int iMiddle = (bot.y - top.y) + 4;
  1398. int iWidth = iMiddle / 3.5;
  1399.  
  1400. if (Entity->Team() == 2) // T
  1401. {
  1402. DrawOutlinedRect(top.x - iWidth, top.y, iWidth * 2, iMiddle, Color(0,0,0));
  1403. DrawOutlinedRect(top.x - iWidth + 1, top.y + 1, iWidth * 2 - 2, iMiddle - 2, Color(150, 0, 30, 255));
  1404. }
  1405.  
  1406. if (Entity->Team() == 3) // CT
  1407. {
  1408. DrawOutlinedRect(top.x - iWidth, top.y, iWidth * 2, iMiddle, Color(0,0,0));
  1409. DrawOutlinedRect(top.x - iWidth + 1, top.y + 1, iWidth * 2 - 2, iMiddle - 2, Color(30, 150, 150, 255));
  1410. }
  1411. }
  1412. }
  1413. }
  1414.  
  1415. void AIMWAREHEALTH()
  1416. {
  1417. C_BaseEntity* Local = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  1418. if (!Local)
  1419. return;
  1420.  
  1421. for (int i = 1; i < pEntList->GetHighestEntityIndex(); i++) {
  1422. C_BaseEntity* Entity = (C_BaseEntity*)pEntList->GetClientEntity(i);
  1423.  
  1424. if (!Entity)
  1425. continue;
  1426.  
  1427. if (Entity->IsDormant())
  1428. continue;
  1429.  
  1430. if (Entity->Health() < 1)
  1431. continue;
  1432.  
  1433. if (Entity == Local)
  1434. continue;
  1435.  
  1436. Vector mon, nom;
  1437.  
  1438. nom = Entity->GetAbsOrigin();
  1439.  
  1440. if (Entity->Flags() & FL_DUCKING) {
  1441. mon = nom + Vector(0, 0, 50.f);
  1442. }
  1443. else {
  1444. mon = nom + Vector(0, 0, 70.f);
  1445. }
  1446. Vector bot, top;
  1447. player_info_t pInfo;
  1448. pEngine->GetPlayerInfo(i, &pInfo);
  1449. if (WorldToScreen(nom, bot) && WorldToScreen(mon, top)) {
  1450. float h = (bot.y - top.y);
  1451. float w = h / 3.5f;
  1452. int iMiddle = (bot.y - top.y) + 4;
  1453. int iWidth = iMiddle / 3.5;
  1454.  
  1455. if (Entity->Team() == 2)
  1456. {
  1457. int iClampedHealth = Entity->Health();
  1458. if (iClampedHealth >= 101)
  1459. iClampedHealth = 100;
  1460. int iHealthG = iClampedHealth * 2.55;
  1461. int iHealthR = 255 - iHealthG;
  1462.  
  1463. Color colHealth = Color(iHealthR, iHealthG, 0, 255);
  1464. DrawRect(top.x + iWidth + 3, top.y + 1, 3, iMiddle * 0.01 * iClampedHealth - 2, colHealth);
  1465. DrawBox(top.x + iWidth + 2, top.y, 3 + 2, iMiddle, Color(0, 0, 0, 255));
  1466.  
  1467. // FilledRGBOutlined(top.x - 6, top.y, 3, top.y, Color(14, 14, 14, 255));
  1468. // FillRGB(top.x - 6, top.y + top.y - iWidth, 2, iMiddle, colHealth);
  1469. }
  1470.  
  1471. if (Entity->Team() == 3)
  1472. {
  1473. int iClampedHealth = Entity->Health();
  1474. if (iClampedHealth >= 101)
  1475. iClampedHealth = 100;
  1476. int iHealthG = iClampedHealth * 2.55;
  1477. int iHealthR = 255 - iHealthG;
  1478.  
  1479. Color colHealth = Color(iHealthR, iHealthG, 0, 255);
  1480.  
  1481. DrawRect(top.x + iWidth + 3, top.y + 1, 3, iMiddle * 0.01 * iClampedHealth - 2, colHealth);
  1482. DrawBox(top.x + iWidth + 2, top.y, 3 + 2, iMiddle, Color(0, 0, 0, 255));
  1483.  
  1484. // FilledRGBOutlined(top.x - 6, top.y, 3, top.y, Color(14, 14, 14, 255));
  1485. // FillRGB(top.x - 6, top.y + top.y - iWidth, 2, iMiddle, colHealth);
  1486. }
  1487. }
  1488. }
  1489. }
  1490.  
  1491. void TXTHEALTH()
  1492. {
  1493. C_BaseEntity* Local = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  1494. if (!Local)
  1495. return;
  1496.  
  1497. for (int i = 1; i < pEntList->GetHighestEntityIndex(); i++) {
  1498. C_BaseEntity* Entity = (C_BaseEntity*)pEntList->GetClientEntity(i);
  1499.  
  1500. if (!Entity)
  1501. continue;
  1502.  
  1503. if (Entity->IsDormant())
  1504. continue;
  1505.  
  1506. if (Entity->Health() < 1)
  1507. continue;
  1508.  
  1509. if (Entity == Local)
  1510. continue;
  1511.  
  1512. Vector mon, nom;
  1513.  
  1514. nom = Entity->GetAbsOrigin();
  1515.  
  1516. if (Entity->Flags() & FL_DUCKING) {
  1517. mon = nom + Vector(0, 0, 50.f);
  1518. }
  1519. else {
  1520. mon = nom + Vector(0, 0, 70.f);
  1521. }
  1522. Vector bot, top;
  1523. player_info_t pInfo;
  1524. pEngine->GetPlayerInfo(i, &pInfo);
  1525. if (WorldToScreen(nom, bot) && WorldToScreen(mon, top)) {
  1526. float h = (bot.y - top.y);
  1527. float w = h / 3.5f;
  1528. int iMiddle = (bot.y - top.y) + 4;
  1529. int iWidth = iMiddle / 3.5;
  1530.  
  1531. if (Entity->Team() == 2)
  1532. {
  1533. drawText(pFont, top.x + iWidth + 3, top.y + 3, false, Color(240, 240, 240, 255), "HP: %i", Entity->Health());
  1534. }
  1535.  
  1536. if (Entity->Team() == 3)
  1537. {
  1538. drawText(pFont, top.x + iWidth + 3, top.y + 3, false, Color(240, 240, 240, 255), "HP: %i", Entity->Health());
  1539. }
  1540. }
  1541. }
  1542. }
  1543.  
  1544. void TXTARMOR()
  1545. {
  1546. C_BaseEntity* Local = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  1547. if (!Local)
  1548. return;
  1549.  
  1550. for (int i = 1; i < pEntList->GetHighestEntityIndex(); i++) {
  1551. C_BaseEntity* Entity = (C_BaseEntity*)pEntList->GetClientEntity(i);
  1552.  
  1553. if (!Entity)
  1554. continue;
  1555.  
  1556. if (Entity->IsDormant())
  1557. continue;
  1558.  
  1559. if (Entity->Health() < 1)
  1560. continue;
  1561.  
  1562. if (Entity == Local)
  1563. continue;
  1564.  
  1565. Vector mon, nom;
  1566.  
  1567. nom = Entity->GetAbsOrigin();
  1568.  
  1569. if (Entity->Flags() & FL_DUCKING) {
  1570. mon = nom + Vector(0, 0, 50.f);
  1571. }
  1572. else {
  1573. mon = nom + Vector(0, 0, 70.f);
  1574. }
  1575. Vector bot, top;
  1576. player_info_t pInfo;
  1577. pEngine->GetPlayerInfo(i, &pInfo);
  1578. if (WorldToScreen(nom, bot) && WorldToScreen(mon, top)) {
  1579. float h = (bot.y - top.y);
  1580. float w = h / 3.5f;
  1581. int iMiddle = (bot.y - top.y) + 4;
  1582. int iWidth = iMiddle / 3.5;
  1583.  
  1584. if (Entity->Team() == 2)
  1585. {
  1586. drawText(pFont, top.x + iWidth + 3, top.y + 11, false, Color(240, 240, 240, 255), "ARMOR: %i", Entity->Armor());
  1587. }
  1588.  
  1589. if (Entity->Team() == 3)
  1590. {
  1591. drawText(pFont, top.x + iWidth + 3, top.y + 11, false, Color(240, 240, 240, 255), "ARMOR: %i", Entity->Armor());
  1592. }
  1593. }
  1594. }
  1595. }
  1596.  
  1597. void ISVISIBLE()
  1598. {
  1599. C_BaseEntity* Local = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  1600. if (!Local)
  1601. return;
  1602.  
  1603. for (int i = 1; i < pEntList->GetHighestEntityIndex(); i++) {
  1604. C_BaseEntity* Entity = (C_BaseEntity*)pEntList->GetClientEntity(i);
  1605.  
  1606. if (!Entity)
  1607. continue;
  1608.  
  1609. if (Entity->IsDormant())
  1610. continue;
  1611.  
  1612. if (Entity->Health() < 1)
  1613. continue;
  1614.  
  1615. if (Entity == Local)
  1616. continue;
  1617.  
  1618. Vector mon, nom;
  1619.  
  1620. nom = Entity->GetAbsOrigin();
  1621.  
  1622. if (Entity->Flags() & FL_DUCKING) {
  1623. mon = nom + Vector(0, 0, 50.f);
  1624. }
  1625. else {
  1626. mon = nom + Vector(0, 0, 70.f);
  1627. }
  1628. Vector bot, top;
  1629. player_info_t pInfo;
  1630. pEngine->GetPlayerInfo(i, &pInfo);
  1631. if (WorldToScreen(nom, bot) && WorldToScreen(mon, top)) {
  1632. float h = (bot.y - top.y);
  1633. float w = h / 3.5f;
  1634. int iMiddle = (bot.y - top.y) + 4;
  1635. int iWidth = iMiddle / 3.5;
  1636.  
  1637. if (Entity->Team() == 2)
  1638. {
  1639. if (IsVisible(Entity, Local))
  1640. {
  1641. drawText(pFont, top.x + iWidth + 3, top.y + 19, false, Color(240, 240, 240, 255), "VISIBLE!");
  1642. }
  1643. }
  1644.  
  1645. if (Entity->Team() == 3)
  1646. {
  1647. if (IsVisible(Entity, Local))
  1648. {
  1649. drawText(pFont, top.x + iWidth + 3, top.y + 19, false, Color(240, 240, 240, 255), "VISIBLE!");
  1650. }
  1651. }
  1652. }
  1653. }
  1654. }
  1655.  
  1656. void GLOWESP()
  1657. {
  1658. C_BaseEntity* Local = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  1659. if (!Local)
  1660. return;
  1661.  
  1662. for (int i = 1; i < pEntList->GetHighestEntityIndex(); i++) {
  1663. C_BaseEntity* Entity = (C_BaseEntity*)pEntList->GetClientEntity(i);
  1664.  
  1665. if (!Entity)
  1666. continue;
  1667.  
  1668. if (Entity->IsDormant())
  1669. continue;
  1670.  
  1671. if (Entity->Health() < 1)
  1672. continue;
  1673.  
  1674. if (Entity == Local)
  1675. continue;
  1676.  
  1677. Vector mon, nom;
  1678.  
  1679. nom = Entity->GetAbsOrigin();
  1680.  
  1681. if (Entity->Flags() & FL_DUCKING) {
  1682. mon = nom + Vector(0, 0, 50.f);
  1683. }
  1684. else {
  1685. mon = nom + Vector(0, 0, 70.f);
  1686. }
  1687. Vector bot, top;
  1688. player_info_t pInfo;
  1689. pEngine->GetPlayerInfo(i, &pInfo);
  1690. if (WorldToScreen2(nom, bot) && WorldToScreen2(mon, top)) {
  1691. float h = (bot.y - top.y);
  1692. float w = h / 3.5f;
  1693. int iMiddle = (bot.y - top.y) + 4;
  1694. int iWidth = iMiddle / 3.5;
  1695.  
  1696. DWORD gGlowPointer = *reinterpret_cast<DWORD*>((DWORD)GetModuleHandleA("client.dll") + (DWORD)0x04F6691C);
  1697.  
  1698. if (Entity->Team() == 2) {
  1699. StartGlow(gGlowPointer, Entity->GlowIndex(), 150, 0, 30, 255);
  1700. }
  1701.  
  1702. if (Entity->Team() == 3) {
  1703. StartGlow(gGlowPointer, Entity->GlowIndex(), 30, 150, 150, 255);
  1704. }
  1705. }
  1706. }
  1707. }
  1708.  
  1709. void ESPNAME()
  1710. {
  1711. C_BaseEntity* Local = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  1712. if (!Local)
  1713. return;
  1714.  
  1715. for (int i = 1; i < pEntList->GetHighestEntityIndex(); i++) {
  1716. C_BaseEntity* Entity = (C_BaseEntity*)pEntList->GetClientEntity(i);
  1717.  
  1718. if (!Entity)
  1719. continue;
  1720.  
  1721. if (Entity->IsDormant())
  1722. continue;
  1723.  
  1724. if (Entity->Health() < 1)
  1725. continue;
  1726.  
  1727. if (Entity == Local)
  1728. continue;
  1729.  
  1730. Vector mon, nom;
  1731.  
  1732. nom = Entity->GetAbsOrigin();
  1733.  
  1734. if (Entity->Flags() & FL_DUCKING) {
  1735. mon = nom + Vector(0, 0, 50.f);
  1736. }
  1737. else {
  1738. mon = nom + Vector(0, 0, 70.f);
  1739. }
  1740. Vector bot, top;
  1741. player_info_t pInfo;
  1742. pEngine->GetPlayerInfo(i, &pInfo);
  1743. if (WorldToScreen(nom, bot) && WorldToScreen(mon, top)) {
  1744. float h = (bot.y - top.y);
  1745. float w = h / 3.5f;
  1746. int iMiddle = (bot.y - top.y) + 4;
  1747. int iWidth = iMiddle / 3.5;
  1748.  
  1749. if (Entity->Team() == 2)
  1750. {
  1751. DrawStringMiddle(pFont, true, top.x, top.y - 5, Color(240, 240, 240, 255), pInfo.name);
  1752. }
  1753.  
  1754. if (Entity->Team() == 3)
  1755. {
  1756. DrawStringMiddle(pFont, true, top.x, top.y - 5, Color(240, 240, 240, 255), pInfo.name);
  1757. }
  1758. }
  1759. }
  1760. }
  1761.  
  1762. void CORNERAAESP()
  1763. {
  1764. C_BaseEntity* Local = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  1765. if (!Local)
  1766. return;
  1767.  
  1768. for (int i = 1; i < pEntList->GetHighestEntityIndex(); i++) {
  1769. C_BaseEntity* Entity = (C_BaseEntity*)pEntList->GetClientEntity(i);
  1770.  
  1771. if (!Entity)
  1772. continue;
  1773.  
  1774. if (Entity->IsDormant())
  1775. continue;
  1776.  
  1777. if (Entity->Health() < 1)
  1778. continue;
  1779.  
  1780. if (Entity == Local)
  1781. continue;
  1782.  
  1783. Vector mon, nom;
  1784.  
  1785. nom = Entity->GetAbsOrigin();
  1786.  
  1787. if (Entity->Flags() & FL_DUCKING) {
  1788. mon = nom + Vector(0, 0, 50.f);
  1789. }
  1790. else {
  1791. mon = nom + Vector(0, 0, 70.f);
  1792. }
  1793.  
  1794. Vector bot, top;
  1795. player_info_t pInfo;
  1796. pEngine->GetPlayerInfo(i, &pInfo);
  1797. if (WorldToScreen(nom, bot) && WorldToScreen(mon, top)) {
  1798. float h = (bot.y - top.y);
  1799. float w = h / 3.5f;
  1800. float radius;
  1801. int iMiddle = (bot.y - top.y) + 4;
  1802. int iWidth = iMiddle / 3.5;
  1803.  
  1804. if (Entity->Team() == 2)
  1805. {
  1806. EdgedOutline(top.x - w, top.y, w * 2, h, Color(150, 0, 30, 255));
  1807. }
  1808.  
  1809. if (Entity->Team() == 3)
  1810. {
  1811. EdgedOutline(top.x - w, top.y, w * 2, h, Color(30, 150, 150, 255));
  1812. }
  1813. }
  1814. }
  1815. }
  1816.  
  1817. void ESPWEAPON()
  1818. {
  1819. C_BaseEntity* Local = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  1820. if (!Local)
  1821. return;
  1822.  
  1823. for (int i = 1; i < pEntList->GetHighestEntityIndex(); i++) {
  1824. C_BaseEntity* Entity = (C_BaseEntity*)pEntList->GetClientEntity(i);
  1825.  
  1826. if (!Entity)
  1827. continue;
  1828.  
  1829. if (Entity->IsDormant())
  1830. continue;
  1831.  
  1832. if (Entity->Health() < 1)
  1833. continue;
  1834.  
  1835. if (Entity == Local)
  1836. continue;
  1837.  
  1838. Vector mon, nom;
  1839.  
  1840. nom = Entity->GetAbsOrigin();
  1841.  
  1842. if (Entity->Flags() & FL_DUCKING) {
  1843. mon = nom + Vector(0, 0, 50.f);
  1844. }
  1845. else {
  1846. mon = nom + Vector(0, 0, 70.f);
  1847. }
  1848.  
  1849. Vector bot, top;
  1850. player_info_t pInfo;
  1851. pEngine->GetPlayerInfo(i, &pInfo);
  1852. if (WorldToScreen(nom, bot) && WorldToScreen(mon, top)) {
  1853. float h = (bot.y - top.y);
  1854. float w = h / 3.5f;
  1855. int iMiddle = (bot.y - top.y) + 4;
  1856. int iWidth = iMiddle / 3.5;
  1857.  
  1858. if (Entity->Team() == 2)
  1859. {
  1860. drawText(pFont, top.x + w * 0.5, top.y + h + 1, true, Color(255, 255, 255, 255), "WEAPON: %i", Entity->getActiveWeapon());
  1861. }
  1862.  
  1863. if (Entity->Team() == 3)
  1864. {
  1865. drawText(pFont, top.x + w * 0.5, top.y + h + 1, true, Color(255, 255, 255, 255), "WEAPON: %i", Entity->getActiveWeapon());
  1866. }
  1867. }
  1868. }
  1869. }
  1870.  
  1871. void flashESP()
  1872. {
  1873. C_BaseEntity* Local = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  1874. if (!Local)
  1875. return;
  1876.  
  1877. for (int i = 1; i < pEntList->GetHighestEntityIndex(); i++) {
  1878. C_BaseEntity* Entity = (C_BaseEntity*)pEntList->GetClientEntity(i);
  1879.  
  1880. if (!Entity)
  1881. continue;
  1882.  
  1883. if (Entity->IsDormant())
  1884. continue;
  1885.  
  1886. if (Entity->Health() < 1)
  1887. continue;
  1888.  
  1889. if (Entity == Local)
  1890. continue;
  1891.  
  1892. Vector mon, nom;
  1893.  
  1894. nom = Entity->GetAbsOrigin();
  1895.  
  1896. if (Entity->Flags() & FL_DUCKING) {
  1897. mon = nom + Vector(0, 0, 50.f);
  1898. }
  1899. else {
  1900. mon = nom + Vector(0, 0, 70.f);
  1901. }
  1902.  
  1903. Vector bot, top;
  1904. player_info_t pInfo;
  1905. pEngine->GetPlayerInfo(i, &pInfo);
  1906. if (WorldToScreen(nom, bot) && WorldToScreen(mon, top)) {
  1907. float h = (bot.y - top.y);
  1908. float w = h / 3.5f;
  1909. int iMiddle = (bot.y - top.y) + 4;
  1910. int iWidth = iMiddle / 3.5;
  1911.  
  1912. if (Entity->Team() == 2 && Entity->flashDuration() > 0)
  1913. {
  1914. drawText(pFont, top.x + iWidth + 3, top.y + 27, false, Color(240, 240, 240, 255), "FLASHED!");
  1915. }
  1916.  
  1917. if (Entity->Team() == 3 && Entity->flashDuration() > 0)
  1918. {
  1919. drawText(pFont, top.x + iWidth + 3, top.y + 27, false, Color(240, 240, 240, 255), "FLASHED!");
  1920. }
  1921. }
  1922. }
  1923. }
  1924.  
  1925. void WALLBANGESPY()
  1926. {
  1927. C_BaseEntity* Local = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  1928. if (!Local)
  1929. return;
  1930.  
  1931. for (int i = 1; i < pEntList->GetHighestEntityIndex(); i++) {
  1932. C_BaseEntity* Entity = (C_BaseEntity*)pEntList->GetClientEntity(i);
  1933.  
  1934. if (!Entity)
  1935. continue;
  1936.  
  1937. if (Entity->IsDormant())
  1938. continue;
  1939.  
  1940. if (Entity->Health() < 1)
  1941. continue;
  1942.  
  1943. if (Entity == Local)
  1944. continue;
  1945.  
  1946. Vector mon, nom;
  1947. Vector vPos;
  1948.  
  1949. nom = Entity->GetAbsOrigin();
  1950.  
  1951. if (Entity->Flags() & FL_DUCKING) {
  1952. mon = nom + Vector(0, 0, 50.f);
  1953. }
  1954. else {
  1955. mon = nom + Vector(0, 0, 70.f);
  1956. }
  1957. Vector bot, top;
  1958. player_info_t pInfo;
  1959. pEngine->GetPlayerInfo(i, &pInfo);
  1960. if (WorldToScreen(nom, bot) && WorldToScreen(mon, top)) {
  1961. float h = (bot.y - top.y);
  1962. float w = h / 3.5f;
  1963. int iMiddle = (bot.y - top.y) + 4;
  1964. int iWidth = iMiddle / 3.5;
  1965.  
  1966. if (Entity->Team() == 2)
  1967. {
  1968. if (AutoWall(vPos, Local, Entity) && !IsVisible(Entity, Local))
  1969. {
  1970. drawText(pFont, top.x + iWidth + 3, top.y + 35, false, Color(240, 240, 240, 255), "WALLBANG!");
  1971. }
  1972. }
  1973.  
  1974. if (Entity->Team() == 3)
  1975. {
  1976. if (AutoWall(vPos, Local, Entity) && !IsVisible(Entity, Local))
  1977. {
  1978. drawText(pFont, top.x + iWidth + 3, top.y + 35, false, Color(240, 240, 240, 255), "WALLBANG!");
  1979. }
  1980. }
  1981. }
  1982. }
  1983. }
  1984.  
  1985. void hashelmetESP()
  1986. {
  1987. IClientEntityList * pClasses;
  1988. C_BaseEntity* Local = (C_BaseEntity*)pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  1989. if (!Local)
  1990. return;
  1991.  
  1992. for (int i = 1; i < pEntList->GetHighestEntityIndex(); i++) {
  1993. C_BaseEntity *ent = pEntList->GetClientEntity(i);
  1994. C_BaseEntity* Entity = (C_BaseEntity*)pEntList->GetClientEntity(i);
  1995.  
  1996. if (!Entity)
  1997. continue;
  1998.  
  1999. if (Entity->IsDormant())
  2000. continue;
  2001.  
  2002. if (Entity->Health() < 1)
  2003. continue;
  2004.  
  2005. if (Entity == Local)
  2006. continue;
  2007.  
  2008. Vector mon, nom;
  2009.  
  2010. nom = Entity->GetAbsOrigin();
  2011.  
  2012. if (Entity->Flags() & FL_DUCKING) {
  2013. mon = nom + Vector(0, 0, 50.f);
  2014. }
  2015. else {
  2016. mon = nom + Vector(0, 0, 70.f);
  2017. }
  2018.  
  2019. Vector bot, top;
  2020. player_info_t pInfo;
  2021. pEngine->GetPlayerInfo(i, &pInfo);
  2022. if (WorldToScreen(nom, bot) && WorldToScreen(mon, top)) {
  2023. float h = (bot.y - top.y);
  2024. float w = h / 3.5f;
  2025. int iMiddle = (bot.y - top.y) + 4;
  2026. int iWidth = iMiddle / 3.5;
  2027.  
  2028. if (Entity->Team() == 2 && Entity->hasHelmet())
  2029. {
  2030. drawText(pFont, top.x + iWidth + 3, top.y + 43, false, Color(240, 240, 240, 255), "HELMET: 1");
  2031. }
  2032.  
  2033. if (Entity->Team() == 3 && Entity->hasHelmet())
  2034. {
  2035. drawText(pFont, top.x + iWidth + 3, top.y + 43, false, Color(240, 240, 240, 255), "HELMET: 1");
  2036. }
  2037. }
  2038. }
  2039. }
  2040.  
  2041. // ESP MEMES ENDS HERE BLYAT
  2042. //-------------------------------------------------------------
  2043. // MISC MEMES BEGINNS HERE
  2044.  
  2045. void bhop(CUserCmd* pCmd, C_BaseEntity* Local)
  2046. {
  2047. if (pCmd->buttons & IN_JUMP)
  2048. {
  2049. if (!(Local->Flags() & FL_ONGROUND)) // pmeMes
  2050. {
  2051. pCmd->buttons &= ~IN_JUMP;
  2052. }
  2053. }
  2054. }
  2055.  
  2056. void namespammer()
  2057. {
  2058. static bool steal = false;
  2059.  
  2060. ConVar* Name = pCvar->FindVar("name");
  2061. *(int*)((DWORD)&Name->fnChangeCallback + 0xC) = 0;
  2062.  
  2063. if (Name)
  2064. {
  2065. if (steal)
  2066. {
  2067. Name->SetValue("PROJECT: zer0ine");
  2068. }
  2069. else
  2070. {
  2071. Name->SetValue("PROJECT: zer0ine.");
  2072. }
  2073.  
  2074. steal = !steal; // more simple like a normal cactus.
  2075. }
  2076. }
  2077.  
  2078. void fakelag1(C_BaseEntity * pLocal, bool &bSendPacket)
  2079. {
  2080. if (pLocal->GetLifeState() == 0)
  2081. {
  2082. float FakelagA = fakelagfac.getValue() * 3; // becoz we are donald trump.
  2083.  
  2084. if (fakelag < fakelagfac.getValue()) {
  2085. bSendPacket = false;
  2086. fakelag++;
  2087. }
  2088. else
  2089. {
  2090. bSendPacket = true;
  2091. fakelag = 0;
  2092. }
  2093. }
  2094. }
  2095.  
  2096. int fakesteps(C_BaseEntity * pLocal)
  2097. {
  2098. int step;
  2099. int Chokeness;
  2100.  
  2101. switch (step)
  2102. {
  2103. case 1:
  2104. if (pLocal->GetVelocity().Length() < 50)
  2105. Chokeness = 2;
  2106. break;
  2107. case 2:
  2108. if (pLocal->GetVelocity().Length() < 100)
  2109. Chokeness = 4;
  2110. break;
  2111. case 3:
  2112. if (pLocal->GetVelocity().Length() < 200)
  2113. Chokeness = 6;
  2114. break;
  2115. case 4:
  2116. if (pLocal->GetVelocity().Length() < 300)
  2117. Chokeness = 8;
  2118. break;
  2119. case 5:
  2120. if (pLocal->GetVelocity().Length() < 400)
  2121. Chokeness = 10;
  2122. break;
  2123. case 6:
  2124. if (pLocal->GetVelocity().Length() < 500)
  2125. Chokeness = 12;
  2126. break;
  2127. case 7:
  2128. if (pLocal->GetVelocity().Length() > 500)
  2129. Chokeness = 14;
  2130. break;
  2131. }
  2132.  
  2133. return true;
  2134. }
  2135.  
  2136. void fakelagAdaptive(C_BaseEntity * pLocal, bool &bSendPacket)
  2137. {
  2138. static int adaptive = 0;
  2139. float FakelagA = pLocal->GetVelocity().Length() * 3;
  2140.  
  2141. if (pLocal->GetLifeState() == 0)
  2142. {
  2143. if (adaptive < fakesteps(pLocal)) {
  2144.  
  2145. bSendPacket = false;
  2146. adaptive++;
  2147. }
  2148. else
  2149. {
  2150. bSendPacket = true;
  2151. adaptive = 0;
  2152. }
  2153.  
  2154. if (adaptive > 14)
  2155. adaptive = 0;
  2156. }
  2157. }
  2158.  
  2159. void fakelagRandom(C_BaseEntity * pLocal, bool &bSendPacket)
  2160. {
  2161. static int randd = 0;
  2162. int random = rand() % 14;
  2163. float FakelagA = random * 3;
  2164.  
  2165. if (pLocal->GetLifeState() == 0)
  2166. {
  2167. if (randd < random) { // vorlдufig auf random weil velocity mir noch probleme bereitet!
  2168.  
  2169. bSendPacket = false;
  2170. randd++;
  2171. }
  2172. else
  2173. {
  2174. bSendPacket = true;
  2175. randd = 0;
  2176. }
  2177. }
  2178. }
  2179.  
  2180. void Misc2(CUserCmd* pCmd, C_BaseEntity* Local)
  2181. {
  2182. C_BaseCombatWeapon* pWeapon = Local->GetActive();
  2183. Vector pRecoil; // love it! sidechicks of a sidechick!
  2184.  
  2185. if (pWeapon->isShootable())
  2186. {
  2187. pRecoil = Local->AimPunch() * 2.0; // Roll that angle Xer0000 :^)
  2188. pCmd->viewangles -= pRecoil;
  2189. ClampAngles(pCmd->viewangles);
  2190. NormalizeVector(pCmd->viewangles);
  2191. }
  2192. }
  2193.  
  2194. void autopistol(CUserCmd* pCmd)
  2195. {
  2196. if (pCmd->buttons & IN_ATTACK)
  2197. {
  2198. if (WasFiring)
  2199. {
  2200. pCmd->buttons &= ~IN_ATTACK;
  2201. }
  2202. }
  2203. WasFiring = pCmd->buttons & IN_ATTACK ? true : false; // this it literally gay but i love it too! <3
  2204. }
  2205.  
  2206. void doRCS(CUserCmd* pCmd, C_BaseEntity* Local)
  2207. {
  2208. C_BaseCombatWeapon* pWeapon = Local->GetActive();
  2209.  
  2210. if (!pWeapon)
  2211. return;
  2212.  
  2213. if (pWeapon->IsKnife())
  2214. return;
  2215.  
  2216. if (pWeapon->isShotgun())
  2217. return;
  2218.  
  2219. if (pWeapon->isGrenade())
  2220. return;
  2221.  
  2222. if (pWeapon->isPistol())
  2223. return;
  2224.  
  2225. if (pWeapon->isSniper())
  2226. return;
  2227.  
  2228. pEngine->GetViewAngles(VA);
  2229. PA = Local->AimPunch() * 2.0f;
  2230. float modifier = 100.0f - rcssmoothing.getValue();
  2231. modifier /= 100.0f;
  2232. VA.x -= (PA.x - oldPunchAngles.x) * modifier;
  2233. VA.y -= (PA.y - oldPunchAngles.y) * modifier;
  2234. oldPunchAngles = PA;
  2235.  
  2236. NormalizeVector(VA);
  2237. pCmd->viewangles = VA;
  2238. pEngine->SetViewAngles(VA);
  2239. ClampAngles(VA); // principally gay..
  2240.  
  2241. }
  2242.  
  2243. void pseudofovchanger()
  2244. {
  2245. ConVar * fov = pCvar->FindVar("viewmodel_fov");
  2246. fov->SetValue(FOVCHANGER.getValue());
  2247. }
  2248.  
  2249. void fovchanger(C_BaseEntity * pLocal)
  2250. {
  2251. int Fov = *(int*)(pLocal + 0x31C8) = FOVCHANGER.getValue(); // FOV_Start is 0x31CC
  2252.  
  2253. if (FOVCHANGER.getValue() == 90)
  2254. {
  2255. int Fov = *(int*)(pLocal + 0x31C8) = 90;
  2256. }
  2257. }
  2258.  
  2259. void asusWalls()
  2260. {
  2261.  
  2262. }
  2263.  
  2264. void noname()
  2265. {
  2266. ConVar * callback = pCvar->FindVar("name");
  2267. *(int*)((DWORD)&callback->fnChangeCallback + 0xC) = NULL;
  2268.  
  2269. pCvar->FindVar("name")->SetValue("\rPROJECT: zer0ine.");
  2270. }
  2271.  
  2272. void visCrosshair()
  2273. {
  2274. C_BaseEntity* pLocal = pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  2275.  
  2276. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  2277.  
  2278. if (!pWeapon)
  2279. return;
  2280.  
  2281. if (!pLocal)
  2282. return;
  2283.  
  2284. RECT View = GetViewport();
  2285. int x = View.right / 2;
  2286. int y = View.bottom / 2; // credits to shad0w for this math shit like viewport
  2287.  
  2288. //if (pWeapon->isSniper())
  2289. //{
  2290. FillRGB(x - 3, y - 3, 6, 6, Color(150, 0, 30, 255));
  2291. DrawBox(x - 4, y - 4, 7, 7, Color(155, 155, 155, 255));
  2292. //}
  2293. }
  2294.  
  2295. void RecoilCrosshair()
  2296. {
  2297. C_BaseEntity* pLocal = pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  2298.  
  2299. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  2300.  
  2301. if (!pWeapon)
  2302. return;
  2303.  
  2304. if (!pLocal)
  2305. return;
  2306.  
  2307. Vector ViewAngles;
  2308. pEngine->GetViewAngles(ViewAngles);
  2309. ViewAngles += pLocal->AimPunch() * 2;
  2310.  
  2311. Vector fowardVec;
  2312. Vector up, right;
  2313. AngleVectors(ViewAngles, &fowardVec, &up, &right);
  2314. fowardVec *= 10000;
  2315.  
  2316. Vector start = pLocal->GetAbsOrigin() + pLocal->LocalViewAngles();
  2317. Vector end = start + fowardVec, endScreen;
  2318.  
  2319. if (WorldToScreen(end, endScreen))
  2320. {
  2321. FillRGB(endScreen.x - 3, endScreen.y - 3, 6, 6, Color(150, 0, 30, 255));
  2322. DrawBox(endScreen.x - 4, endScreen.y - 4, 7, 7, Color(155, 155, 155, 255));
  2323. }
  2324. }
  2325.  
  2326. void namestealer()
  2327. {
  2328. static bool steal = false;
  2329. ConVar *name = pCvar->FindVar("name");
  2330. *(int*)((DWORD)&name->fnChangeCallback + 0xC) = NULL;
  2331.  
  2332. player_info_t pInfo;
  2333. char chCommand[256];
  2334.  
  2335. if (steal)
  2336. {
  2337. name->SetSteal(chCommand, "name \"%s \"", pInfo.name);
  2338. }
  2339. else
  2340. {
  2341. name->SetSteal(chCommand, "name \"%s \"", pInfo.name);
  2342. }
  2343.  
  2344. steal = !steal;
  2345. }
  2346.  
  2347. void FakeDuck(CUserCmd* cmd, bool& bSendPacket)
  2348. {
  2349. static bool fDuck = false;
  2350. static bool bFakeCrouch = true;
  2351.  
  2352. if (fDuck)
  2353. {
  2354. fDuck = false;
  2355. cmd->buttons &= ~IN_DUCK;
  2356. bSendPacket = false;
  2357. }
  2358. else if (bFakeCrouch)
  2359. {
  2360. bSendPacket = true;
  2361. cmd->buttons |= IN_DUCK;
  2362. fDuck = true;
  2363. }
  2364. bFakeCrouch = !bFakeCrouch;
  2365. }
  2366.  
  2367. void commandExecute2(const char* str)
  2368. {
  2369. pEngine->ExecuteClientCmd(str); // why im doin this function? for sw4g!
  2370. }
  2371.  
  2372. void chatspamcounter()
  2373. {
  2374. static bool chatspamrecode = false;
  2375.  
  2376. if (chatspamrecode)
  2377. {
  2378. commandExecute2("say im just laffing on you and rolling naked on my floor.");
  2379. Sleep(50);
  2380. }
  2381. else
  2382. {
  2383. commandExecute2("say this cheat is made by reflex tbh.");
  2384. Sleep(50);
  2385. }
  2386.  
  2387. chatspamrecode = !chatspamrecode; // its gay but i love it!
  2388. }
  2389.  
  2390. void servercrasher()
  2391. {
  2392. static bool crasher = false;
  2393.  
  2394. if (crasher)
  2395. {
  2396. commandExecute2(""); // spamming nothing makin some errors
  2397. }
  2398. else
  2399. {
  2400. commandExecute2("status"); // spamming status crashin some shit
  2401. }
  2402.  
  2403. crasher = !crasher; // status spam works to crash? loololol this is the lucifer type of evilness ..
  2404. }
  2405.  
  2406. void AutoStrafe(CUserCmd *pCmd, C_BaseEntity * pLocal)
  2407. {
  2408. static bool bDirection = true;
  2409. static bool jumpspammer = false;
  2410.  
  2411. static float move = 450;
  2412. float s_move = move * 0.5065f;
  2413.  
  2414. if (GetAsyncKeyState(VK_F4))
  2415. {
  2416. commandExecute2("+right");
  2417. commandExecute2("+forward");
  2418.  
  2419. if (jumpspammer)
  2420. {
  2421. commandExecute2("+jump");
  2422. Sleep(20);
  2423. }
  2424.  
  2425. jumpspammer = !jumpspammer; // for the memes
  2426. }
  2427.  
  2428. if (GetAsyncKeyState(VK_F6))
  2429. {
  2430. commandExecute2("-right");
  2431. commandExecute2("-forward");
  2432. commandExecute2("-jump");
  2433. }
  2434.  
  2435. if ((pCmd->buttons & IN_JUMP) || !(pLocal->Flags() & FL_ONGROUND)) // pChecks
  2436. {
  2437. pCmd->forwardmove = move * 0.015f;
  2438. pCmd->sidemove += (float)(((pCmd->TickCount % 2) * 2) - 1) * s_move;
  2439.  
  2440. if (pCmd->mousedX)
  2441. pCmd->sidemove = (float)clamp(pCmd->mousedX, -1, 1) * s_move;
  2442.  
  2443. static float strafe = pCmd->viewangles.y;
  2444.  
  2445. float rt = pCmd->viewangles.y, rotation;
  2446. rotation = strafe - rt;
  2447.  
  2448. if (rotation < FloatNegate(pGlobals->interval_per_tick))
  2449. pCmd->sidemove = -s_move;
  2450.  
  2451. if (rotation > pGlobals->interval_per_tick)
  2452. pCmd->sidemove = s_move;
  2453.  
  2454. strafe = rt; // circlestrafer is gud i guess, but the math is pPaste ._.
  2455. }
  2456. }
  2457.  
  2458. void bTelehop(CUserCmd * cmd, C_BaseEntity * Local)
  2459. {
  2460. static bool bDirection = true;
  2461. static bool takethatshitoff = false;
  2462.  
  2463. if ((cmd->buttons & IN_JUMP) && (Local->Flags() & FL_ONGROUND))
  2464. {
  2465. cmd->forwardmove = 450; // thx to xer0, gaining to speed while beeing on the ground
  2466. }
  2467.  
  2468. if ((cmd->buttons & IN_JUMP) || !(Local->Flags() & FL_ONGROUND)) // pChecks
  2469. {
  2470. if (bDirection)
  2471. {
  2472. cmd->sidemove = -450.f; // -650 & 650 is P!
  2473. bDirection = false;
  2474. }
  2475. else
  2476. {
  2477. cmd->sidemove = +450.f; // -650 & 650 is P!
  2478. bDirection = true;
  2479. }
  2480. }
  2481. }
  2482.  
  2483. void teleporty(CUserCmd * cmd)
  2484. {
  2485. if (GetAsyncKeyState(VK_F1))
  2486. {
  2487. cmd->viewangles.y = 22249223532141231232143.949962143f; // oversized values can teleport you! 13:37 never forget.
  2488. cmd->viewangles.x = 22249223523413423454322345.9499621213f;
  2489. }
  2490. }
  2491.  
  2492. void crapcode() {}
  2493.  
  2494. void downvisualrecoil()
  2495. {
  2496. C_BaseEntity* Local = pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  2497. C_BaseCombatWeapon* pWeapon = Local->GetActive();
  2498. Vector *PunchVisualAngle;
  2499. Vector viewangles;
  2500. PunchVisualAngle = (Vector*)((DWORD)Local + 0x300C); // idk why im doin this! sw4g
  2501.  
  2502. /* UNSERE SIMPLER RETURN CHECK */
  2503.  
  2504. /*if (pWeapon->isSniper())
  2505. return;
  2506.  
  2507. if (pWeapon->isPistol())
  2508. return;
  2509.  
  2510. if (pWeapon->isShotgun())
  2511. return;*/
  2512.  
  2513. /* WE ARE GOING TO MINUS TO TAKE IT DOWN! */
  2514.  
  2515. *PunchVisualAngle -= Local->AimPunch() * 2;
  2516.  
  2517. /* CLAMPING AND NORMALISING OUR SHIT! */
  2518.  
  2519. ClampAngles(*PunchVisualAngle);
  2520. ClampAngles(viewangles); // clamping the full vector to be fully safe
  2521. NormalizeVector(viewangles); // normalizing the full vector to be fully safe
  2522. NormalizeVector(*PunchVisualAngle); // #creditstomyself
  2523. }
  2524.  
  2525. void sAirstuck(CUserCmd * cmd)
  2526. {
  2527. if (GetAsyncKeyState(VK_F1))
  2528. {
  2529. cmd->TickCount = 174522396;
  2530. }
  2531. }
  2532.  
  2533. void noflashON(C_BaseEntity * Local)
  2534. {
  2535. int m_flFlashMaxAlpha = 0xA2F4;
  2536. int m_flFlashDuration = 0xA2F8;
  2537.  
  2538. *MakePtr(float*, Local, m_flFlashDuration) = 0.4f;
  2539. *MakePtr(float*, Local, m_flFlashMaxAlpha) = 0.4f;
  2540. }
  2541.  
  2542. void noflashOFF(C_BaseEntity * Local)
  2543. {
  2544. int m_flFlashMaxAlpha = 0xA2F4;
  2545. int m_flFlashDuration = 0xA2F8;
  2546.  
  2547. *MakePtr(float*, Local, m_flFlashDuration) = 5100.0f;
  2548. *MakePtr(float*, Local, m_flFlashMaxAlpha) = 255.0f;
  2549. }
  2550.  
  2551. // MISC MEMES ENDS HERE BLYAT YO
  2552. //---------------------------------------------------------
  2553. // HOOKING & CO BEGINNS HERE FOR THE PREMIUM MEMEZ
  2554.  
  2555. void __stdcall FrameStageHook(ClientFrameStage_t curStage) {
  2556.  
  2557. C_BaseEntity* gLocal = pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  2558. if (pEngine->IsInGame() && pEngine->IsConnected() && gLocal)
  2559. {
  2560.  
  2561. Vector *PunchAngle, OldPunchAngle;
  2562. Vector *PunchVisualAngle, OldVisualAngle;
  2563.  
  2564. PunchAngle = (Vector*)((DWORD)gLocal + 0x3018);
  2565. PunchVisualAngle = (Vector*)((DWORD)gLocal + 0x300C);
  2566.  
  2567. if (misc_active.getValve() == 1)
  2568. {
  2569. if (curStage == FRAME_RENDER_START)
  2570. {
  2571. if (novisrecoil.getValve() == 1)
  2572. {
  2573. if (gLocal)
  2574. {
  2575. if (gLocal->Health() > 0)
  2576. {
  2577. if (gLocal->GetLifeState() == 0)
  2578. {
  2579. // if (!gWeapon->IsKnife() || gWeapon->IsBomb()) {
  2580. {
  2581. OldPunchAngle = *PunchAngle;
  2582. OldVisualAngle = *PunchVisualAngle;
  2583. *PunchAngle = Vector(0, 0, 0);
  2584. *PunchVisualAngle = Vector(0, 0, 0);
  2585. }
  2586. }
  2587. }
  2588. }
  2589. }
  2590. }
  2591. }
  2592.  
  2593. if (misc_active.getValve() == 1)
  2594. {
  2595. if (curStage == FRAME_RENDER_START)
  2596. {
  2597. if (Visualrecoil.getValve() == 1)
  2598. {
  2599. if (gLocal)
  2600. {
  2601. if (gLocal->Health() > 0)
  2602. {
  2603. if (gLocal->GetLifeState() == 0)
  2604. {
  2605. // if (!gWeapon->IsKnife() || gWeapon->IsBomb()) {
  2606. {
  2607. downvisualrecoil();
  2608. }
  2609. }
  2610. }
  2611. }
  2612. }
  2613. }
  2614. }
  2615.  
  2616. ClientHooked->Function<FrameStageNotify_t>(36)(curStage);
  2617.  
  2618. if (misc_active.getValve() == 1)
  2619. {
  2620. if (novisrecoil.getValve() == 1)
  2621. {
  2622. if (curStage == FRAME_RENDER_START)
  2623. {
  2624. if (gLocal)
  2625. {
  2626. if (gLocal->Health() > 0)
  2627. {
  2628. if (gLocal->GetLifeState() == 0)
  2629. {
  2630. if (PunchAngle->x == 0 || PunchAngle->y == 0 || PunchAngle->z == 0 || PunchVisualAngle->x == 0 || PunchVisualAngle->y == 0 || PunchVisualAngle->z == 0)
  2631. {
  2632. *PunchAngle = OldPunchAngle;
  2633. *PunchVisualAngle = OldVisualAngle;
  2634. }
  2635. }
  2636. }
  2637. }
  2638. }
  2639. }
  2640. if (fovactive.getValve() == 1)
  2641. {
  2642. fovchanger(gLocal);
  2643. }
  2644. }
  2645. }
  2646. }
  2647.  
  2648. void ProxyHook()
  2649. {
  2650. ClientClass *pClass = gpClient->GetAllClasses();
  2651. while (pClass)
  2652. {
  2653. const char *pszName = pClass->m_pRecvTable->m_pNetTableName;
  2654. if (!strcmp(pszName, "DT_CSPlayer"))
  2655. {
  2656. for (int i = 0; i < pClass->m_pRecvTable->m_nProps; i++)
  2657. {
  2658. RecvProp *pProp = &(pClass->m_pRecvTable->m_pProps[i]);
  2659. const char *name = pProp->m_pVarName;
  2660. }
  2661. }
  2662. }
  2663. }
  2664.  
  2665. void __fastcall hkPaintTraverse(void* ecx, void* edx, unsigned int vguiPanel, bool forceRepaint, bool allowForce)
  2666. {
  2667. PanelHook->Function<tPaintTraverse>(41)(ecx, vguiPanel, forceRepaint, allowForce);
  2668.  
  2669. const char* pszPanelName = pPanel->GetName(vguiPanel);
  2670. bool isValidPanel = false;
  2671. static bool xOnce = false;
  2672. float radius;
  2673.  
  2674. if (pszPanelName && pszPanelName[0] == 'M' && pszPanelName[3] == 'S' &&
  2675. pszPanelName[9] == 'T' && pszPanelName[12] == 'P')
  2676. isValidPanel = true;
  2677.  
  2678. if (isValidPanel)
  2679. {
  2680. if (!cOnce)
  2681. {
  2682.  
  2683. pEngine->GetScreenSize(width, height);
  2684.  
  2685. // FONTS
  2686.  
  2687. Watermarkfont = pSurface->CreateFontA();
  2688. pSurface->SetFontGlyphSet(Watermarkfont, "Geometeus_Rounded", 16, 800, 0, 0, FONTFLAG_OUTLINE);
  2689.  
  2690. // FONTS
  2691.  
  2692. pFont = pSurface->CreateFontA();
  2693. pSurface->SetFontGlyphSet(pFont, "Animal_Silence", 10, 800, 0, 0, FONTFLAG_OUTLINE); // NORMAL 12
  2694.  
  2695. // FONTS
  2696.  
  2697. Rosso = pSurface->CreateFontA();
  2698. pSurface->SetFontGlyphSet(Rosso, "Ferro_Rosso", 13, 800, 0, 0, FONTFLAG_OUTLINE);
  2699.  
  2700. // FONTS
  2701.  
  2702. Coture = pSurface->CreateFontA();
  2703. pSurface->SetFontGlyphSet(Coture, "Couture", 15, 800, 0, 0, FONTFLAG_OUTLINE);
  2704.  
  2705. // FONTS
  2706.  
  2707. PRIMETIME = pSurface->CreateFontA();
  2708. pSurface->SetFontGlyphSet(PRIMETIME, "Bebas_Neue", 30, 800, 0, 0, FONTFLAG_ANTIALIAS); // usual flag is outlined and timeline
  2709.  
  2710. // FONTS
  2711.  
  2712. blackfont = pSurface->CreateFontA();
  2713. pSurface->SetFontGlyphSet(blackfont, "TheBlackFont", 30, 800, 0, 0, FONTFLAG_OUTLINE);
  2714.  
  2715. // DO XMENU GRЦЯE
  2716.  
  2717. initMenu();
  2718. cOnce = true;
  2719.  
  2720. }
  2721.  
  2722. DrawMenu();
  2723. UpdateMenu();
  2724. GetCursorPos(&Cursor);
  2725.  
  2726. if (pEngine->IsConnected() && pEngine->IsInGame())
  2727. {
  2728. if (vis_active.getValve() == 1)
  2729. {
  2730.  
  2731. if (visbox.getValve() == 1)
  2732. {
  2733. AIMWAREESP();
  2734. }
  2735.  
  2736. if (vishealthbar.getValve() == 1)
  2737. {
  2738. AIMWAREHEALTH();
  2739. }
  2740.  
  2741. if (visname.getValve() == 1)
  2742. {
  2743. ESPNAME();
  2744. }
  2745.  
  2746. if (glow.getValve() == 1)
  2747. {
  2748. GLOWESP();
  2749. }
  2750.  
  2751. if (legitesp.getValve() == 1)
  2752. {
  2753. CORNERAAESP();
  2754. }
  2755.  
  2756. if (txthealth.getValve() == 1)
  2757. {
  2758. TXTHEALTH();
  2759. }
  2760.  
  2761. if (Armoresp.getValve() == 1)
  2762. {
  2763. TXTARMOR();
  2764. }
  2765.  
  2766. if (visibleesp.getValve() == 1)
  2767. {
  2768. ISVISIBLE();
  2769. }
  2770.  
  2771. if (wallbangesp.getValve() == 1)
  2772. {
  2773. WALLBANGESPY();
  2774. }
  2775.  
  2776. if (weaponsesp.getValve() == 1)
  2777. {
  2778. ESPWEAPON();
  2779. }
  2780.  
  2781. if (helmesp.getValve() == 1)
  2782. {
  2783. hashelmetESP();
  2784. }
  2785.  
  2786. if (flashedESP.getValve() == 1)
  2787. {
  2788. flashESP();
  2789. }
  2790.  
  2791. if (crosshair.getValve() == 1)
  2792. {
  2793. if (!MenuOpend)
  2794. {
  2795. visCrosshair();
  2796. }
  2797. }
  2798.  
  2799. if (recoilcrosshair.getValve() == 1)
  2800. {
  2801. if (!MenuOpend)
  2802. {
  2803. RecoilCrosshair();
  2804. }
  2805. }
  2806.  
  2807. if (edgeaa.getValve() == 1)
  2808. {
  2809. inEdge();
  2810. }
  2811. }
  2812. }
  2813.  
  2814. if (MenuOpend)
  2815. {
  2816. if (pEngine->IsConnected() && pEngine->IsInGame())
  2817. {
  2818. DrawpCursor(Cursor.x, Cursor.y);
  2819. }
  2820. }
  2821.  
  2822. if (GetAsyncKeyState(VK_LBUTTON) & 1)
  2823. {
  2824. onMouseClick();
  2825. }
  2826.  
  2827. if (GetAsyncKeyState(VK_LBUTTON))
  2828. {
  2829. onMouseHold();
  2830. }
  2831.  
  2832. if (vis_active.getValve() == 1)
  2833. {
  2834. if (watermark.getValve() == 1)
  2835. {
  2836. Watermarkyo();
  2837. }
  2838. }
  2839. }
  2840. }
  2841.  
  2842. bool __stdcall HookedCreateMove(float SampleTime, CUserCmd* pCmd)
  2843. {
  2844. if (!pCmd->CommandNumber)
  2845. return true;
  2846.  
  2847. C_BaseEntity* pEntity = pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  2848. C_BaseEntity* pLocal = pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  2849. C_BaseCombatWeapon* pWeapon = pLocal->GetActive();
  2850.  
  2851. if (!pLocal)
  2852. return false;
  2853.  
  2854. if (pLocal->Health() < 0)
  2855. return false;
  2856.  
  2857. if (!pLocal->GetLifeState() == 0)
  2858. return false;
  2859.  
  2860. for (int i = 1; i < pEntList->GetHighestEntityIndex(); i++) {
  2861.  
  2862. C_BaseEntity* Entity = (C_BaseEntity*)pEntList->GetClientEntity(i);
  2863.  
  2864. if (pEngine->IsInGame() && pEngine->IsConnected())
  2865. {
  2866.  
  2867. // SENDPACKET //
  2868.  
  2869. PVOID pebp;
  2870. __asm mov pebp, ebp;
  2871. bool* pbSendPacket = (bool*)(*(PDWORD)pebp - 0x1C);
  2872. bool& bSendPacket = *pbSendPacket;
  2873.  
  2874. // AUTOSTRAFER XCORRECTION //
  2875.  
  2876. if (misc_active.getValve() == 1)
  2877. {
  2878.  
  2879. if (autostrafer.getValve() == 1)
  2880. {
  2881. // GetAutostrafeView();
  2882. AutoStrafe(pCmd, pLocal);
  2883. }
  2884.  
  2885. if (antiuntrust.getValve() == 1 && telehop.getValve() == 1)
  2886. {
  2887. bTelehop(pCmd, pLocal);
  2888. }
  2889.  
  2890. if (antiaimactive.getValve() == 1)
  2891. {
  2892. if (antiaim.getValue() == 5 && pWeapon->isShootable2())
  2893. {
  2894. if (pCmd->buttons & IN_USE)
  2895. return;
  2896.  
  2897. casualaa(pCmd);
  2898. }
  2899. }
  2900.  
  2901. ClampAngles(pCmd->viewangles);
  2902. NormalizeVector(pCmd->viewangles);
  2903.  
  2904. }
  2905.  
  2906. // Aim goat memes //
  2907.  
  2908. if (aim_active.getValve() == 1)
  2909. {
  2910. Vector vMove(pCmd->forwardmove, pCmd->sidemove, pCmd->upmove);
  2911. float flSpeed = sqrt(vMove.x * vMove.x + vMove.y * vMove.y), flYaw;
  2912. Vector vMove2;
  2913. Vector vRealView(pCmd->viewangles);
  2914. Vector Hitbox;
  2915. VectorAngles3D(vMove, vMove2);
  2916.  
  2917. /*if (pWeapon->WeaponAmmo() < 1)
  2918. return;*/
  2919.  
  2920. if (aim_active.getValve() == 1 && aimonshoot.getValve() == 1)
  2921. {
  2922. if (GetAsyncKeyState(VK_LBUTTON)) { doAim(pCmd, bSendPacket); }
  2923. }
  2924.  
  2925. if (aim_active.getValve() == 1 && aimonshoot.getValve() == 0)
  2926. {
  2927. doAim(pCmd, bSendPacket);
  2928. }
  2929.  
  2930. flYaw = DEG2RAD(pCmd->viewangles.y - vRealView.y + vMove2.y);
  2931. pCmd->forwardmove = cos(flYaw) * flSpeed;
  2932. pCmd->sidemove = sin(flYaw) * flSpeed;
  2933. ClampAngles(pCmd->viewangles);
  2934. NormalizeVector(pCmd->viewangles);
  2935. }
  2936.  
  2937. if (aim_active.getValve() == 1 && aimonshoot.getValve() == 0 && autoduck.getValve() == 1)
  2938. {
  2939. /*if (pWeapon->WeaponAmmo() < 1)
  2940. return;*/
  2941.  
  2942. doAim(pCmd, bSendPacket);
  2943. }
  2944.  
  2945. if (Legitactive.getValve() == 1)
  2946. {
  2947. if (Triggerenable.getValve() == 1)
  2948. {
  2949.  
  2950. }
  2951.  
  2952. if (autopistolyo.getValve() == 1 && pWeapon->isPistol())
  2953. {
  2954. autopistol(pCmd);
  2955. }
  2956. }
  2957.  
  2958. /* Misc memes */
  2959.  
  2960. if (misc_active.getValve() == 1)
  2961. {
  2962.  
  2963. if (norecoil.getValve() == 1)
  2964. {
  2965. Misc2(pCmd, pLocal);
  2966. }
  2967.  
  2968. if (bunnyhop.getValve() == 1)
  2969. {
  2970. bhop(pCmd, pLocal);
  2971. }
  2972.  
  2973. if (namespam.getValve() == 1)
  2974. {
  2975. namespammer();
  2976. }
  2977.  
  2978. if (antiaimactive.getValve() == 1)
  2979. {
  2980. if (antiaim.getValue() == 1 && pWeapon->isShootable2())
  2981. {
  2982. if (pCmd->buttons & IN_USE)
  2983. return;
  2984.  
  2985. antimeme1ye(pCmd);
  2986. }
  2987.  
  2988. if (antiaim.getValue() == 2 && pWeapon->isShootable2())
  2989. {
  2990. if (pCmd->buttons & IN_USE)
  2991. return;
  2992.  
  2993. antimeme2ye(pCmd);
  2994. }
  2995.  
  2996. if (antiaim.getValue() == 3 && pWeapon->isShootable2())
  2997. {
  2998. if (pCmd->buttons & IN_USE)
  2999. return;
  3000.  
  3001. antimeme3ye(pCmd);
  3002. }
  3003.  
  3004. if (antiaim.getValue() == 4 && pWeapon->isShootable2())
  3005. {
  3006. if (pCmd->buttons & IN_USE)
  3007. return;
  3008.  
  3009. fakeedge(pCmd, bSendPacket);
  3010. }
  3011.  
  3012. if (edgeaa.getValve() == 1 && pLocal->GetVelocity().Length() < 5 && pWeapon->isShootable2())
  3013. {
  3014. if (pCmd->buttons & IN_USE)
  3015. return;
  3016.  
  3017. edge(pCmd, bSendPacket);
  3018. }
  3019.  
  3020. if (antiaim.getValue() == 6 && pWeapon->isShootable2())
  3021. {
  3022. if (pCmd->buttons & IN_USE)
  3023. return;
  3024.  
  3025. bJitter(pCmd);
  3026. }
  3027.  
  3028. if (antiaim.getValue() == 7 && pWeapon->isShootable2())
  3029. {
  3030. if (pCmd->buttons & IN_USE)
  3031. return;
  3032.  
  3033. fBackwards(pLocal, pCmd, bSendPacket);
  3034. }
  3035. }
  3036.  
  3037. if (fakelagon.getValve() == 1)
  3038. {
  3039. fakelag1(pLocal, bSendPacket);
  3040. }
  3041.  
  3042. if (RCS.getValve() == 1)
  3043. {
  3044. doRCS(pCmd, pLocal);
  3045. }
  3046.  
  3047. if (chatspam.getValve() == 1)
  3048. {
  3049. chatspamcounter();
  3050. }
  3051.  
  3052. if (servercraxxer.getValve() == 1)
  3053. {
  3054. servercrasher();
  3055. }
  3056.  
  3057. if (nonameexploit.getValve() == 1)
  3058. {
  3059. noname();
  3060. }
  3061.  
  3062. if (namesteal.getValve() == 1)
  3063. {
  3064. namestealer();
  3065. }
  3066.  
  3067. if (adaptivefakelag.getValve() == 1)
  3068. {
  3069. fakelagAdaptive(pLocal, bSendPacket);
  3070. }
  3071.  
  3072. if (randomfakelag.getValve() == 1)
  3073. {
  3074. fakelagRandom(pLocal, bSendPacket);
  3075. }
  3076.  
  3077. if (airstuck.getValve() == 1)
  3078. {
  3079. sAirstuck(pCmd);
  3080. }
  3081.  
  3082. if (fakeduck.getValve() == 1)
  3083. {
  3084. FakeDuck(pCmd, bSendPacket);
  3085. }
  3086.  
  3087. if (noflash.getValve() == 1)
  3088. {
  3089. noflashON(pLocal);
  3090. }
  3091. else if (noflash.getValve() == 0)
  3092. {
  3093. noflashOFF(pLocal);
  3094. }
  3095.  
  3096. ClampAngles(pCmd->viewangles);
  3097. NormalizeVector(pCmd->viewangles);
  3098.  
  3099. }
  3100.  
  3101. if (misc_active.getValve() == 1)
  3102. {
  3103. Vector origView = pCmd->viewangles;
  3104. Vector viewforward, viewright, viewup, aimforward, aimright, aimup;
  3105. Vector qAimAngles;
  3106. qAimAngles.Init(0.0f, pCmd->viewangles.y, 0.0f);
  3107. AngleVectors(qAimAngles, &viewforward, &viewright, &viewup);
  3108.  
  3109. if (antiuntrust.getValve() == 1 && teleport.getValve() == 1)
  3110. {
  3111. teleporty(pCmd);
  3112. }
  3113.  
  3114. if (antiaimactive.getValve() == 1)
  3115. {
  3116. if (antiuntrust.getValve() == 1 && antiaim.getValue() == 8)
  3117. {
  3118. if (pWeapon->IsKnife()) // cuz we are crashing if no
  3119. return;
  3120.  
  3121. ANGLELAFF(pCmd, bSendPacket);
  3122. }
  3123.  
  3124. if (antiuntrust.getValve() == 1 && antiaim.getValue() == 9)
  3125. {
  3126. mattiazangel(pCmd, bSendPacket);
  3127. }
  3128.  
  3129. if (antiuntrust.getValve() == 1 && antiaim.getValue() == 10)
  3130. {
  3131. newtick++;
  3132.  
  3133. if (newtick <= 6)
  3134. {
  3135. bSendPacket = false;
  3136. }
  3137. else
  3138. {
  3139. rekt1337(pCmd, bSendPacket);
  3140. newtick = 0;
  3141. }
  3142. }
  3143.  
  3144. if (antiuntrust.getValve() == 1 && antiaim.getValue() == 11)
  3145. {
  3146. fHead(pLocal, pCmd, bSendPacket);
  3147. }
  3148.  
  3149. if (antiuntrust.getValve() == 1 && antiaim.getValue() == 12)
  3150. {
  3151. fLisp(pLocal, pCmd, bSendPacket);
  3152. }
  3153. }
  3154.  
  3155. qAimAngles.Init(0.0f, pCmd->viewangles.y, 0.0f);
  3156. AngleVectors(qAimAngles, &aimforward, &aimright, &aimup);
  3157. Vector vForwardNorm; Normalize(viewforward, vForwardNorm);
  3158. Vector vRightNorm; Normalize(viewright, vRightNorm);
  3159. Vector vUpNorm; Normalize(viewup, vUpNorm);
  3160.  
  3161. float forward = pCmd->forwardmove;
  3162. float right = pCmd->sidemove;
  3163. float up = pCmd->upmove;
  3164. if (forward > 450) forward = 450;
  3165. if (right > 450) right = 450;
  3166. if (up > 450) up = 450;
  3167. if (forward < -450) forward = -450;
  3168. if (right < -450) right = -450;
  3169. if (up < -450) up = -450;
  3170. pCmd->forwardmove = DotProduct(forward * vForwardNorm, aimforward) + DotProduct(right * vRightNorm, aimforward) + DotProduct(up * vUpNorm, aimforward);
  3171. pCmd->sidemove = DotProduct(forward * vForwardNorm, aimright) + DotProduct(right * vRightNorm, aimright) + DotProduct(up * vUpNorm, aimright);
  3172. pCmd->upmove = DotProduct(forward * vForwardNorm, aimup) + DotProduct(right * vRightNorm, aimup) + DotProduct(up * vUpNorm, aimup);
  3173. }
  3174.  
  3175. if (antiuntrust.getValve() == 0)
  3176. {
  3177. NormalizeVector(pCmd->viewangles);
  3178. ClampAngles(pCmd->viewangles);
  3179. }
  3180. }
  3181. return false;
  3182. }
  3183. }
  3184.  
  3185. // HOOKING SHIT ENDS HERE
  3186. //---------------------------------------------------------
  3187. // HOOKING THE FEATS BEGINNS HERE
  3188.  
  3189. void clientmode()
  3190. {
  3191. void** BaseClientDllVMT = *(void***)pClient;
  3192. ClientMode = *(IClientMode***)((DWORD)BaseClientDllVMT[10] + 5);
  3193. }
  3194.  
  3195. void hookCM()
  3196. {
  3197. CreateMoveHook = new CVMTHook(*(DWORD***)ClientMode);
  3198. _CreateMove = (CreateMove2)CreateMoveHook->Hook((DWORD)HookedCreateMove, 24);
  3199. }
  3200.  
  3201. void hookPT()
  3202. {
  3203. PanelHook = new CVMTHook((DWORD**)pPanel);
  3204. PanelHook->Hook((DWORD)hkPaintTraverse, 41);
  3205. }
  3206.  
  3207. void hookFT()
  3208. {
  3209. ClientHooked = new CVMTHook((DWORD**)pClient);
  3210. ClientHooked->Hook((DWORD)FrameStageHook, 36);
  3211. }
  3212.  
  3213. // HOOKING THE FEATS ENDS HERE
  3214. //---------------------------------------------------------
  3215. // SIMPLE MSG SHIT STARTS HERE!
  3216.  
  3217. void __cdecl Msg(char const* msg, ...)
  3218. {
  3219. static MsgFn oMsg = (MsgFn)GetProcAddress(GetModuleHandleA("tier0.dll"), "Msg");
  3220. char buffer[989];
  3221. va_list list;
  3222. va_start(list, msg);
  3223. vsprintf(buffer, msg, list);
  3224. va_end(list);
  3225. oMsg(buffer, list);
  3226. }
  3227.  
  3228. void permaclean_console()
  3229. {
  3230. static bool permclean = false;
  3231.  
  3232. if (permclean)
  3233. {
  3234. pEngine->ExecuteClientCmd("clear");
  3235. }
  3236.  
  3237. permclean = !permclean;
  3238. }
  3239.  
  3240. // SIMPLE MSGBOX FOR THE INGM CONSOLE ENDS HERE!
  3241. //---------------------------------------------------------
  3242. // HOOKING THE HOOKS WE MADE BEFORE HERE!
  3243.  
  3244. DWORD WINAPI APPLYHooks(LPVOID lpArguments)
  3245. {
  3246. hwCSGO = FindWindowA(NULL, "Counter-Strike: Global Offensive");
  3247.  
  3248. AllocConsole();
  3249. freopen("CONOUT$", "w", stdout);
  3250.  
  3251. INTERFACES();
  3252.  
  3253. pEngine->ExecuteClientCmd("clear");
  3254. Msg("zer0ine // BY RFX");
  3255. Msg("\nzer0ine // LOADED!");
  3256.  
  3257. hookPT();
  3258. cout << " PANEL HOOK -> " << PanelHook << endl << " HOOKED PANEL -> " << PanelHook->Hook((DWORD)hkPaintTraverse, 41) << endl;
  3259.  
  3260. hookFT();
  3261. cout << " CLIENT -> FRAMESTAGE -> " << ClientHooked->Hook((DWORD)FrameStageHook, 36) << endl;
  3262.  
  3263. clientmode();
  3264. cout << " CLIENTMODE -> " << ClientMode << endl; // for the style :3
  3265.  
  3266. hookCM();
  3267. cout << " CREATEMOVE -> " << (CreateMove2)CreateMoveHook->Hook((DWORD)HookedCreateMove, 24) << endl; // for the style :3 aswell
  3268.  
  3269. ProxyHook();
  3270.  
  3271. cout << "" << endl;
  3272. cout << " REFLEX'S PRIVATE HAKE LOADED BESTE! " << endl;
  3273. cout << " For PSILENT only use FOV 1 it could shake! " << endl;
  3274. cout << " Edge antiaim, is only working per Velocity! " << endl;
  3275. cout << " If you wanna use RCS with fov > 1, use Norecoil + Visrecoil. " << endl;
  3276.  
  3277. PDWORD pdwClient = (PDWORD)*(PDWORD)pClient;
  3278. DWORD dwInitAddr = (DWORD)(pdwClient[0]);
  3279.  
  3280. for (DWORD dwIter = 0; dwIter <= 0xFF; dwIter++) {
  3281. if (*(PBYTE)(dwInitAddr + dwIter) == 0xA3) {
  3282. pGlobals = (CGlobalVarsBase*)*(PDWORD)*(PDWORD)(dwInitAddr + dwIter + 1);
  3283.  
  3284. break;
  3285. }
  3286. }
  3287. return false;
  3288. }
  3289.  
  3290. // OUR APPLYHOOK SHIT ENDS HERE
  3291. //---------------------------------------------------------
  3292. // APPLYING OR HOOKS TO THE GAME BEGINNS HERE + SECURITY
  3293.  
  3294. float DllMain(HINSTANCE hinst, DWORD dwReason, LPVOID lpReserved) {
  3295. if (dwReason == DLL_PROCESS_ATTACH) {
  3296.  
  3297. CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)ThreadHiding, NULL, NULL, NULL);
  3298. CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)debuggkiller, NULL, NULL, NULL);
  3299.  
  3300. AllocConsole();
  3301.  
  3302. SetConsoleTitleA("zer0ine // Private Build");
  3303.  
  3304. freopen("CONIN$", "r", stdin);
  3305. freopen("CONOUT$", "w", stdout);
  3306. freopen("CONOUT$", "w", stderr);
  3307.  
  3308. const string USERNAME = "blaz3rin0";
  3309. const string PASSWORD = "pr0coder";
  3310. string username, password;
  3311.  
  3312. cout << " ENTER USERNAME : ";
  3313.  
  3314. cin >> username;
  3315.  
  3316. if (username.length() < 4)
  3317. {
  3318. cout << " USERNAME MUST BE ATLEAST 4 CHARACTERS LONG.";
  3319.  
  3320. ExitProcess(0);
  3321. }
  3322. else
  3323. {
  3324. cout << " ENTER PASSWORD : ";
  3325.  
  3326. cin >> password;
  3327. cout << "" << endl;
  3328.  
  3329. if (password.length() < 6)
  3330. {
  3331. cout << "PASSWORD MUST BE ATLEAST 6 CHARACTERS LONG.";
  3332.  
  3333. ExitProcess(0);
  3334. }
  3335. else
  3336. {
  3337. if (username == USERNAME && password == PASSWORD)
  3338. {
  3339. cout << " LOGIN SUCCESS!" << endl;
  3340. cout << "____________________________________________" << endl;
  3341. cout << "" << endl;
  3342.  
  3343. if (hwid->hwidCheck(0x9C5FD31E)) {
  3344.  
  3345. polymorph *pmorph;
  3346.  
  3347. Rectangley rec(10, 7);
  3348. Triangle tri(10, 5);
  3349.  
  3350. pmorph = &rec;
  3351. pmorph->area();
  3352.  
  3353. pmorph = &tri;
  3354. pmorph->area();
  3355.  
  3356. Virtual_Holder * vh = new Definition_Holder();
  3357.  
  3358. CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)APPLYHooks, NULL, NULL, NULL);
  3359.  
  3360. cout << " UR HARDWAREID DOES MATCH! " << endl;
  3361. cout << "____________________________________________" << endl;
  3362. cout << "" << endl;
  3363.  
  3364. }
  3365. }
  3366. else
  3367. {
  3368. cout << " IM SORRY! nice try :^)" << endl;
  3369. cout << "____________________________________________" << endl;
  3370. cout << "" << endl;
  3371.  
  3372. ExitProcess(0);
  3373. }
  3374. }
  3375. return true;
  3376. }
  3377. }
  3378. }
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!