API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 3rd, 2015
251
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 38.78 KB | None | 0 0
raw download clone embed print report
  1. #include <Windows.h>
  2. #include <Ntsecapi.h>
  3. #include "inj_defs.h"
  4.  
  5. DWORD WINAPI InjectThread (LPVOID lpParam)
  6. {
  7. DllInjectData *pInfo = (DllInjectData*) lpParam;
  8. ExitThreadType pExitThread = (ExitThreadType)pInfo->pExitThread;
  9. GetStdHandleType pGetStdHandle = (GetStdHandleType)pInfo->pGetStdHandle;
  10. GetCurrentProcessIdType pGetCurrentProcessId = (GetCurrentProcessIdType)pInfo->pGetCurrentProcessId;
  11. CreateFileAType pCreateFileA = (CreateFileAType)pInfo->pCreateFileA;
  12. SleepType pSleep = (SleepType)pInfo->pSleep;
  13. itoaType pitoa = (itoaType)pInfo->pitoa;
  14. GetAsyncKeyStateType pGetAsyncKeyState = (GetAsyncKeyStateType)pInfo->pGetAsyncKeyState;
  15. sscanf_sType psscanf_s = (sscanf_sType)pInfo->psscanf_s;
  16. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  17.  
  18. bool Cyclefunc(DllInjectData *, HANDLE *, char*);
  19. void InitModules(DllInjectData *pInfo);
  20. void C_Config_LoadSettings(DllInjectData *);
  21. void _GetPrivateProfileStringF(DllInjectData *, LPCSTR , LPCSTR , float *, LPCSTR );
  22. void _GetPrivateProfileStringI(DllInjectData *, LPCSTR , LPCSTR , int *, LPCSTR );
  23. int elapsedTime(DWORD *sTimer, DWORD *sTaTimer, DWORD *eNtTimer, DllInjectData *pInfo);
  24. void Timer(DWORD *sTimer, DWORD *sTaTimer, DllInjectData *pInfo);
  25. void NormaaliAnglet( float angle[], DllInjectData *pInfo);
  26. bool arctg (float* arg, float *ret, DllInjectData *pInfo);
  27. bool arccos (float* arg, float *ret, DllInjectData *pInfo);
  28. bool GE (float* arg1, float* arg2, DllInjectData *pInfo );
  29. bool IL (float* arg1, float* arg2, DllInjectData *pInfo );
  30. bool IG (float* arg1, float* arg2, DllInjectData *pInfo );
  31. int toInt (float* arg, DllInjectData *pInfo);
  32. bool toFloat(int arg, float *ret, DllInjectData *pInfo);
  33.  
  34.  
  35. //Classes
  36. class Vector
  37. {
  38. public:
  39. float x, y, z;
  40. memcpyType pmemcpy;
  41.  
  42. Vector( void )
  43. {
  44. }
  45.  
  46. Vector( float *pX, float *pY, float *pZ, DllInjectData *pInfo)
  47. {
  48. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  49. pmemcpy(&(this->x),pX,sizeof(float));
  50. pmemcpy(&(this->y),pY,sizeof(float));
  51. pmemcpy(&(this->z),pZ,sizeof(float));
  52. }
  53.  
  54. Vector( float args[ 3 ] , DllInjectData *pInfo)
  55. {
  56. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  57. pmemcpy(&(this->x),&(args[ 0 ]),sizeof(float));
  58. pmemcpy(&(this->y),&(args[ 1 ]),sizeof(float));
  59. pmemcpy(&(this->z),&(args[ 2 ]),sizeof(float));
  60. }
  61.  
  62. Vector( Vector *v, DllInjectData *pInfo )
  63. {
  64. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  65. pmemcpy(&(this->x),&(v->x),sizeof(float));
  66. pmemcpy(&(this->y),&(v->y),sizeof(float));
  67. pmemcpy(&(this->z),&(v->z),sizeof(float));
  68. }
  69. };
  70.  
  71. class CMath
  72. {
  73. public:
  74. void MakeVector(float *pfIn, float *pfOut, DllInjectData *pInfo)
  75. {
  76. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  77.  
  78. float pitchasm;
  79. float yawasm;
  80. float tmpasm;
  81.  
  82. float f180;
  83. pmemcpy(&f180,&(pInfo->t180),sizeof(float));
  84.  
  85. float pfIn0;
  86. pmemcpy(&pfIn0,&(pfIn[0]),sizeof(float));
  87.  
  88. float pfIn1;
  89. pmemcpy(&pfIn1,&(pfIn[1]),sizeof(float));
  90.  
  91. _asm
  92. {
  93. fldpi
  94. fmul pfIn0
  95. fdiv f180
  96. fstp pitchasm
  97. }
  98.  
  99. _asm
  100. {
  101. fldpi
  102. fmul pfIn1
  103. fdiv f180
  104. fstp yawasm
  105. }
  106.  
  107. _asm
  108. {
  109. fld pitchasm
  110. fcos
  111. fstp tmpasm
  112. }
  113.  
  114. float pfOut0,pfOut1,pfOut2;
  115. float mone;
  116. pmemcpy(&mone,&(pInfo->n1),sizeof(float));
  117.  
  118. _asm
  119. {
  120. fld yawasm
  121. fcos
  122. fmul mone
  123. fstp pfOut0
  124. fld tmpasm
  125. fmul mone
  126. fmul pfOut0
  127. fstp pfOut0
  128. }
  129.  
  130. _asm
  131. {
  132. fld yawasm
  133. fsin
  134. fmul tmpasm
  135. fstp pfOut1
  136. }
  137.  
  138. _asm
  139. {
  140. fld pitchasm
  141. fsin
  142. fmul mone
  143. fstp pfOut2
  144. }
  145.  
  146. pmemcpy(&(pfOut[0]),&pfOut0,sizeof(float));
  147. pmemcpy(&(pfOut[1]),&pfOut1,sizeof(float));
  148. pmemcpy(&(pfOut[2]),&pfOut2,sizeof(float));
  149.  
  150. return;
  151. }
  152.  
  153. void CalcAngle( float *src, float *dst, float *angles, DllInjectData *pInfo )
  154. {
  155. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  156. float delta0, delta1, delta2;
  157. float src0,src1,src2;
  158. pmemcpy(&src0,&(src[0]),sizeof(float));
  159. pmemcpy(&src1,&(src[1]),sizeof(float));
  160. pmemcpy(&src2,&(src[2]),sizeof(float));
  161. float dst0,dst1,dst2;
  162. pmemcpy(&dst0,&(dst[0]),sizeof(float));
  163. pmemcpy(&dst1,&(dst[1]),sizeof(float));
  164. pmemcpy(&dst2,&(dst[2]),sizeof(float));
  165.  
  166. _asm
  167. {
  168. fld src0
  169. fsub dst0
  170. fstp delta0
  171. fld src1
  172. fsub dst1
  173. fstp delta1
  174. fld src2
  175. fsub dst2
  176. fstp delta2
  177. }
  178.  
  179. float hyp;
  180.  
  181. _asm
  182. {
  183. fld delta0
  184. fmul delta0
  185. fstp hyp
  186. fld delta1
  187. fmul delta1
  188. fadd hyp
  189. fsqrt
  190. fstp hyp
  191. }
  192.  
  193. float angles0;
  194.  
  195. _asm
  196. {
  197. fld delta2
  198. fdiv hyp
  199. fstp angles0
  200. fpatan
  201. }
  202.  
  203. arctg (&angles0, &angles0, pInfo);
  204. float M_RADPI;
  205. pmemcpy(&M_RADPI,&(pInfo->M_RADPI),sizeof(float));
  206.  
  207. _asm
  208. {
  209. fld angles0
  210. fmul M_RADPI
  211. fstp angles0
  212. }
  213.  
  214. float angles1;
  215.  
  216. _asm
  217. {
  218. fld delta1
  219. fdiv delta0
  220. fstp angles1
  221. }
  222.  
  223. arctg (&angles1, &angles1, pInfo);
  224.  
  225. _asm
  226. {
  227. fld angles1
  228. fmul M_RADPI
  229. fstp angles1
  230. }
  231.  
  232. float t0;
  233.  
  234. _asm
  235. {
  236. fldz
  237. fstp t0
  238. }
  239.  
  240. if (GE(&delta0, &t0, pInfo))
  241. {
  242. float t180;
  243. pmemcpy (&t180, &(pInfo->t180),sizeof(float));
  244.  
  245. _asm
  246. {
  247. fld angles1
  248. fadd t180;
  249. fstp angles1
  250. }
  251. }
  252.  
  253. pmemcpy(&(angles[0]),&angles0,sizeof(float));
  254. pmemcpy(&(angles[1]),&angles1,sizeof(float));
  255. pmemcpy(&(angles[2]),&t0,sizeof(float));
  256.  
  257. return;
  258. }
  259.  
  260. bool GetFOV( float *angle, float *src, float *dst, float* pFov, DllInjectData *pInfo)
  261. {
  262. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  263.  
  264. float ang[3],aim[3];
  265. float fov;
  266.  
  267. CalcAngle(src, dst, ang, pInfo);
  268. MakeVector(angle, aim, pInfo);
  269. MakeVector(ang, ang, pInfo);
  270.  
  271. float t0,t1;
  272. float mag_s;
  273. float aim0,aim1,aim2;
  274.  
  275. pmemcpy(&aim0,&(aim[0]),sizeof(float));
  276. pmemcpy(&aim1,&(aim[1]),sizeof(float));
  277. pmemcpy(&aim2,&(aim[2]),sizeof(float));
  278.  
  279. _asm
  280. {
  281. fld aim0
  282. fmul aim0
  283. fstp t0
  284. fld aim1
  285. fmul aim1
  286. fstp t1
  287. fld aim2
  288. fmul aim2
  289. fadd t1
  290. fadd t0
  291. fsqrt
  292. fstp mag_s
  293. }
  294.  
  295. float mag_d;
  296. pmemcpy(&mag_d,&mag_s,sizeof(float));
  297.  
  298. float u_dot_v;
  299. float ang0,ang1,ang2;
  300. pmemcpy(&ang0,&(ang[0]),sizeof(float));
  301. pmemcpy(&ang1,&(ang[1]),sizeof(float));
  302. pmemcpy(&ang2,&(ang[2]),sizeof(float));
  303.  
  304. _asm
  305. {
  306. fld aim0
  307. fmul ang0
  308. fstp u_dot_v
  309. fld aim1
  310. fmul ang1
  311. fadd u_dot_v
  312. fstp u_dot_v
  313. fld aim2
  314. fmul ang2
  315. fadd u_dot_v
  316. fstp u_dot_v
  317. }
  318.  
  319. _asm
  320. {
  321. fld mag_s
  322. fmul mag_d
  323. fstp fov
  324. fld u_dot_v
  325. fdiv fov
  326. fstp fov
  327. }
  328.  
  329. arccos(&fov, &fov, pInfo);
  330.  
  331. float t180;
  332. float M_PI; pmemcpy(&M_PI,&(pInfo->M_PI),sizeof(float));
  333. pmemcpy(&t180, &(pInfo->t180), sizeof(float));
  334.  
  335. _asm
  336. {
  337. fld t180
  338. fdiv M_PI
  339. fmul fov
  340. fstp fov
  341. }
  342.  
  343. pmemcpy(pFov, &fov, sizeof(float));
  344.  
  345. return true;
  346. }
  347.  
  348. void Smooth(float *src, float *back, float *LocalAngles, int smooth, DllInjectData *pInfo)
  349. {
  350. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  351. float smoothdiff0,smoothdiff1;
  352. float src0,src1;
  353. pmemcpy(&src0,&(src[0]),sizeof(float));
  354. pmemcpy(&src1,&(src[1]),sizeof(float));
  355.  
  356. float LocalAngles0,LocalAngles1;
  357. pmemcpy(&LocalAngles0,&(LocalAngles[0]),sizeof(float));
  358. pmemcpy(&LocalAngles1,&(LocalAngles[1]),sizeof(float));
  359.  
  360. _asm
  361. {
  362. fld src0
  363. fsub LocalAngles0
  364. fstp src0
  365. }
  366.  
  367. _asm
  368. {
  369. fld src1
  370. fsub LocalAngles1
  371. fstp src1
  372. }
  373.  
  374. float f360;
  375. pmemcpy(&f360,&(pInfo->t360),sizeof(float));
  376.  
  377. float f180;
  378. pmemcpy(&f180,&(pInfo->t180),sizeof(float));
  379.  
  380. if (IG(&src0, &f180,pInfo))
  381. {
  382. _asm
  383. {
  384. fld src0
  385. fsub f360
  386. fstp src0
  387. }
  388. }
  389.  
  390. if (IG(&src1, &f180,pInfo))
  391. {
  392. _asm
  393. {
  394. fld src1
  395. fsub f360
  396. fstp src1
  397. }
  398. }
  399.  
  400. float n180;
  401. pmemcpy(&n180, &(pInfo->n180), sizeof(float));
  402.  
  403. if (IL(&src0, &n180,pInfo))
  404. {
  405. _asm
  406. {
  407. fld src0
  408. fadd f360
  409. fstp src0
  410. }
  411. }
  412.  
  413. if (IL(&src1, &n180,pInfo))
  414. {
  415. _asm
  416. {
  417. fld src1
  418. fadd f360
  419. fstp src1
  420. }
  421. }
  422.  
  423. float fsmooth;
  424. toFloat(smooth,&fsmooth,pInfo);
  425.  
  426. _asm
  427. {
  428. fld src0
  429. fdiv fsmooth
  430. fstp smoothdiff0
  431. }
  432.  
  433. _asm
  434. {
  435. fld src1
  436. fdiv fsmooth
  437. fstp smoothdiff1
  438. }
  439.  
  440. float back0,back1,back2;
  441.  
  442. _asm
  443. {
  444. fld LocalAngles0
  445. fadd smoothdiff0
  446. fstp back0
  447. }
  448.  
  449. _asm
  450. {
  451. fld LocalAngles1
  452. fadd smoothdiff1
  453. fstp back1
  454. }
  455.  
  456. if (IG(&back0, &f180,pInfo))
  457. {
  458. _asm
  459. {
  460. fld back0
  461. fsub f360
  462. fstp back0
  463. }
  464. }
  465.  
  466. if (IG(&back1, &f180,pInfo))
  467. {
  468. _asm
  469. {
  470. fld back1
  471. fsub f360
  472. fstp back1
  473. }
  474. }
  475.  
  476. if (IL(&back0, &n180,pInfo))
  477. {
  478. _asm
  479. {
  480. fld back0
  481. fadd f360
  482. fstp back0
  483. }
  484. }
  485.  
  486. if (IL(&back1, &n180, pInfo))
  487. {
  488. _asm
  489. {
  490. fld back1
  491. fadd f360
  492. fstp back1
  493. }
  494. }
  495.  
  496. pmemcpy(&(src[0]),&src0,sizeof(float));
  497. pmemcpy(&(src[1]),&src1,sizeof(float));
  498. pmemcpy(&(back[0]),&back0,sizeof(float));
  499. pmemcpy(&(back[1]),&back1,sizeof(float));
  500. pmemcpy(&(back[2]),&(LocalAngles[2]),sizeof(float));
  501.  
  502. return;
  503. }
  504. };
  505.  
  506. class C_LocalBase
  507. {
  508. public:
  509.  
  510. DWORD dwEntity;
  511.  
  512. C_LocalBase()
  513. {
  514. dwEntity = 0;
  515. }
  516.  
  517. C_LocalBase(DllInjectData *pInfo)
  518. {
  519. dwEntity = 0;
  520. dwEntity = *(DWORD*)(pInfo->Client + Ad_LocalEntity);
  521. }
  522.  
  523. int GetHealth()
  524. {
  525. int m_iHealth = 100;
  526. m_iHealth = *(int*)(dwEntity + Ad_Health);
  527. return m_iHealth;
  528. }
  529.  
  530. int GetTeam()
  531. {
  532. int m_iTeam;
  533. m_iTeam = *(int*)(dwEntity + Ad_Team);
  534. return m_iTeam;
  535. }
  536. };
  537.  
  538. class C_EntityBase
  539. {
  540. public:
  541. DWORD dwEntity;
  542.  
  543. C_EntityBase(int index,DllInjectData *pInfo)
  544. {
  545. dwEntity = 0;
  546. dwEntity = *(DWORD*)(pInfo->Client + Ad_Entity + index * 0x10);
  547. };
  548.  
  549. int GetHealth()
  550. {
  551. int m_iHealth;
  552. m_iHealth = *(int*)(dwEntity + Ad_Health);
  553. return m_iHealth;
  554. };
  555.  
  556. int GetTeam()
  557. {
  558. int m_iTeam;
  559. m_iTeam = *(int*)(dwEntity + Ad_Team);
  560. return m_iTeam;
  561. };
  562.  
  563. bool IsDormant()
  564. {
  565. bool m_bDormant;
  566. m_bDormant = *(bool*)(dwEntity + Ad_Dor);
  567. return m_bDormant;
  568. };
  569.  
  570. BYTE Getlifestate()
  571. {
  572. BYTE m_lifestate;
  573. m_lifestate = *(BYTE*)(dwEntity + Ad_Lifestate);
  574. return m_lifestate;
  575. };
  576. };
  577.  
  578. class C_Aimbot
  579. {
  580. public:
  581. int ClosestFov(CMath *cMat,Vector *EntityPos,DllInjectData *pInfo)
  582. {
  583. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  584.  
  585. C_LocalBase LocalEntity(pInfo);
  586.  
  587. float MaxDist;
  588. int ClosestID = 0;
  589.  
  590. if(!LocalEntity.dwEntity)
  591. return -1;
  592.  
  593. pmemcpy (&MaxDist,&(pInfo->t_MaxDist),sizeof(float));
  594.  
  595. for(int i = 0; i < 64; i++)
  596. {
  597. C_EntityBase EntityList(i,pInfo);
  598.  
  599. if(EntityList.dwEntity != NULL)
  600. {
  601. if(EntityList.dwEntity == LocalEntity.dwEntity)
  602. continue;
  603.  
  604. if(EntityList.GetHealth() < 1)
  605. continue;
  606.  
  607. if(EntityList.Getlifestate() != 0)
  608. continue;
  609.  
  610. if(EntityList.IsDormant() != 0)
  611. continue;
  612.  
  613. if(EntityList.GetTeam() == LocalEntity.GetTeam())
  614. continue;
  615.  
  616.  
  617. float x,y,z,x2,y2,z2;
  618.  
  619. Vector Bone( &(pInfo->t0),&(pInfo->t0),&(pInfo->t0),pInfo );
  620.  
  621. DWORD dwBone = *(DWORD*)(EntityList.dwEntity + 0xA78);
  622.  
  623. pmemcpy(&x,(float*)(dwBone + (0x30 * (pInfo->C_Conf_Aim_Hitbox)) + 0x0C),sizeof(float));
  624. pmemcpy(&y,(float*)(dwBone + (0x30 * (pInfo->C_Conf_Aim_Hitbox)) + 0x1C),sizeof(float));
  625. pmemcpy(&z,(float*)(dwBone + (0x30 * (pInfo->C_Conf_Aim_Hitbox)) + 0x2C),sizeof(float));
  626.  
  627. toFloat(pInfo->C_Conf_Aim_Height, &z2,pInfo);
  628.  
  629. _asm
  630. {
  631. fld z
  632. fadd z2
  633. fstp z
  634. }
  635.  
  636. Vector EntityPosTwo (&x, &y, &z,pInfo);
  637. Vector* MyPosOne =(Vector*) (LocalEntity.dwEntity+Ad_Origin);
  638.  
  639. pmemcpy(&x, &(MyPosOne->x) ,sizeof(float));
  640. pmemcpy(&y, &(MyPosOne->y) ,sizeof(float));
  641. pmemcpy(&z, &(MyPosOne->z) ,sizeof(float));
  642.  
  643. Vector* MyPosTwo =(Vector*) (LocalEntity.dwEntity+Ad_ViewOrig);
  644.  
  645. pmemcpy(&x2, &(MyPosTwo->x) ,sizeof(float));
  646. pmemcpy(&y2, &(MyPosTwo->y) ,sizeof(float));
  647. pmemcpy(&z2, &(MyPosTwo->z) ,sizeof(float));
  648.  
  649. _asm
  650. {
  651. fld x
  652. fadd x2
  653. fstp x
  654. fld y
  655. fadd y2
  656. fstp y
  657. fld z
  658. fadd z2
  659. fstp z
  660. }
  661.  
  662. Vector EyePosition(&x,&y,&z,pInfo);
  663.  
  664. DWORD pEngine;
  665. pEngine = *(DWORD*)(pInfo->Engine + Ad_EnginePointer);
  666. Vector *t = (Vector*)(pEngine + Ad_ViewAngles);
  667.  
  668. pmemcpy(&x, &(t->x), sizeof(float));
  669. pmemcpy(&y, &(t->y), sizeof(float));
  670. pmemcpy(&z, &(t->z), sizeof(float));
  671.  
  672. Vector MyAngles(&x,&y,&z,pInfo);
  673.  
  674.  
  675. float temp;
  676. float angle[3], src[3], dst[3];
  677.  
  678. pmemcpy(&(angle[0]), &(MyAngles.x),sizeof(float));
  679. pmemcpy(&(angle[1]), &(MyAngles.y),sizeof(float));
  680. pmemcpy(&(angle[2]), &(MyAngles.z),sizeof(float));
  681.  
  682. pmemcpy(&(src[0]), &(EyePosition.x),sizeof(float));
  683. pmemcpy(&(src[1]), &(EyePosition.y),sizeof(float));
  684. pmemcpy(&(src[2]), &(EyePosition.z),sizeof(float));
  685.  
  686. pmemcpy(&(dst[0]), &(EntityPosTwo.x),sizeof(float));
  687. pmemcpy(&(dst[1]), &(EntityPosTwo.y),sizeof(float));
  688. pmemcpy(&(dst[2]), &(EntityPosTwo.z),sizeof(float));
  689.  
  690. cMat->GetFOV(angle, src, dst, &temp, pInfo);
  691.  
  692. float tC_Conf_Aim_Fov;
  693.  
  694. toFloat(pInfo->C_Conf_Aim_Fov, &tC_Conf_Aim_Fov, pInfo);
  695.  
  696. if( IG(&temp, &tC_Conf_Aim_Fov, pInfo) )
  697. continue;
  698.  
  699. if( IL(&temp, &MaxDist, pInfo) )
  700. {
  701. ClosestID = i;
  702.  
  703. pmemcpy (&MaxDist,&temp,sizeof(float));
  704. pmemcpy (&(EntityPos->x),&(EntityPosTwo.x),sizeof(float));
  705. pmemcpy (&(EntityPos->y),&(EntityPosTwo.y),sizeof(float));
  706. pmemcpy (&(EntityPos->z),&(EntityPosTwo.z),sizeof(float));
  707. }
  708. }
  709. }
  710.  
  711. return ClosestID;
  712. }
  713.  
  714. void Aimbot(CMath *cMat,Vector *EntityPos, Vector *AimAngles, DWORD *sTimer, DWORD *sTaTimer, DWORD *eNtTimer, DllInjectData *pInfo)
  715. {
  716. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  717.  
  718. C_LocalBase LocalEntity(pInfo);
  719.  
  720. if(!LocalEntity.dwEntity)
  721. return;
  722.  
  723. GetAsyncKeyStateType pGetAsyncKeyState = (GetAsyncKeyStateType)pInfo->pGetAsyncKeyState;
  724.  
  725. if(pGetAsyncKeyState(pInfo->C_Conf_Aim_Key))
  726. {
  727. int EntityID = ClosestFov(cMat,EntityPos,pInfo);
  728.  
  729. if(EntityID < 1)
  730. return;
  731.  
  732. C_EntityBase Entity(EntityID,pInfo);
  733.  
  734. if(!Entity.dwEntity)
  735. return;
  736.  
  737. if (*sTimer == 0)
  738. Timer(sTimer, sTaTimer, pInfo);
  739.  
  740. if (elapsedTime(sTimer, sTaTimer, eNtTimer, pInfo) > pInfo->C_Conf_Aim_Time )
  741. return;
  742.  
  743. float x,y,z,x2,y2,z2;
  744.  
  745. Vector* MyPosOne =(Vector*) (LocalEntity.dwEntity+Ad_Origin);
  746.  
  747. pmemcpy(&x, &(MyPosOne->x) ,sizeof(float));
  748. pmemcpy(&y, &(MyPosOne->y) ,sizeof(float));
  749. pmemcpy(&z, &(MyPosOne->z) ,sizeof(float));
  750.  
  751. Vector* MyPosTwo =(Vector*) (LocalEntity.dwEntity+Ad_ViewOrig);
  752.  
  753. pmemcpy(&x2, &(MyPosTwo->x) ,sizeof(float));
  754. pmemcpy(&y2, &(MyPosTwo->y) ,sizeof(float));
  755. pmemcpy(&z2, &(MyPosTwo->z) ,sizeof(float));
  756.  
  757. _asm
  758. {
  759. fld x
  760. fadd x2
  761. fstp x
  762. fld y
  763. fadd y2
  764. fstp y
  765. fld z
  766. fadd z2
  767. fstp z
  768. }
  769.  
  770. Vector EyePosition(&x,&y,&z,pInfo);
  771.  
  772. float angle[3];
  773. float src[3], dst[3];
  774.  
  775. pmemcpy(&(src[0]), &(EyePosition.x),sizeof(float));
  776. pmemcpy(&(src[1]), &(EyePosition.y),sizeof(float));
  777. pmemcpy(&(src[2]), &(EyePosition.z),sizeof(float));
  778.  
  779. pmemcpy(&(dst[0]), &(EntityPos->x),sizeof(float));
  780. pmemcpy(&(dst[1]), &(EntityPos->y),sizeof(float));
  781. pmemcpy(&(dst[2]), &(EntityPos->z),sizeof(float));
  782.  
  783. cMat->CalcAngle(src,dst,angle,pInfo);
  784.  
  785. pmemcpy(&(AimAngles->x), &(angle[0]),sizeof(float));
  786. pmemcpy(&(AimAngles->y), &(angle[1]),sizeof(float));
  787. pmemcpy(&(AimAngles->z), &(angle[2]),sizeof(float));
  788.  
  789. //RCS
  790. if(pInfo->C_Conf_Aim_RCS)
  791. {
  792. Vector* pAngles =(Vector*) (LocalEntity.dwEntity+ Ad_Local + Ad_PAngles);
  793.  
  794. pmemcpy(&x, &(pAngles->x) ,sizeof(float));
  795. pmemcpy(&y, &(pAngles->y) ,sizeof(float));
  796. pmemcpy(&z, &(pAngles->z) ,sizeof(float));
  797.  
  798. pmemcpy(&x2, &(pInfo->t1dot96),sizeof(float));
  799. pmemcpy(&y2, &(pInfo->t1dot96),sizeof(float));
  800.  
  801. _asm
  802. {
  803. fld x
  804. fmul x2
  805. fstp x2 // x2 = Angles.x*1.96
  806. fld y
  807. fmul y2
  808. fstp y2 // y2 = Angles.y*1.96
  809. }
  810.  
  811. pmemcpy(&x, &(AimAngles->x) ,sizeof(float));
  812. pmemcpy(&y, &(AimAngles->y) ,sizeof(float));
  813.  
  814. _asm
  815. {
  816. fld x
  817. fsub x2
  818. fstp x // x = AimAngles.x = AimAngles.x - Angles.x*1.96
  819. fld y
  820. fsub y2
  821. fstp y
  822. }
  823.  
  824. pmemcpy(&(AimAngles->x),&x,sizeof(float));
  825. pmemcpy(&(AimAngles->y),&y,sizeof(float));
  826. }
  827.  
  828.  
  829. DWORD pEngine;
  830. pEngine = *(DWORD*)(pInfo->Engine + Ad_EnginePointer);
  831.  
  832. //Smooth
  833. if(pInfo->C_Conf_Aim_Smooth)
  834. {
  835. Vector *t = (Vector*)(pEngine + Ad_ViewAngles);
  836.  
  837. pmemcpy(&x, &(t->x), sizeof(float));
  838. pmemcpy(&y, &(t->y), sizeof(float));
  839. pmemcpy(&z, &(t->z), sizeof(float));
  840.  
  841. Vector MyAngles(&x,&y,&z,pInfo);
  842.  
  843. pmemcpy(&(dst[0]), &(MyAngles.x),sizeof(float));
  844. pmemcpy(&(dst[1]), &(MyAngles.y),sizeof(float));
  845. pmemcpy(&(dst[2]), &(MyAngles.z),sizeof(float));
  846.  
  847. pmemcpy(&(src[0]), &(AimAngles->x),sizeof(float));
  848. pmemcpy(&(src[1]), &(AimAngles->y),sizeof(float));
  849. pmemcpy(&(src[2]), &(AimAngles->z),sizeof(float));
  850.  
  851. cMat->Smooth(src, src, dst, pInfo->C_Conf_Aim_Smooth, pInfo);
  852.  
  853. pmemcpy(&(AimAngles->x),&(src[0]),sizeof(float));
  854. pmemcpy(&(AimAngles->y),&(src[1]),sizeof(float));
  855. pmemcpy(&(AimAngles->z),&(src[2]),sizeof(float));
  856. }
  857. else
  858. {
  859. pmemcpy(&(src[0]), &(AimAngles->x),sizeof(float));
  860. pmemcpy(&(src[1]), &(AimAngles->y),sizeof(float));
  861. pmemcpy(&(src[2]), &(AimAngles->z),sizeof(float));
  862. }
  863.  
  864. //NormaaliAnglet
  865. NormaaliAnglet(src,pInfo);
  866.  
  867. pmemcpy(&(AimAngles->x),&(src[0]),sizeof(float));
  868. pmemcpy(&(AimAngles->y),&(src[1]),sizeof(float));
  869. pmemcpy(&(AimAngles->z),&(src[2]),sizeof(float));
  870.  
  871. //SetAngles
  872. Vector *CurAngles = (Vector*)(pEngine + Ad_ViewAngles);
  873.  
  874. pmemcpy(&(CurAngles->x),&(AimAngles->x),sizeof(float));
  875. pmemcpy(&(CurAngles->y),&(AimAngles->y),sizeof(float));
  876. pmemcpy(&(CurAngles->z),&(AimAngles->z),sizeof(float));
  877. }
  878.  
  879. if(!(pGetAsyncKeyState(pInfo->C_Conf_Aim_Key)) && *sTimer == 1 )
  880. {
  881. *sTimer = 0;
  882. }
  883. };
  884. };
  885.  
  886.  
  887. DWORD sTimer;
  888. sTimer = 0;
  889. DWORD sTaTimer;
  890. DWORD eNtTimer;
  891.  
  892. float x,y,z;
  893. CMath cMat;
  894. Vector EntityPos(&(pInfo->t0),&(pInfo->t0),&(pInfo->t0),pInfo);
  895. Vector AimAngles(&(pInfo->t0),&(pInfo->t0),&(pInfo->t0),pInfo);
  896. C_Aimbot cAim;
  897.  
  898. if(pInfo->bInit == false)
  899. {
  900. C_Config_LoadSettings(pInfo);
  901. InitModules(pInfo);
  902. pInfo->bInit = true;
  903. }
  904.  
  905. while(pInfo->bInit == true)
  906. {
  907. C_LocalBase LocalEntity(pInfo);
  908.  
  909. if(LocalEntity.dwEntity != NULL)
  910. {
  911. cAim.Aimbot(&cMat,&EntityPos,&AimAngles,&sTimer,&sTaTimer,&eNtTimer,pInfo);
  912.  
  913. if(pGetAsyncKeyState(VK_DELETE)&1)
  914. {
  915. C_Config_LoadSettings(pInfo);
  916. }
  917. }
  918. }
  919.  
  920. if (pExitThread)
  921. pExitThread (0);
  922.  
  923. return 0;
  924. }
  925.  
  926. void Timer(DWORD *sTimer, DWORD *sTaTimer, DllInjectData *pInfo)
  927. {
  928. GetTickCountType pGetTickCount = (GetTickCountType)pInfo->pGetTickCount;
  929. *sTaTimer = pGetTickCount();
  930. *sTimer = 1;
  931. }
  932.  
  933. int elapsedTime( DWORD *sTimer, DWORD *sTaTimer, DWORD *eNtTimer, DllInjectData *pInfo)
  934. {
  935. GetTickCountType pGetTickCount = (GetTickCountType)pInfo->pGetTickCount;
  936. *eNtTimer = pGetTickCount();
  937. return (*eNtTimer - *sTaTimer);
  938. }
  939.  
  940. bool toFloat(int arg, float *ret, DllInjectData *pInfo)
  941. {
  942. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  943. float res, junk;
  944.  
  945. _asm
  946. {
  947. fild arg
  948. fstp res
  949. fstp junk
  950. }
  951.  
  952. pmemcpy (ret, &res, sizeof(float));
  953.  
  954. return true;
  955. }
  956.  
  957. int toInt(float *arg, DllInjectData *pInfo)
  958. {
  959. int re = 0;
  960. float farg;
  961. float junk;
  962.  
  963. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  964. pmemcpy(&farg, arg, sizeof(float));
  965.  
  966. _asm
  967. {
  968. fld farg
  969. fist re
  970. fstp junk
  971. }
  972.  
  973. return re;
  974. }
  975.  
  976. void InitModules(DllInjectData *pInfo)
  977. {
  978. DWORD mesD[10];
  979. char *dll = (char*)mesD;
  980.  
  981. dll[0]='c'; dll[1]='l'; dll[2]='i'; dll[3]='e'; dll[4]='n'; dll[5]='t'; dll[6]='.'; dll[7]='d'; dll[8]='l'; dll[9]='l'; dll[10]=0;
  982.  
  983. GetModuleHandleAType pGetModuleHandleA = (GetModuleHandleAType)pInfo->pGetModuleHandleA;
  984.  
  985. while(pInfo->Client == 0x0)
  986. {
  987. pInfo->Client = (DWORD)pGetModuleHandleA(dll);
  988. }
  989.  
  990. while(pInfo->Engine == 0x0)
  991. {
  992. dll[0]='e'; dll[1]='n'; dll[2]='g'; dll[3]='i'; dll[4]='n'; dll[5]='e'; dll[6]='.'; dll[7]='d'; dll[8]='l'; dll[9]='l'; dll[10]=0;
  993. pInfo->Engine = (DWORD)pGetModuleHandleA(dll);
  994. }
  995.  
  996. return;
  997. }
  998.  
  999. void _GetPrivateProfileStringF(DllInjectData *pInfo, LPCSTR lpAppName, LPCSTR lpKeyName, float *lpFloat, LPCSTR szIniFile)
  1000. {
  1001. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  1002.  
  1003. DWORD mesD[40]; char *buffer = (char*)mesD;
  1004.  
  1005. GetPrivateProfileStringAType pGetPrivateProfileStringA = (GetPrivateProfileStringAType)pInfo->pGetPrivateProfileStringA;
  1006. sscanf_sType psscanf_s = (sscanf_sType)pInfo->psscanf_s;
  1007. pGetPrivateProfileStringA(lpAppName, lpKeyName, 0, buffer, sizeof(buffer), szIniFile);
  1008.  
  1009. int param = 0;float fparam;
  1010. char szFormat[4]={'%','i','\0'};
  1011. psscanf_s(buffer, szFormat, &param);
  1012.  
  1013. _asm
  1014. {
  1015. fild param
  1016. fstp fparam
  1017. }
  1018.  
  1019. pmemcpy(lpFloat,&fparam,sizeof(float));
  1020.  
  1021. return;
  1022. }
  1023.  
  1024. void _GetPrivateProfileStringI(DllInjectData *pInfo, LPCSTR lpAppName, LPCSTR lpKeyName, int *pInt, LPCSTR szIniFile)
  1025. {
  1026. DWORD mesD[40];
  1027. char *buffer = (char*)mesD;
  1028.  
  1029. GetPrivateProfileStringAType pGetPrivateProfileStringA = (GetPrivateProfileStringAType)pInfo->pGetPrivateProfileStringA;
  1030. sscanf_sType psscanf_s = (sscanf_sType)pInfo->psscanf_s;
  1031. pGetPrivateProfileStringA(lpAppName, lpKeyName, 0, buffer, sizeof(mesD), szIniFile);
  1032.  
  1033. char szFormat[4]={'%','i','\0'};
  1034. psscanf_s(buffer, szFormat, pInt);
  1035.  
  1036. return;
  1037. }
  1038.  
  1039. void C_Config_LoadSettings(DllInjectData *pInfo)
  1040. {
  1041. DWORD dwIniFile[60];
  1042. char *szIniFile = (char*)dwIniFile;
  1043. DWORD dwAimbot[10];
  1044. char *szAimbot = (char*)dwAimbot;
  1045. DWORD dwStr[20];
  1046. char *szStr = (char*)dwStr;
  1047.  
  1048. szIniFile[0]='C'; szIniFile[1]=':'; szIniFile[2]='\\'; szIniFile[3]='W'; szIniFile[4]='i'; szIniFile[5]='n'; szIniFile[6]='d'; szIniFile[7]='o'; szIniFile[8]='w'; szIniFile[9]='s'; szIniFile[10]='\\'; szIniFile[11]='N'; szIniFile[12]='V'; szIniFile[13]='I'; szIniFile[14]='D'; szIniFile[15]='I'; szIniFile[16]='A'; szIniFile[17]='2'; szIniFile[18]='.'; szIniFile[19]='i'; szIniFile[20]='n'; szIniFile[21]='i'; szIniFile[22]=0;
  1049.  
  1050. szAimbot[0]='A'; szAimbot[1]='i'; szAimbot[2]='m'; szAimbot[3]='b'; szAimbot[4]='o'; szAimbot[5]='t'; szAimbot[6]=0;
  1051.  
  1052. szStr[0]='K'; szStr[1]='e'; szStr[2]='y'; szStr[3]=0;//"Key"
  1053. _GetPrivateProfileStringI(pInfo, szAimbot, szStr, &(pInfo->C_Conf_Aim_Key), szIniFile);
  1054.  
  1055. szStr[0]='F'; szStr[1]='o'; szStr[2]='v'; szStr[3]=0;//"Fov"
  1056. _GetPrivateProfileStringI(pInfo, szAimbot, szStr, &(pInfo->C_Conf_Aim_Fov), szIniFile);
  1057.  
  1058. szStr[0]='S'; szStr[1]='m'; szStr[2]='o'; szStr[3]='o'; szStr[4]='t'; szStr[5]='h';szStr[6]=0;//"Smooth"
  1059. _GetPrivateProfileStringI(pInfo, szAimbot, szStr, &(pInfo->C_Conf_Aim_Smooth), szIniFile);
  1060.  
  1061. szStr[0]='A'; szStr[1]='i'; szStr[2]='m'; szStr[3]='t'; szStr[4]='i'; szStr[5]='m'; szStr[6]='e'; szStr[7]=0;//"Aimtime"
  1062. _GetPrivateProfileStringI(pInfo, szAimbot, szStr, &(pInfo->C_Conf_Aim_Time), szIniFile);
  1063.  
  1064. szStr[0]='H'; szStr[1]='i'; szStr[2]='t'; szStr[3]='b'; szStr[4]='o'; szStr[5]='x';szStr[6]=0;//"Hitbox"
  1065. _GetPrivateProfileStringI(pInfo, szAimbot, szStr, &(pInfo->C_Conf_Aim_Hitbox), szIniFile);
  1066.  
  1067. szStr[0]='A'; szStr[1]='i'; szStr[2]='m'; szStr[3]='H'; szStr[4]='e'; szStr[5]='i'; szStr[6]='g'; szStr[7]='h'; szStr[8]='t'; szStr[9]=0;//"AimHeight"
  1068. _GetPrivateProfileStringI(pInfo, szAimbot, szStr, &(pInfo->C_Conf_Aim_Height), szIniFile);
  1069.  
  1070. szStr[0]='R'; szStr[1]='C'; szStr[2]='S'; szStr[3]=0;//"RCS"
  1071. _GetPrivateProfileStringI(pInfo, szAimbot, szStr, &(pInfo->C_Conf_Aim_RCS), szIniFile);
  1072. }
  1073.  
  1074. bool arctg (float* parg, float *ret, DllInjectData *pInfo)
  1075. {
  1076. float res;
  1077. float junk;
  1078. float arg;
  1079.  
  1080. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  1081. pmemcpy(&arg,parg,sizeof(float));
  1082.  
  1083. _asm
  1084. {
  1085. fld arg
  1086. fadd st(1),st(0)
  1087. fld1
  1088. fpatan
  1089. fldz
  1090. fadd st(0), st(1)
  1091. fstp res
  1092. fstp junk
  1093. fstp junk
  1094. }
  1095.  
  1096. pmemcpy(ret, &res, sizeof(float));
  1097.  
  1098. return true;
  1099. }
  1100.  
  1101. bool arccos(float* parg, float *ret, DllInjectData *pInfo)
  1102. {
  1103. float res;
  1104. float arg;
  1105. float junk;
  1106.  
  1107. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  1108. pmemcpy(&arg,parg,sizeof(float));
  1109.  
  1110. _asm
  1111. {
  1112. fld1
  1113. fadd arg
  1114. fstp res
  1115. fld arg
  1116. fld arg
  1117. fmulp st(1), st(0)
  1118. fld1
  1119. fsub st(0), st(1)
  1120. fsqrt
  1121. fdiv res
  1122. fstp res
  1123. fstp junk
  1124. }
  1125.  
  1126. arctg (&res, &res, pInfo);
  1127. float two;
  1128. pmemcpy(&two, &(pInfo->t2), sizeof(float));
  1129.  
  1130. _asm
  1131. {
  1132. fld res
  1133. fmul two
  1134. fstp res
  1135. }
  1136.  
  1137. pmemcpy(ret, &res, sizeof(float));
  1138.  
  1139. return true;
  1140. }
  1141.  
  1142. //Is greater
  1143. bool IG (float* parg1, float* parg2,DllInjectData *pInfo )
  1144. {
  1145. int iarg1 = 0, iarg2 = 0;
  1146. float arg1,arg2,junk;
  1147. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  1148. pmemcpy(&arg1,parg1,sizeof(float));
  1149. pmemcpy(&arg2,parg2,sizeof(float));
  1150.  
  1151. _asm
  1152. {
  1153. fld arg1
  1154. fistp iarg1
  1155. fld arg2
  1156. fistp iarg2
  1157. fstp junk
  1158. fstp junk
  1159. }
  1160.  
  1161. if (iarg1 > iarg2)
  1162. return true;
  1163. else
  1164. return false;
  1165. }
  1166.  
  1167. //Is lower
  1168. bool IL (float* parg1, float* parg2,DllInjectData *pInfo )
  1169. {
  1170. int iarg1 = 0, iarg2 = 0;
  1171. float arg1,arg2,junk;
  1172. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  1173. pmemcpy(&arg1,parg1,sizeof(float));
  1174. pmemcpy(&arg2,parg2,sizeof(float));
  1175.  
  1176. _asm
  1177. {
  1178. fld arg1
  1179. fistp iarg1
  1180. fld arg2
  1181. fistp iarg2
  1182. fstp junk
  1183. fstp junk
  1184. }
  1185.  
  1186. if (iarg1 < iarg2)
  1187. return true;
  1188. else
  1189. return false;
  1190. }
  1191.  
  1192. //Greater or equal
  1193. bool GE (float *parg1, float *parg2,DllInjectData *pInfo )
  1194. {
  1195. int iarg1 = 0, iarg2 = 0;
  1196. float arg1,arg2,junk;
  1197.  
  1198. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  1199. pmemcpy(&arg1,parg1,sizeof(float));
  1200. pmemcpy(&arg2,parg2,sizeof(float));
  1201.  
  1202. _asm
  1203. {
  1204. fld arg1
  1205. fistp iarg1
  1206. fld arg2
  1207. fistp iarg2
  1208. fstp junk
  1209. fstp junk
  1210. }
  1211.  
  1212. if (iarg1 >= iarg2)
  1213. return true;
  1214. else
  1215. return false;
  1216. }
  1217.  
  1218. void NormaaliAnglet( float angle[], DllInjectData *pInfo)
  1219. {
  1220. memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy;
  1221. float f180;
  1222. pmemcpy (&f180, &(pInfo->t180), sizeof(float));
  1223. float f89;
  1224. pmemcpy (&f89, &(pInfo->t89), sizeof(float));
  1225.  
  1226. float angle0,angle1;
  1227. pmemcpy (&angle0, &(angle[0]), sizeof(float));
  1228. pmemcpy (&angle1, &(angle[1]), sizeof(float));
  1229.  
  1230. while( IG(&angle0,&f89,pInfo))
  1231. {
  1232. _asm
  1233. {
  1234. fld angle0
  1235. fsub f180
  1236. fstp angle0
  1237. }
  1238. }
  1239.  
  1240. float n89;
  1241. pmemcpy (&n89, &(pInfo->n89), sizeof(float));
  1242.  
  1243. while( IL(&angle0,&n89,pInfo))
  1244. {
  1245. _asm
  1246. {
  1247. fld angle0
  1248. fadd f180
  1249. fstp angle0
  1250. }
  1251. }
  1252.  
  1253. float f360;
  1254. pmemcpy (&f360, &(pInfo->t360), sizeof(float));
  1255.  
  1256. while( IG(&angle1,&f180,pInfo))
  1257. {
  1258. _asm
  1259. {
  1260. fld angle1
  1261. fsub f360
  1262. fstp angle1
  1263. }
  1264. }
  1265.  
  1266. float n180;
  1267. pmemcpy (&n180, &(pInfo->n180), sizeof(float));
  1268.  
  1269. while( IL(&angle1,&n180,pInfo))
  1270. {
  1271. _asm
  1272. {
  1273. fld angle1
  1274. fadd f360
  1275. fstp angle1
  1276. }
  1277. }
  1278.  
  1279. pmemcpy (&(angle[0]), &angle0, sizeof(float));
  1280. pmemcpy (&(angle[1]), &angle1, sizeof(float));
  1281.  
  1282. return;
  1283. }
  1284.  
  1285. VOID WINAPI InjectThreadEnd ()
  1286. {
  1287. }
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!