csgo

PASTEBINnew pastePRO API tools faq deals
search...


Guest User
-

Public Pastes
Belle KNOB
4 sec ago
Untitled
19 sec ago
Untitled
26 sec ago
Untitled
35 sec ago
Untitled
56 sec ago
Untitled
HTML 5 | 58 sec ago
Untitled
59 sec ago
pagnosuperculo
1 min ago

SHARE
TWEET

Main.cpp //CSGO AIMBOT
 A GUEST  OCT 1ST, 2013  8,885  NEVER

NOT a member OF Pastebin yet? Sign Up, it unlocks many cool features!
rawdownloadcloneembedreportprintC++ 17.54 KB



#include <Windows.h>
#include <iostream>
#include <math.h>
#include "HackProcess.h"
#include <vector>
#include <algorithm>    // std::sort
//Create our 'hooking' and process managing object
CHackProcess fProcess;
using namespace std;
//We use F6 to exit the hack
#define F6_Key 0x75
//right click
#define RIGHT_MOUSE 0x02
//Here we store the num of players and update it regularly to know how many enemies we are dealing with
//this saves us doing loops unless their necessary e.g. we have 12 players and still loop 32 times wasting our great resources
//This makes our triggerbot MUCH faster in general
INT NumOfPlayers = 15;
CONST DWORD dw_PlayerCountOffs = 0x6F4020;//Engine.dll //Tirar  //////engine.dll+6F4020

//The player base is VERY important so we know where our player info is at
//including current jump status so we can use force jumping making our bHop
CONST DWORD GameBasePtr = 0xC000;
CONST DWORD GameBase = 0x00A15F68;

DWORD MeuPlayerBase;
INT localizado = 0;
INT localizadoang = 0;
INT contador = 0;
CONST DWORD Player_Base = GameBase-0x198;//0x00574560;
//The ATTACK address BELOW, WE WRITE 5 TO SHOOT OR 4 TO
CONST DWORD dw_MyTeamOffset = 0xD8;//client // + vai virar -
CONST DWORD dw_mTeamOffset = 0xD8;//client // -
CONST DWORD dw_MyHealth = 0x198;//client //+
CONST DWORD dw_Health = 0x00;//client //+
//FOR the x coord we can use cl_pdump for m_vecOrigin Vector or just move around the map looking for different values
//e.g. to find y coordinate walk up ladder search up, walk down search down etc.
CONST DWORD dw_Pos = 0x48;//client //0134 //-
CONST DWORD dw_MyPos = 0x150;//client //+
CONST CHAR mname = 0x4;//+
//Enemy Vars including the enemy loop
CONST DWORD EntityPlayer_Base = GameBase;
//How far in memory is each enemy data
CONST DWORD EntityLoopDistance = 0x1E0;

CONST DWORD waller = 0x9A8320;
//ViewAngles
//We find these by moving our mouse around constantly looking for changed/unchanged value,
//the alternative is to use cl_pdump 1 and search for the value assigned to m_angRotation vector


//We will use this struct throughout all other tutorials adding more variables every time

DWORD dw_m_angRotationFINAL = 0x09B23760;
//const DWORD dw_m_angRotationFINAL = 0x00;

/*
VOID EncontraAngulo()
{

float angulo;
float angulocompare;
DWORD compareptr;

FOR(INT i = 0; i < 3300;i++) {
        IF(localizadoang == 0) {
ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + 0xA00EB8), &angulo, sizeof(float), 0);
ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordEngine + 0xi), &compareptr, sizeof(DWORD), 0);
ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(compareptr), &angulocompare, sizeof(DWORD), 0);
printf("contador = %d \n", i);
printf("Angulo encontrado addr %x \n", compareptr);
printf("Angulo encontrado %f \n", angulocompare);
IF(angulo == angulocompare)
{
dw_m_angRotationFINAL = compareptr;
printf("Angulo encontrado addr %x \n", compareptr);
printf("Angulo encontrado %f \n", angulocompare);
localizadoang = 1;
}
        }
}



}*/


STRUCT MyPlayer_t
{
        DWORD CLocalPlayer;
        DWORD ggGameBase;
        DWORD ggGameBaseB;
        DWORD ggGameBaseC;
        INT Team;
        INT Health;
        float Position[3];

        float poscomparer;
        float posfinder;

        DWORD TeamPtr;
        DWORD HealthPtr;
        DWORD PositionPtr;

        DWORD poscomparerptr;

        DWORD BaseOffsA, BaseOffsB,BaseOffsC,BaseOffsD,BaseOffsE,BaseOffsF,BaseOffsG,BaseOffsH;
        DWORD BaseOffsAptr, BaseOffsBptr,BaseOffsCptr,BaseOffsDptr,BaseOffsEptr,BaseOffsFptr,BaseOffsGptr,BaseOffsHptr;
        DWORD TeamGambiarra;
        VOID ReadInformation()
        {


                        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + GameBase), &ggGameBase, sizeof(DWORD), 0);

                BaseOffsA = ggGameBase+0x4FC;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsA), &BaseOffsAptr, sizeof(DWORD), 0);
                BaseOffsB = BaseOffsAptr+0x504;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsB), &BaseOffsBptr, sizeof(DWORD), 0);
                BaseOffsC = BaseOffsBptr+0xD4;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsC), &BaseOffsCptr, sizeof(DWORD), 0);
                BaseOffsD = BaseOffsCptr+0x0;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsD), &BaseOffsDptr, sizeof(DWORD), 0);
                BaseOffsE = BaseOffsDptr+0x90;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsE), &BaseOffsEptr, sizeof(DWORD), 0);
                BaseOffsF = BaseOffsEptr+0x7C;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsF), &BaseOffsFptr, sizeof(DWORD), 0);
                BaseOffsG = BaseOffsFptr+0x120;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsG), &BaseOffsGptr, sizeof(DWORD), 0);
                BaseOffsH = BaseOffsGptr+0x200;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsH), &BaseOffsHptr, sizeof(DWORD), 0);



        //      ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(gggGameBaseB  + (Player * EntityLoopDistance)),&CBaseEntity, sizeof(DWORD), 0);


                FOR(INT i = 0; i < 32; i++) {
                        IF(localizado == 0) {
                CLocalPlayer = BaseOffsH  + (i * EntityLoopDistance);
                poscomparerptr = CLocalPlayer - dw_Pos;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + 0x9B8960), &posfinder, sizeof(float), 0);
        //ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(Nameptr), &Nameptrb, sizeof(DWORD), 0);
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(poscomparerptr), &poscomparer, sizeof(float), 0);
                printf("posfinder: %f \n", posfinder);
                printf("poscomparer: %f \n", poscomparer);
                IF(posfinder == poscomparer) {
                        CLocalPlayer = BaseOffsH  + (i * EntityLoopDistance);
            localizado = 1;
                        contador = i;
                        printf("Localizado ;p");
                }ELSE {
        localizado = 0;
                }
                //printf("i = %d", i);
                }
                }




                //ggGameBaseB = BaseOffsH;
                //ggGameBaseC = BaseOffsH-0x198;
        //      printf("BaseOffsH = %x", BaseOffsH);

  // ###############CLocalPlayer = ggGameBaseC; ******************************************/

                                //////ACHA O MEU PLAYER NO MEIO DOS PLAYERSS!!!!!!!!!!



CLocalPlayer = BaseOffsH  + (contador * EntityLoopDistance);
//printf("Localizado %d", localizado);
//CLocalPlayer = MeuPlayerBase-0x4;


        HealthPtr = CLocalPlayer+dw_Health;
        PositionPtr = CLocalPlayer-dw_Pos;
        TeamPtr = CLocalPlayer-dw_mTeamOffset;
        //printf("Team: %x", TeamPtr);
                // Reading CLocalPlayer Pointer to our "CLocalPlayer" DWORD.
                //ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(ggGameBaseC), &CLocalPlayer, sizeof(DWORD), 0);
                // Reading out our Team to our "Team" Varible.




                // Reading out our Health to our "Health" Varible.
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(HealthPtr), &Health, sizeof(INT), 0);


                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(TeamPtr), &Team, sizeof(INT), 0);//Tirar

                // Reading out our Position to our "Position" Varible.
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(PositionPtr), &Position, sizeof(float[3]), 0);

                //Here we find how many player entities exist in our game, through this we make sure to only loop the amount of times we need
                //when grabbing player data
                //Note that this call could be even better at a regular 15 or so seconds timer but performance shouldn't vary a great deal
                //ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordEngine + dw_PlayerCountOffs), &NumOfPlayers, sizeof(int), 0); //Tirar

        //DWORD PosX = 0x9B8960;
        //DWORD PosZ = 0x9B8964;
        //DWORD PosY = 0x9B8968;


        }
}MyPlayer;




//Here is where we narrow the enemy data to the enemies that we want to shoot,
//these players are added once we validated them e.g. do they have enough health?, or maybe they are on the enemy team
STRUCT TargetList_t
{
        float Distance;
        float AimbotAngle[3];

        TargetList_t()
        {
                //our default constructor :S
        }

        TargetList_t(float aimbotAngle[], float myCoords[], float enemyCoords[])
        {
                //Send our coordinates and the enemy's to find out how close they are to us!
                Distance = Get3dDistance(myCoords[0], myCoords[1], myCoords[2],
                                                                enemyCoords[0], enemyCoords[1], enemyCoords[2] );

                //Define our aimbot angles and set them for later use when shooting
                AimbotAngle[0] = aimbotAngle[0];
                AimbotAngle[1] = aimbotAngle[1];
                AimbotAngle[2] = aimbotAngle[2];
        }

        //Get our 3d Distance between 2 sets of coordinates(ours and enemies) and find out how close an enemy is to us
        //when it comes to shooting we aim at the closest enemy
        //Simple but effective

        //Here we will AVOID vectors for simplicity but feel free to create to use them
        //if you prefer float Get3dDistance(std::vector<float> myCoords, std::vector<float> enemyCoords)

        //See how far away our enemy is to us
        float Get3dDistance(float myCoordsX, float myCoordsZ, float myCoordsY,
                                                float eNx, float eNz, float eNy)
        {
                //Use the 3d distance formula to get a resulting Floating distance value POW!!
                RETURN sqrt(
                        pow(double(eNx - myCoordsX), 2.0) +
                        pow(double(eNy - myCoordsY), 2.0) +
                        pow(double(eNz - myCoordsZ), 2.0));
        }
};



//ENemy struct
STRUCT PlayerList_t
{
        DWORD gggGameBase;
        DWORD gggGameBaseB;
        DWORD gggGameBaseC;
        DWORD CBaseEntity;
        INT Team;
        INT Health;
        float Position[3];
        float AimbotAngle[3];
        CHAR Name[39];

        DWORD Healthptr;
        DWORD Teamptr;
        DWORD Positionptr;
        DWORD Nameptr;


        DWORD BaseOffsA, BaseOffsB,BaseOffsC,BaseOffsD,BaseOffsE,BaseOffsF,BaseOffsG,BaseOffsH;
        DWORD BaseOffsAptr, BaseOffsBptr,BaseOffsCptr,BaseOffsDptr,BaseOffsEptr,BaseOffsFptr,BaseOffsGptr,BaseOffsHptr;
        VOID ReadInformation(INT Player)
        {
                // Reading CBaseEntity Pointer to our "CBaseEntity" DWORD + Current Player in the loop. 0x10 is the CBaseEntity List Size
                //"client.dll"+00545204 //0x571A5204







                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + GameBase), &gggGameBase, sizeof(DWORD), 0);

                BaseOffsA = gggGameBase+0x4FC;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsA), &BaseOffsAptr, sizeof(DWORD), 0);
                BaseOffsB = BaseOffsAptr+0x504;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsB), &BaseOffsBptr, sizeof(DWORD), 0);
                BaseOffsC = BaseOffsBptr+0xD4;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsC), &BaseOffsCptr, sizeof(DWORD), 0);
                BaseOffsD = BaseOffsCptr+0x0;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsD), &BaseOffsDptr, sizeof(DWORD), 0);
                BaseOffsE = BaseOffsDptr+0x90;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsE), &BaseOffsEptr, sizeof(DWORD), 0);
                BaseOffsF = BaseOffsEptr+0x7C;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsF), &BaseOffsFptr, sizeof(DWORD), 0);
                BaseOffsG = BaseOffsFptr+0x120;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsG), &BaseOffsGptr, sizeof(DWORD), 0);
                BaseOffsH = BaseOffsGptr+0x200;
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsH), &BaseOffsHptr, sizeof(DWORD), 0);



        //      ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(gggGameBaseB  + (Player * EntityLoopDistance)),&CBaseEntity, sizeof(DWORD), 0);

                CBaseEntity = BaseOffsH  + (Player * EntityLoopDistance);

                //printf("gggGameBaseB = %x", CBaseEntity);


     Teamptr = CBaseEntity - dw_mTeamOffset;
         Healthptr = CBaseEntity + dw_Health;
     Positionptr =  CBaseEntity - dw_Pos;
         Nameptr = CBaseEntity + mname;


                        // Reading out our Team to our "Team" Varible.
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(Teamptr), &Team, sizeof(INT), 0); //Tirar
                //printf("TeamId = %d \n", Team);
                // Reading out our Health to our "Health" Varible.
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(Healthptr), &Health, sizeof(INT), 0);
                // Reading out our Position to our "Position" Varible.
                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(Positionptr), &Position, sizeof(float[3]), 0);

                ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(Nameptr), &Name, sizeof(CHAR), 0);


        }
}PlayerList[32];



//Used to compare the distance when sorting the array of Target Enemies
//JUST think of this as an assist for a sorting algorithm
//and this isn't necessarily related to hacking but it helps us out
STRUCT CompareTargetEnArray
{
        //USE A COMPARATOR TO SORT OUR ARRAY nicely
        BOOL operator() (TargetList_t & lhs, TargetList_t & rhs)
        {
                RETURN lhs.Distance < rhs.Distance;
        }
};


//Props to Nubtik and a couple of other places on the interwebs for this function
VOID CalcAngle( float *src, float *dst, float *angles )
{

        double delta[3] = { (src[0]-dst[0]), (src[1]-dst[1]), (src[2]-dst[2]) };
        double hyp = sqrt(delta[0]*delta[0] + delta[1]*delta[1]);
        angles[0] = (float) (asinf(delta[2]/hyp) * 57.295779513082f);
        angles[1] = (float) (atanf(delta[1]/delta[0]) * 57.295779513082f);
        angles[2] = 0.0f;

        IF(delta[0] >= 0.0)
        {
                angles[1] += 180.0f;
        }
}




        float Calculadistancia(float myCoordsX, float myCoordsZ, float myCoordsY,
                                                float eNx, float eNz, float eNy)
        {
                //Use the 3d distance formula to get a resulting Floating distance value POW!!
                RETURN sqrt(
                        pow(double(eNx - myCoordsX), 2.0) +
                        pow(double(eNy - myCoordsY), 2.0) +
                        pow(double(eNz - myCoordsZ), 2.0));
        }

VOID Aimbot()
{
        float fNearest = (float)INT_MAX;//Meu cod
        INT iAimAt = -1;
        INT gambiarrameutime = 12;
        ///////
        //Declare our target list to define our victims through a dynamic array
        TargetList_t* TargetList = new TargetList_t[NumOfPlayers];
        //Loop through all our players and retrieve their information
        //we use this mainly here to find out what players are our enemies and what players are on our team
        //loops through players to set the target enemies
        INT targetLoop = 0;
        FOR(INT i = 1; i < NumOfPlayers; i ++) //Começa com 2 pq se n mira em mim mesmo e explode a porra toda
        {
                IF (GetAsyncKeyState(VK_RBUTTON)) { ////Meu
                        i++;
                }
                        IF (GetAsyncKeyState(VK_F2)) { ////Meu
                        gambiarrameutime = 12;
                }
                                IF (GetAsyncKeyState(VK_F3)) { ////Meu
                        gambiarrameutime = 16;
                }

                        IF (GetAsyncKeyState(VK_F4)) { ////Meu
                        gambiarrameutime = 8;
                }


                PlayerList[i].ReadInformation(i);

                // Skip if they're my teammates.
                IF (PlayerList[i].Team == MyPlayer.Team)
                        CONTINUE;

                //Make sure our targets have at keast 2 health
                IF (PlayerList[i].Health < 2)
                        CONTINUE; //break to next iteration //Tirar

                IF(Calculadistancia(MyPlayer.Position[0], MyPlayer.Position[1], (MyPlayer.Position[2]),PlayerList[i].Position[0],PlayerList[i].Position[1], (PlayerList[i].Position[2]) ) < fNearest )//dis :D
                                {

                                        //      if(!Parede.noobie && !Parede.aimdelay) {  //Mudar aki...

                                        iAimAt = i;

                                        fNearest = Calculadistancia(MyPlayer.Position[0], MyPlayer.Position[1],
                                                (MyPlayer.Position[2]),PlayerList[i].Position[0],PlayerList[i].Position[1], (PlayerList[i].Position[2]) );
                                        //      }
                                }


                //PlayerList[i].Position[2] -= 10;
                CalcAngle (MyPlayer.Position, PlayerList[i].Position, PlayerList[i].AimbotAngle);

                //ONCE WE GET HERE we have already read all the information we want, all enemies have been checked for valid data
                //Therefore players on our team a dont get selected and only enemies with over 1 health are allowed

                //WE NOW DEFINE A LIST OF ENEMIES TO SHOOT AT, from here we will scan that array and choose to aim at the closest one
                //Create our target loop player and store the most important information
                TargetList[targetLoop] = TargetList_t(PlayerList[i].AimbotAngle, MyPlayer.Position, PlayerList[i].Position);

                //Increment so we can add more players onto the array
                targetLoop++;
        }




        //ONLY AIM if we have any enemies
        IF(targetLoop > 0)
        {
                //SORT ENEMIES ARRAY BY DISTANCE before AIMING AT THEM
                //JUST NORMAL std::sort function with our custom comparator, not much to it
                //target loop -1 because it will always go 1 above the count
                std::sort(TargetList, TargetList+targetLoop, CompareTargetEnArray());

                //AIM at the closest guy we found,
                //by default aim at ALL times, if you right click hold it switches it off
                //This isn't the best example but change the example to whatevery you like E.g. Left click etc...
                IF (GetAsyncKeyState(VK_MBUTTON))
                {
                        IF(iAimAt != -1) {


                        /*
                                        WriteProcessMemory (fProcess.__HandleProcess,
                                (PBYTE*)(fProcess.__csgoexe+dw_m_angRotation),
                                        TargetList[0].AimbotAngle, 12, 0);*/

                                IF(MyPlayer.Health > 2) { //Evita um bug louco
                WriteProcessMemory (fProcess.__HandleProcess,
                                (PBYTE*)(dw_m_angRotationFINAL),
                                        TargetList[0].AimbotAngle, 14, 0);
                                }
/*
                                WriteProcessMemory (fProcess.__HandleProcess,
                                (PBYTE*)(dw_m_angRotationX),
                                        TargetList[0].AimbotAngle, 12, 0);

                                                WriteProcessMemory (fProcess.__HandleProcess,
                                (PBYTE*)(dw_m_angRotationY),
                                        TargetList[0].AimbotAngle, 12, 0);
                                                                WriteProcessMemory (fProcess.__HandleProcess,
                                (PBYTE*)(dw_m_angRotationZ),
                                        TargetList[0].AimbotAngle, 12, 0);*/





                        }

                        //no recoil above text
                }

        }
        //reset the loop counter
        targetLoop = 0;
        //DELETE OUR ARRAY and clear memory, very important
        delete [] TargetList;
}



INT main()
{

        fProcess.RunProcess(); // Waiting for CSS......
        cout << "Game found! Running Aimbot..." << endl;

        //Exit if the F6 key is pressed
        WHILE (!GetAsyncKeyState(F6_Key)) // or for(;;)
        {
                //Read player information into our struct so we know the player
                //base and the bunny hop addresses


                MyPlayer.ReadInformation();
        //      EncontraAngulo();


                //Call our Aimbot

                Aimbot();

        }
}
RAW Paste Data


#include <Windows.h>
#include <iostream>
#include <math.h>
#include "HackProcess.h"
#include <vector>
#include <algorithm>    // std::sort
//Create our 'hooking' and process managing object
CHackProcess fProcess;
using namespace std;
//We use F6 to exit the hack
#define F6_Key 0x75
//right click
#define RIGHT_MOUSE 0x02
//Here we store the num of players and update it regularly to know how many enemies we are dealing with
//this saves us doing loops unless their necessary e.g. we have 12 players and still loop 32 times wasting our great resources
//This makes our triggerbot MUCH faster in general
INT NumOfPlayers = 15;
CONST DWORD dw_PlayerCountOffs = 0x6F4020;//Engine.dll //Tirar  //////engine.dll+6F4020

//The player base is VERY important so we know where our player info is at
//including current jump status so we can use force jumping making our bHop
CONST DWORD GameBasePtr = 0xC000;
CONST DWORD GameBase = 0x00A15F68;

DWORD MeuPlayerBase;
INT localizado = 0;
INT localizadoang = 0;
INT contador = 0;
CONST DWORD Player_Base = GameBase-0x198;//0x00574560;
//The ATTACK address BELOW, WE WRITE 5 TO SHOOT OR 4 TO
CONST DWORD dw_MyTeamOffset = 0xD8;//client // + vai virar -
CONST DWORD dw_mTeamOffset = 0xD8;//client // -
CONST DWORD dw_MyHealth = 0x198;//client //+
CONST DWORD dw_Health = 0x00;//client //+
//FOR the x coord we can use cl_pdump for m_vecOrigin Vector or just move around the map looking for different values
//e.g. to find y coordinate walk up ladder search up, walk down search down etc.
CONST DWORD dw_Pos = 0x48;//client //0134 //-
CONST DWORD dw_MyPos = 0x150;//client //+
CONST CHAR mname = 0x4;//+
//Enemy Vars including the enemy loop
CONST DWORD EntityPlayer_Base = GameBase;
//How far in memory is each enemy data
CONST DWORD EntityLoopDistance = 0x1E0;

CONST DWORD waller = 0x9A8320;
//ViewAngles
//We find these by moving our mouse around constantly looking for changed/unchanged value,
//the alternative is to use cl_pdump 1 and search for the value assigned to m_angRotation vector


//We will use this struct throughout all other tutorials adding more variables every time

DWORD dw_m_angRotationFINAL = 0x09B23760;
//const DWORD dw_m_angRotationFINAL = 0x00;

/*
VOID EncontraAngulo()
{

float angulo;
float angulocompare;
DWORD compareptr;

FOR(INT i = 0; i < 3300;i++) {
    IF(localizadoang == 0) {
ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + 0xA00EB8), &angulo, sizeof(float), 0);
ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordEngine + 0xi), &compareptr, sizeof(DWORD), 0);
ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(compareptr), &angulocompare, sizeof(DWORD), 0);
printf("contador = %d \n", i);
printf("Angulo encontrado addr %x \n", compareptr);
printf("Angulo encontrado %f \n", angulocompare);
IF(angulo == angulocompare)
{
dw_m_angRotationFINAL = compareptr;
printf("Angulo encontrado addr %x \n", compareptr);
printf("Angulo encontrado %f \n", angulocompare);
localizadoang = 1;
}
    }
}



}*/


STRUCT MyPlayer_t
{
    DWORD CLocalPlayer;
    DWORD ggGameBase;
    DWORD ggGameBaseB;
    DWORD ggGameBaseC;
    INT Team;
    INT Health;
    float Position[3];

    float poscomparer;
    float posfinder;

    DWORD TeamPtr;
    DWORD HealthPtr;
    DWORD PositionPtr;

    DWORD poscomparerptr;

    DWORD BaseOffsA, BaseOffsB,BaseOffsC,BaseOffsD,BaseOffsE,BaseOffsF,BaseOffsG,BaseOffsH;
    DWORD BaseOffsAptr, BaseOffsBptr,BaseOffsCptr,BaseOffsDptr,BaseOffsEptr,BaseOffsFptr,BaseOffsGptr,BaseOffsHptr;
    DWORD TeamGambiarra;
    VOID ReadInformation()
    {


            ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + GameBase), &ggGameBase, sizeof(DWORD), 0);

        BaseOffsA = ggGameBase+0x4FC;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsA), &BaseOffsAptr, sizeof(DWORD), 0);
        BaseOffsB = BaseOffsAptr+0x504;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsB), &BaseOffsBptr, sizeof(DWORD), 0);
        BaseOffsC = BaseOffsBptr+0xD4;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsC), &BaseOffsCptr, sizeof(DWORD), 0);
        BaseOffsD = BaseOffsCptr+0x0;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsD), &BaseOffsDptr, sizeof(DWORD), 0);
        BaseOffsE = BaseOffsDptr+0x90;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsE), &BaseOffsEptr, sizeof(DWORD), 0);
        BaseOffsF = BaseOffsEptr+0x7C;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsF), &BaseOffsFptr, sizeof(DWORD), 0);
        BaseOffsG = BaseOffsFptr+0x120;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsG), &BaseOffsGptr, sizeof(DWORD), 0);
        BaseOffsH = BaseOffsGptr+0x200;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsH), &BaseOffsHptr, sizeof(DWORD), 0);



    //  ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(gggGameBaseB  + (Player * EntityLoopDistance)),&CBaseEntity, sizeof(DWORD), 0);


        FOR(INT i = 0; i < 32; i++) {
            IF(localizado == 0) {
        CLocalPlayer = BaseOffsH  + (i * EntityLoopDistance);
        poscomparerptr = CLocalPlayer - dw_Pos;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + 0x9B8960), &posfinder, sizeof(float), 0);
        //ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(Nameptr), &Nameptrb, sizeof(DWORD), 0);
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(poscomparerptr), &poscomparer, sizeof(float), 0);
        printf("posfinder: %f \n", posfinder);
        printf("poscomparer: %f \n", poscomparer);
        IF(posfinder == poscomparer) {
            CLocalPlayer = BaseOffsH  + (i * EntityLoopDistance);
            localizado = 1;
            contador = i;
            printf("Localizado ;p");
        }ELSE {
        localizado = 0;
        }
        //printf("i = %d", i);
        }
        }




        //ggGameBaseB = BaseOffsH;
        //ggGameBaseC = BaseOffsH-0x198;
    //  printf("BaseOffsH = %x", BaseOffsH);

  // ###############CLocalPlayer = ggGameBaseC; ******************************************/

                //////ACHA O MEU PLAYER NO MEIO DOS PLAYERSS!!!!!!!!!!



CLocalPlayer = BaseOffsH  + (contador * EntityLoopDistance);
//printf("Localizado %d", localizado);
//CLocalPlayer = MeuPlayerBase-0x4;


    HealthPtr = CLocalPlayer+dw_Health;
    PositionPtr = CLocalPlayer-dw_Pos;
    TeamPtr = CLocalPlayer-dw_mTeamOffset;
    //printf("Team: %x", TeamPtr);
        // Reading CLocalPlayer Pointer to our "CLocalPlayer" DWORD.
        //ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(ggGameBaseC), &CLocalPlayer, sizeof(DWORD), 0);
        // Reading out our Team to our "Team" Varible.




        // Reading out our Health to our "Health" Varible.
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(HealthPtr), &Health, sizeof(INT), 0);


        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(TeamPtr), &Team, sizeof(INT), 0);//Tirar

        // Reading out our Position to our "Position" Varible.
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(PositionPtr), &Position, sizeof(float[3]), 0);

        //Here we find how many player entities exist in our game, through this we make sure to only loop the amount of times we need
        //when grabbing player data
        //Note that this call could be even better at a regular 15 or so seconds timer but performance shouldn't vary a great deal
        //ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordEngine + dw_PlayerCountOffs), &NumOfPlayers, sizeof(int), 0); //Tirar

    //DWORD PosX = 0x9B8960;
    //DWORD PosZ = 0x9B8964;
    //DWORD PosY = 0x9B8968;


    }
}MyPlayer;




//Here is where we narrow the enemy data to the enemies that we want to shoot,
//these players are added once we validated them e.g. do they have enough health?, or maybe they are on the enemy team
STRUCT TargetList_t
{
    float Distance;
    float AimbotAngle[3];

    TargetList_t()
    {
        //our default constructor :S
    }

    TargetList_t(float aimbotAngle[], float myCoords[], float enemyCoords[])
    {
        //Send our coordinates and the enemy's to find out how close they are to us!
        Distance = Get3dDistance(myCoords[0], myCoords[1], myCoords[2],
                                enemyCoords[0], enemyCoords[1], enemyCoords[2] );

        //Define our aimbot angles and set them for later use when shooting
        AimbotAngle[0] = aimbotAngle[0];
        AimbotAngle[1] = aimbotAngle[1];
        AimbotAngle[2] = aimbotAngle[2];
    }

    //Get our 3d Distance between 2 sets of coordinates(ours and enemies) and find out how close an enemy is to us
    //when it comes to shooting we aim at the closest enemy
    //Simple but effective

    //Here we will AVOID vectors for simplicity but feel free to create to use them
    //if you prefer float Get3dDistance(std::vector<float> myCoords, std::vector<float> enemyCoords)

    //See how far away our enemy is to us
    float Get3dDistance(float myCoordsX, float myCoordsZ, float myCoordsY,
                        float eNx, float eNz, float eNy)
    {
        //Use the 3d distance formula to get a resulting Floating distance value POW!!
        RETURN sqrt(
            pow(double(eNx - myCoordsX), 2.0) +
            pow(double(eNy - myCoordsY), 2.0) +
            pow(double(eNz - myCoordsZ), 2.0));
    }
};



//ENemy struct
STRUCT PlayerList_t
{
    DWORD gggGameBase;
    DWORD gggGameBaseB;
    DWORD gggGameBaseC;
    DWORD CBaseEntity;
    INT Team;
    INT Health;
    float Position[3];
    float AimbotAngle[3];
    CHAR Name[39];

    DWORD Healthptr;
    DWORD Teamptr;
    DWORD Positionptr;
    DWORD Nameptr;


    DWORD BaseOffsA, BaseOffsB,BaseOffsC,BaseOffsD,BaseOffsE,BaseOffsF,BaseOffsG,BaseOffsH;
    DWORD BaseOffsAptr, BaseOffsBptr,BaseOffsCptr,BaseOffsDptr,BaseOffsEptr,BaseOffsFptr,BaseOffsGptr,BaseOffsHptr;
    VOID ReadInformation(INT Player)
    {
        // Reading CBaseEntity Pointer to our "CBaseEntity" DWORD + Current Player in the loop. 0x10 is the CBaseEntity List Size
        //"client.dll"+00545204 //0x571A5204







        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + GameBase), &gggGameBase, sizeof(DWORD), 0);

        BaseOffsA = gggGameBase+0x4FC;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsA), &BaseOffsAptr, sizeof(DWORD), 0);
        BaseOffsB = BaseOffsAptr+0x504;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsB), &BaseOffsBptr, sizeof(DWORD), 0);
        BaseOffsC = BaseOffsBptr+0xD4;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsC), &BaseOffsCptr, sizeof(DWORD), 0);
        BaseOffsD = BaseOffsCptr+0x0;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsD), &BaseOffsDptr, sizeof(DWORD), 0);
        BaseOffsE = BaseOffsDptr+0x90;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsE), &BaseOffsEptr, sizeof(DWORD), 0);
        BaseOffsF = BaseOffsEptr+0x7C;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsF), &BaseOffsFptr, sizeof(DWORD), 0);
        BaseOffsG = BaseOffsFptr+0x120;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsG), &BaseOffsGptr, sizeof(DWORD), 0);
        BaseOffsH = BaseOffsGptr+0x200;
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(BaseOffsH), &BaseOffsHptr, sizeof(DWORD), 0);



    //  ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(gggGameBaseB  + (Player * EntityLoopDistance)),&CBaseEntity, sizeof(DWORD), 0);

        CBaseEntity = BaseOffsH  + (Player * EntityLoopDistance);

        //printf("gggGameBaseB = %x", CBaseEntity);


     Teamptr = CBaseEntity - dw_mTeamOffset;
     Healthptr = CBaseEntity + dw_Health;
     Positionptr =  CBaseEntity - dw_Pos;
     Nameptr = CBaseEntity + mname;


            // Reading out our Team to our "Team" Varible.
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(Teamptr), &Team, sizeof(INT), 0); //Tirar
        //printf("TeamId = %d \n", Team);
        // Reading out our Health to our "Health" Varible.
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(Healthptr), &Health, sizeof(INT), 0);
        // Reading out our Position to our "Position" Varible.
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(Positionptr), &Position, sizeof(float[3]), 0);

        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(Nameptr), &Name, sizeof(CHAR), 0);


    }
}PlayerList[32];



//Used to compare the distance when sorting the array of Target Enemies
//JUST think of this as an assist for a sorting algorithm
//and this isn't necessarily related to hacking but it helps us out
STRUCT CompareTargetEnArray
{
    //USE A COMPARATOR TO SORT OUR ARRAY nicely
    BOOL operator() (TargetList_t & lhs, TargetList_t & rhs)
    {
        RETURN lhs.Distance < rhs.Distance;
    }
};


//Props to Nubtik and a couple of other places on the interwebs for this function
VOID CalcAngle( float *src, float *dst, float *angles )
{

    double delta[3] = { (src[0]-dst[0]), (src[1]-dst[1]), (src[2]-dst[2]) };
    double hyp = sqrt(delta[0]*delta[0] + delta[1]*delta[1]);
    angles[0] = (float) (asinf(delta[2]/hyp) * 57.295779513082f);
    angles[1] = (float) (atanf(delta[1]/delta[0]) * 57.295779513082f);
    angles[2] = 0.0f;

    IF(delta[0] >= 0.0)
    {
        angles[1] += 180.0f;
    }
}




    float Calculadistancia(float myCoordsX, float myCoordsZ, float myCoordsY,
                        float eNx, float eNz, float eNy)
    {
        //Use the 3d distance formula to get a resulting Floating distance value POW!!
        RETURN sqrt(
            pow(double(eNx - myCoordsX), 2.0) +
            pow(double(eNy - myCoordsY), 2.0) +
            pow(double(eNz - myCoordsZ), 2.0));
    }

VOID Aimbot()
{
    float fNearest = (float)INT_MAX;//Meu cod
    INT iAimAt = -1;
    INT gambiarrameutime = 12;
    ///////
    //Declare our target list to define our victims through a dynamic array
    TargetList_t* TargetList = new TargetList_t[NumOfPlayers];
    //Loop through all our players and retrieve their information
    //we use this mainly here to find out what players are our enemies and what players are on our team
    //loops through players to set the target enemies
    INT targetLoop = 0;
    FOR(INT i = 1; i < NumOfPlayers; i ++) //Começa com 2 pq se n mira em mim mesmo e explode a porra toda
    {
        IF (GetAsyncKeyState(VK_RBUTTON)) { ////Meu
            i++;
        }
            IF (GetAsyncKeyState(VK_F2)) { ////Meu
            gambiarrameutime = 12;
        }
                IF (GetAsyncKeyState(VK_F3)) { ////Meu
            gambiarrameutime = 16;
        }

            IF (GetAsyncKeyState(VK_F4)) { ////Meu
            gambiarrameutime = 8;
        }


        PlayerList[i].ReadInformation(i);

        // Skip if they're my teammates.
        IF (PlayerList[i].Team == MyPlayer.Team)
            CONTINUE;

        //Make sure our targets have at keast 2 health
        IF (PlayerList[i].Health < 2)
            CONTINUE; //break to next iteration //Tirar

        IF(Calculadistancia(MyPlayer.Position[0], MyPlayer.Position[1], (MyPlayer.Position[2]),PlayerList[i].Position[0],PlayerList[i].Position[1], (PlayerList[i].Position[2]) ) < fNearest )//dis :D
                {

                    //  if(!Parede.noobie && !Parede.aimdelay) {  //Mudar aki...

                    iAimAt = i;

                    fNearest = Calculadistancia(MyPlayer.Position[0], MyPlayer.Position[1],
                        (MyPlayer.Position[2]),PlayerList[i].Position[0],PlayerList[i].Position[1], (PlayerList[i].Position[2]) );
                    //  }
                }


        //PlayerList[i].Position[2] -= 10;
        CalcAngle (MyPlayer.Position, PlayerList[i].Position, PlayerList[i].AimbotAngle);

        //ONCE WE GET HERE we have already read all the information we want, all enemies have been checked for valid data
        //Therefore players on our team a dont get selected and only enemies with over 1 health are allowed

        //WE NOW DEFINE A LIST OF ENEMIES TO SHOOT AT, from here we will scan that array and choose to aim at the closest one
        //Create our target loop player and store the most important information
        TargetList[targetLoop] = TargetList_t(PlayerList[i].AimbotAngle, MyPlayer.Position, PlayerList[i].Position);

        //Increment so we can add more players onto the array
        targetLoop++;
    }




    //ONLY AIM if we have any enemies
    IF(targetLoop > 0)
    {
        //SORT ENEMIES ARRAY BY DISTANCE before AIMING AT THEM
        //JUST NORMAL std::sort function with our custom comparator, not much to it
        //target loop -1 because it will always go 1 above the count
        std::sort(TargetList, TargetList+targetLoop, CompareTargetEnArray());

        //AIM at the closest guy we found,
        //by default aim at ALL times, if you right click hold it switches it off
        //This isn't the best example but change the example to whatevery you like E.g. Left click etc...
        IF (GetAsyncKeyState(VK_MBUTTON))
        {
            IF(iAimAt != -1) {


            /*
                    WriteProcessMemory (fProcess.__HandleProcess,
                (PBYTE*)(fProcess.__csgoexe+dw_m_angRotation),
                    TargetList[0].AimbotAngle, 12, 0);*/

                IF(MyPlayer.Health > 2) { //Evita um bug louco
        WriteProcessMemory (fProcess.__HandleProcess,
                (PBYTE*)(dw_m_angRotationFINAL),
                    TargetList[0].AimbotAngle, 14, 0);
                }
/*
                WriteProcessMemory (fProcess.__HandleProcess,
                (PBYTE*)(dw_m_angRotationX),
                    TargetList[0].AimbotAngle, 12, 0);

                        WriteProcessMemory (fProcess.__HandleProcess,
                (PBYTE*)(dw_m_angRotationY),
                    TargetList[0].AimbotAngle, 12, 0);
                                WriteProcessMemory (fProcess.__HandleProcess,
                (PBYTE*)(dw_m_angRotationZ),
                    TargetList[0].AimbotAngle, 12, 0);*/





            }

            //no recoil above text
        }

    }
    //reset the loop counter
    targetLoop = 0;
    //DELETE OUR ARRAY and clear memory, very important
    delete [] TargetList;
}



INT main()
{

    fProcess.RunProcess(); // Waiting for CSS......
    cout << "Game found! Running Aimbot..." << endl;

    //Exit if the F6 key is pressed
    WHILE (!GetAsyncKeyState(F6_Key)) // or for(;;)
    {
        //Read player information into our struct so we know the player
        //base and the bunny hop addresses


        MyPlayer.ReadInformation();
    //  EncontraAngulo();


        //Call our Aimbot

        Aimbot();

    }
}

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!

create new paste  /  dealsnew!  /  syntax languages  /  archive  /  faq  /  tools  /  night mode  /  api  /  scraping api
privacy statement  /  cookies policy  /  terms OF service  /  security disclosure  /  dmca  /  contact

BY using Pastebin.com you agree TO our cookies policy TO enhance your experience.
Site design & logo © 2019 Pastebin; user contributions (pastes) licensed under cc by-sa 3.0 -- FavPNG -- Dedicated Server Hosting BY Steadfast
Top