Source Aimbot ²

Há um tempo atraz , o PARKII (http://www.mpgh.net/forum/409-coding...ot.html)postou uma source de um aimbot , procurando na net , achei essa , base , porém é complicada de entender , postarei o que eu consegui entender.

De acordo com o meu conhecimento ( que não é muita coisa) ,tentarei explicar a source, então vamos lá:

Código fonte do aimbot ( mira automatica).

LEMBRANDO QUE NA BASE:

E = LESTE
W = OESTE
N = NORTE
S = SUL
U = PARA CIMA
D = PARA BAIXO

Code:

PLAYER_DATA GetMyPlayerData(void)
PLAYER_DATA GetPlayerData(BYTE PlayerNumber)
void SetCrosshairOnEnemy(BYTE PlayerNumber

A estrutura PLAYER_DATA , contém as informações valiosas.

typedef struct _PLAYER_DATA {
DWORD baseadd; // Base dos endereços do jogador atual.
DWORD coordEW; // Coordenada (X) leste e oeste
DWORD coordNS; // Coordenada (Y) norte e sul
DWORD coordUD; // Coordenada (Z) para cima e para baixo
DWORD coordEWa; // Os endereços dos jogadores leste e oeste
DWORD coordNSa; // Os endereços dos jogadores norte e sul
DWORD coordUDa; // Os endereços dos jogadores para cima e para baixo
DWORD lookX; // Os jogadores ficam no eixo X (o que vai mudar se você mover o mouse lado a lado)
DWORD lookY; // Os jogadores ficam eixo Y (que vai mudar se você mover o mouse para frente e para trás)
DWORD lookXa; // O endereços de olhar X
DWORD lookYa; // O endereço de olhar Y
char name; // Armazena o nome dos jogadores atuais
DWORD namea; // O endereço do nome dos jogadores atuais
} PLAYER_DATA;

Explicação basica.

Code:

#define mBase 0xBD63D8 // mBase = minha base
#define hBase 0xB0D228 // Base = Host 
///
PLAYER_DATA GetMyPlayerData(void)
{
PLAYER_DATA Player; 
ZeroMemory(&Player, sizeof(PLAYER_DATA)); 
Peek((void*)mBase,(void*)&Player.baseadd,4); 
Player.coordEWa = Player.baseadd + 0x8;
Player.coordNSa = Player.baseadd + 0xC;
Player.coordUDa = Player.baseadd + 0x10;
Player.lookXa = Player.baseadd + 0x14;
Player.lookYa = Player.baseadd + 0x18;
Player.namea = Player.baseadd + 0xF4;

Peek((void*)Player.coordEWa,(void*)&Player.coordEW ,4);
Peek((void*)Player.coordNSa,(void*)&Player.coordNS ,4);
Peek((void*)Player.coordUDa,(void*)&Player.coordUD ,4);
Peek((void*)Player.lookXa,(void*)&Player.lookX,4);
Peek((void*)Player.lookYa,(void*)&Player.lookY,4);
Peek((void*)Player.namea,(void*)&Player.name,15);

return Player; 
}
///
PLAYER_DATA GetPlayerData(BYTE PlayerNum) 
{
PLAYER_DATA Player;
ZeroMemory(&Player, sizeof(PLAYER_DATA));
Peek((void*)hBase,(void*)&Player.baseadd,4);

Player.baseadd = Player.baseadd + (PlayerNum*0x388); 
Player.coordEWa = Player.baseadd + 0x8; 
Player.coordNSa = Player.baseadd + 0xC;
Player.coordUDa = Player.baseadd + 0x10;
Player.lookXa = Player.baseadd + 0x14;
Player.lookYa = Player.baseadd + 0x18;
Player.namea = Player.baseadd + 0xF4;

Peek((void*)Player.coordEWa,(void*)&Player.coordEW ,4);
Peek((void*)Player.coordNSa,(void*)&Player.coordNS ,4);
Peek((void*)Player.coordUDa,(void*)&Player.coordUD ,4);
Peek((void*)Player.lookXa,(void*)&Player.lookX,4);
Peek((void*)Player.lookYa,(void*)&Player.lookY,4);
Peek((void*)Player.namea,(void*)&Player.name,15);

return Player;
}

O aimbot funciona em quatro setores. Isso torna as coisas mais fáceis para se descobrir distâncias. Esses são os setores , fica mais facil de ver os inimigos

Setor 1 = Sudeste de nossa posição
Setor 2 = Sudoeste da nossa posição
Setor 3 = Noroeste da nossa posição
Setor 4 = Nordeste da nossa posição

Então, vamos adicionar esses setores para o nosso código fonte. Note que também temos de dizer ao nosso aimbot o que fazer ( nenhum programa é inteligente o suficiente para trabalhar sozinho), por exemplo, a leste de nós, mas o mesmo sobre o eixo norte e sul. Não é necessário colocar o código para que sejam os mesmos em ambos os norte e sul e o eixo lest e oeste, caso contrário você não vai precisar dele para definir um objetivo ,pois você está sobre eles.

Code:

void SetCrosshairOnEnemy(BYTE PlayerNumber)
{
PLAYER_DATA oP = GetPlayerData(PlayerNumber); 
PLAYER_DATA cP = GetMyPlayerData(); 

/*Sec 1*/
if(oP.coordEW > cP.coordEW && oP.coordNS <= cP.coordNS)
{
}

/*Sec 2*/
if(oP.coordEW <= cP.coordEW && oP.coordNS < cP.coordNS)
{
}

/*Sec 3*/
if(oP.coordEW < cP.coordEW && oP.coordNS >= cP.coordNS)
{
}

/*Sec 4*/
if(oP.coordEW >= cP.coordEW && oP.coordNS > cP.coordNS)
{
}
}

Agora, para obter os ângulos precisamos verificar eles, temos que fazer um triângulo entre o eixo leste e oeste, um eixo entre eu e o outro jogador. Então nós temos que encontrar o ângulo

Esta é uma visão de cima:

Um ponto azul = nosso amigo
Um ponto vermelhor = inimigo
Verde = O triângulo que fazemos
Roxo = O ângulo precisamos encontrar
Laranja = A diferença é que temos de trabalhar para fora para o ângulo

Precisariamos lembrar trigonometria, para depois entendermos essa parte , vamos a função tangente:

Tan (ângulo) = Oposto / Adjacentes

Em todos os nossos setores, o Adjacente é a diferença entre leste e oeste, e o oposto é a diferença entre norte e sul. Então, vamos adicionar alguns códigos para a nossa função.

Code:

void SetCrosshairOnEnemy(BYTE PlayerNumber)
{
PLAYER_DATA oP = GetPlayerData(PlayerNumber);
PLAYER_DATA cP = GetMyPlayerData();

double EWdif; 
double NSdif;

/*Sec 1*/
if(oP.coordEW > cP.coordEW && oP.coordNS <= cP.coordNS)
{
EWdif = oP.coordEW - cP.coordEW;
NSdif = cP.coordNS - oP.coordNS;
}

/*Sec 2*/
if(oP.coordEW <= cP.coordEW && oP.coordNS < cP.coordNS)
{
EWdif = cP.coordEW - oP.coordEW;
NSdif = cP.coordNS - oP.coordNS;
}

/*Sec 3*/
if(oP.coordEW < cP.coordEW && oP.coordNS >= cP.coordNS)
{
EWdif = cP.coordEW - oP.coordEW;
NSdif = oP.coordNS - cP.coordNS;
}

/*Sec 4*/
if(oP.coordEW >= cP.coordEW && oP.coordNS > cP.coordNS)
{
EWdif = oP.coordEW - cP.coordEW;
NSdif = oP.coordNS - cP.coordNS;
}
}

Code:

#define mBase 0xBD63D8 // mBase = My Base, always holds my players base address 
# Define HBase 0xB0D228 / HBase / = Host Base, sempre segura ª #define hBase 0xB0D228 // hBase = Host Base, always holds th 

/ / / /// 
PLAYER_DATA GetMyPlayerData (void) PLAYER_DATA GetMyPlayerData(void) 
{ { 
PLAYER_DATA Player / / Criar um PLAYER_DATA branco struct PLAYER_DATA Player; // Create a blank PLAYER_DATA struct 
ZeroMemory (& Player, sizeof (PLAYER_DATA)); / Iniciado tudo a 0 (graças L. Spiro, este resolveu alguns problemas) ZeroMemory(&Player, sizeof(PLAYER_DATA)); // Initiate it all to 0 (thanks L.Spiro, this solved some problems) 
Peek ((void *) Mbase, void * () & Player.baseadd, 4); / / Pega os nossos jogadores da Base Endereço do ponteiro Peek((void*)mBase,(void*)&Player.baseadd,4); // Get our players Base Address from the pointer 

Player.coordEWa = Player.baseadd + 0x8; / / Pega todos os Addies para tudo ... o 0x8, 0xC e merda são os deslocamentos que encontrei para DFX Player.coordEWa = Player.baseadd + 0x8; // Get all the addies for everything...the 0x8, 0xC and shit are the offsets I found for DFX 
Player.coordNSa = Player.baseadd + 0xC; Player.coordNSa = Player.baseadd + 0xC; 
Player.coordUDa Player.baseadd + = 0x10; Player.coordUDa = Player.baseadd + 0x10; 
Player.lookXa Player.baseadd + = 0x14; Player.lookXa = Player.baseadd + 0x14; 
Player.lookYa Player.baseadd + = 0x18; Player.lookYa = Player.baseadd + 0x18; 
Player.namea = Player.baseadd + 0xF4; Player.namea = Player.baseadd + 0xF4; 

Peek ((void *) Player.coordEWa, (void *) & Player.coordEW, 4); / / Agora nós temos todas as Addies, lido a informação de todos eles Peek((void*)Player.coordEWa,(void*)&Player.coordEW ,4); // Now we got all the addies, read in the info from em all 
Peek ((void *) Player.coordNSa, (void *) & Player.coordNS, 4); Peek((void*)Player.coordNSa,(void*)&Player.coordNS ,4); 
Peek ((void *) Player.coordUDa, (void *) & Player.coordUD, 4); Peek((void*)Player.coordUDa,(void*)&Player.coordUD ,4); 
Peek ((void *) Player.lookXa, (void *) & Player.lookX, 4); Peek((void*)Player.lookXa,(void*)&Player.lookX,4); 
Peek ((void *) Player.lookYa, (void *) & Player.lookY, 4); Peek((void*)Player.lookYa,(void*)&Player.lookY,4); 
Peek ((void *) Player.namea, (void *) & Player.name, 15); Peek((void*)Player.namea,(void*)&Player.name,15); 

retorno do jogador / / Dar o nosso PLAYER_DATA Player, como o valor de retorno return Player; // Give our PLAYER_DATA Player, as the return value 
} } 
/ / / /// 
PLAYER_DATA GetPlayerData (BYTE PlayerNum) / / pega o número do jogador como um parâmetro PLAYER_DATA GetPlayerData(BYTE PlayerNum) // Takes the number of the player as a param 
{ { 
Jogador PLAYER_DATA; PLAYER_DATA Player; 
ZeroMemory (& Player, sizeof (PLAYER_DATA)); ZeroMemory(&Player, sizeof(PLAYER_DATA)); 
Peek ((void *) HBase, void * () & Player.baseadd, 4); Peek((void*)hBase,(void*)&Player.baseadd,4); 

Player.baseadd Player.baseadd = + (* PlayerNum 0x388) / / 0x388 é a diferença entre os jogadores, começando com o jogador 1 Player.baseadd = Player.baseadd + (PlayerNum*0x388); // 0x388 is the gap between players, starting with player 1 

Player.coordEWa = Player.baseadd + 0x8; Player.coordEWa = Player.baseadd + 0x8; 
Player.coordNSa = Player.baseadd + 0xC; Player.coordNSa = Player.baseadd + 0xC; 
Player.coordUDa Player.baseadd + = 0x10; Player.coordUDa = Player.baseadd + 0x10; 
Player.lookXa Player.baseadd + = 0x14; Player.lookXa = Player.baseadd + 0x14; 
Player.lookYa Player.baseadd + = 0x18; Player.lookYa = Player.baseadd + 0x18; 
Player.namea = Player.baseadd + 0xF4; Player.namea = Player.baseadd + 0xF4; 

Peek ((void *) Player.coordEWa, (void *) & Player.coordEW, 4); Peek((void*)Player.coordEWa,(void*)&Player.coordEW ,4); 
Peek ((void *) Player.coordNSa, (void *) & Player.coordNS, 4); Peek((void*)Player.coordNSa,(void*)&Player.coordNS ,4); 
Peek ((void *) Player.coordUDa, (void *) & Player.coordUD, 4); Peek((void*)Player.coordUDa,(void*)&Player.coordUD ,4); 
Peek ((void *) Player.lookXa, (void *) & Player.lookX, 4); Peek((void*)Player.lookXa,(void*)&Player.lookX,4); 
Peek ((void *) Player.lookYa, (void *) & Player.lookY, 4); Peek((void*)Player.lookYa,(void*)&Player.lookY,4); 
Peek ((void *) Player.namea, (void *) & Player.name, 15); Peek((void*)Player.namea,(void*)&Player.name,15); 

retorno do jogador; return Player; 
} }

COORDENADAS DOS ANGULOS

Tan (ângulo) = Oposto / Adjacentes Tan(angle) = Opposite/Adjacent
Tan (ângulo) = NSdif / EWdif Tan(angle) = NSdif/EWdif

Code:

void SetCrosshairOnEnemy(BYTE PlayerNumber) 
{ { 
PLAYER_DATA op = GetPlayerData (PlayerNumber); PLAYER_DATA oP = GetPlayerData(PlayerNumber); 
PLAYER_DATA cP = GetMyPlayerData (); PLAYER_DATA cP = GetMyPlayerData(); 

EWdif duplo; double EWdif; 
NSdif duplo; double NSdif; 
angleA dupla / / O ângulo em graus entre o inimigo, a leste, e nós double angleA; // The angle in degrees between the enemy, east, and us 
angleP dupla / / O percentual decimal do ângulo double angleP; // The decimal percentage of the angle 

/ Sec * 1 * / /*Sec 1*/ 
if (cP.coordEW oP.coordEW> & & oP.coordNS <= cP.coordNS) if(oP.coordEW > cP.coordEW && oP.coordNS <= cP.coordNS) 
{ { 
EWdif oP.coordEW = - cP.coordEW; EWdif = oP.coordEW - cP.coordEW; 
NSdif = cP.coordNS - oP.coordNS; NSdif = cP.coordNS - oP.coordNS; 
angleA = atan (NSdif / EWdif) * 57,29578; / / Lembre-se, a 57,29578 é converter de radianos para graus :-) angleA = atan(NSdif/EWdif) * 57.29578; // Remember, the 57.29578 is to convert from radians to degrees :-) 
angleP = (angleA/360); angleP = (angleA/360); 
} } 

/ S * 2 * / /*Sec 2*/ 
if (oP.coordEW <cP.coordEW = & & oP.coordNS <cP.coordNS) if(oP.coordEW <= cP.coordEW && oP.coordNS < cP.coordNS) 
{ { 
EWdif cP.coordEW = - oP.coordEW; EWdif = cP.coordEW - oP.coordEW; 
NSdif = cP.coordNS - oP.coordNS; NSdif = cP.coordNS - oP.coordNS; 
angleA = atan * (NSdif / EWdif) 57,29578; angleA = atan(NSdif/EWdif) * 57.29578; 
angleP = (angleA/360); angleP = (angleA/360); 
} } 

/ Seg * 3 * / /*Sec 3*/ 
if (<& & cP.coordEW oP.coordNS> oP.coordEW cP.coordNS =) if(oP.coordEW < cP.coordEW && oP.coordNS >= cP.coordNS) 
{ { 
EWdif cP.coordEW = - oP.coordEW; EWdif = cP.coordEW - oP.coordEW; 
NSdif = oP.coordNS - cP.coordNS; NSdif = oP.coordNS - cP.coordNS; 
angleA = atan * (NSdif / EWdif) 57,29578; angleA = atan(NSdif/EWdif) * 57.29578; 
angleP = (angleA/360); angleP = (angleA/360); 
} } 

/ Sec * 4 * / /*Sec 4*/ 
if (oP.coordEW> cP.coordEW = & & oP.coordNS> cP.coordNS) if(oP.coordEW >= cP.coordEW && oP.coordNS > cP.coordNS) 
{ { 
EWdif oP.coordEW = - cP.coordEW; EWdif = oP.coordEW - cP.coordEW; 
NSdif = oP.coordNS - cP.coordNS; NSdif = oP.coordNS - cP.coordNS; 
angleA = atan * (NSdif / EWdif) 57,29578; angleA = atan(NSdif/EWdif) * 57.29578; 
angleP = (angleA/360); angleP = (angleA/360); 
} } 
} }

Para entender, lembre-se que 0 em nosso X-Look é este ... e que os valores vão sentido anti-horário. . Vamos voltar para os setores:

Setor 1 (SE) = 0xFFFFFFFF (leste) - o valor dos nossos novos Sector 1 (SE) = 0xFFFFFFFF (east) - our new value
Setor 2 (SW) = 0xFFFFFFFF / 2 (oeste) + nosso novo valor Sector 2 (SW) = 0xFFFFFFFF/2 (west) + our new value
Setor 3 (NW) = 0xFFFFFFFF / 2 (oeste) - o nosso novo valor Sector 3 (NW) = 0xFFFFFFFF/2 (west) - our new value
Setor 4 (NE) = 0 (leste) + nosso novo valor Sector 4 (NE) = 0 (east) + our new value

Antes de escrevê-los, porém, temos de convertê-los de volta para DWORDs, de duplas. Before we write them though, we have to convert them back to DWORDs, from doubles. Aqui está o novo código: Here's the new code :

Code:

void SetCrosshairOnEnemy(BYTE PlayerNumber) 
{ { 
PLAYER_DATA op = GetPlayerData (PlayerNumber); PLAYER_DATA oP = GetPlayerData(PlayerNumber); 
PLAYER_DATA cP = GetMyPlayerData (); PLAYER_DATA cP = GetMyPlayerData(); 

EWdif duplo; double EWdif; 
NSdif duplo; double NSdif; 
dupla angleA; double angleA; 
angleP duplo; double angleP; 
newValue dupla / / Para segurar o nosso valor novo casal double newValue; // To hold our new double value 
DWORD newValue2 / / Para converter a nossa volta em dobro DWORD pronto para escrever DWORD newValue2; // To convert our double back into DWORD ready for writing 

halfCircle dupla = 0xFFFFFFFF / 2 / / Só para tornar o código :-) um pouco mais legível double halfCircle = 0xFFFFFFFF/2; // Just to make the code a bit more readable :-) 

/ Sec * 1 * / /*Sec 1*/ 
if (cP.coordEW oP.coordEW> & & oP.coordNS <= cP.coordNS) if(oP.coordEW > cP.coordEW && oP.coordNS <= cP.coordNS) 
{ { 
EWdif oP.coordEW = - cP.coordEW; EWdif = oP.coordEW - cP.coordEW; 
NSdif = cP.coordNS - oP.coordNS; NSdif = cP.coordNS - oP.coordNS; 
angleA = atan * (NSdif / EWdif) 57,29578; angleA = atan(NSdif/EWdif) * 57.29578; 
angleP = (angleA/360); angleP = (angleA/360); 
newValue = 0xFFFFFFFF - (0xFFFFFFFF angleP *) / / Como descrito acima :-) newValue = 0xFFFFFFFF - (0xFFFFFFFF*angleP); // As described above :-) 
newValue2 newValue = / / Coloque-o em DWORD (compilação pode ficar alertas sobre a perda de dados .. isso é a razão pela qual nós estamos fazendo isso :-) newValue2 = newValue; // Put it into DWORD (may get compile warnings about losing data..thats the whole reason we're doing it :-) 
Poke (cP.lookXa (void *) & newValue2, 4); / / Escreve o nosso novo valor Poke((void*)cP.lookXa, &newValue2,4); // Write our new value 
} } 

/ S * 2 * / /*Sec 2*/ 
if (oP.coordEW <cP.coordEW = & & oP.coordNS <cP.coordNS) if(oP.coordEW <= cP.coordEW && oP.coordNS < cP.coordNS) 
{ { 
EWdif cP.coordEW = - oP.coordEW; EWdif = cP.coordEW - oP.coordEW; 
NSdif = cP.coordNS - oP.coordNS; NSdif = cP.coordNS - oP.coordNS; 
angleA = atan * (NSdif / EWdif) 57,29578; angleA = atan(NSdif/EWdif) * 57.29578; 
angleP = (angleA/360); angleP = (angleA/360); 
halfCircle newValue = + (* angleP 0xFFFFFFFF); newValue = halfCircle + (0xFFFFFFFF*angleP); 
newValue2 newValue =; newValue2 = newValue; 
Poke (cP.lookXa (void *) & newValue2, 4); Poke((void*)cP.lookXa, &newValue2,4); 
} } 

/ Seg * 3 * / /*Sec 3*/ 
if (<& & cP.coordEW oP.coordNS> oP.coordEW cP.coordNS =) if(oP.coordEW < cP.coordEW && oP.coordNS >= cP.coordNS) 
{ { 
EWdif cP.coordEW = - oP.coordEW; EWdif = cP.coordEW - oP.coordEW; 
NSdif = oP.coordNS - cP.coordNS; NSdif = oP.coordNS - cP.coordNS; 
angleA = atan * (NSdif / EWdif) 57,29578; angleA = atan(NSdif/EWdif) * 57.29578; 
angleP = (angleA/360); angleP = (angleA/360); 
halfCircle newValue = - (0xFFFFFFFF angleP *); newValue = halfCircle - (0xFFFFFFFF*angleP); 
newValue2 newValue =; newValue2 = newValue; 
Poke (cP.lookXa (void *) & newValue2, 4); Poke((void*)cP.lookXa, &newValue2,4); 
} } 

/ Sec * 4 * / /*Sec 4*/ 
if (oP.coordEW> cP.coordEW = & & oP.coordNS> cP.coordNS) if(oP.coordEW >= cP.coordEW && oP.coordNS > cP.coordNS) 
{ { 
EWdif oP.coordEW = - cP.coordEW; EWdif = oP.coordEW - cP.coordEW; 
NSdif = oP.coordNS - cP.coordNS; NSdif = oP.coordNS - cP.coordNS; 
angleA = atan * (NSdif / EWdif) 57,29578; angleA = atan(NSdif/EWdif) * 57.29578; 
angleP = (angleA/360); angleP = (angleA/360); 
newValue = 0 + (* angleP 0xFFFFFFFF); newValue = 0 + (0xFFFFFFFF*angleP); 
newValue2 newValue =; newValue2 = newValue; 
Poke (cP.lookXa (void *) & newValue2, 4); Poke((void*)cP.lookXa, &newValue2,4); 
} } 
} }

Desta vez, imagine nós já temos X-olhar fechado sobre eles, e está olhando diretamente em frente .... o ponto em frente que é a distância mesmo nível de distância de nós como ele é, que está logo acima / abaixo dele. Isso é um ponto, então o nosso leitor, então o jogador adversário.

A distância entre nós com ele ao longo de uma visão de nível é obtido por Pitágoras no EWdif e NWdif. Em seguida, usamos isso, e as UDdif como o oposto e adjacente e fazer as mesmas coisas de antes. Desta vez, porém, precisamos incluir um pouco para que o inimigo está na mesma altura que nós também

Code:

void SetCrosshairOnEnemy(BYTE PlayerNumber) 
{ { 
PLAYER_DATA op = GetPlayerData (PlayerNumber); PLAYER_DATA oP = GetPlayerData(PlayerNumber); 
PLAYER_DATA cP = GetMyPlayerData (); PLAYER_DATA cP = GetMyPlayerData(); 

EWdif duplo; double EWdif; 
NSdif duplo; double NSdif; 
UDdif duplo; double UDdif; 

dupla angleA; double angleA; 
angleP duplo; double angleP; 
angleB duplo; double angleB; 
angleBP duplo; double angleBP; 

newValue duplo; double newValue; 
DWORD newValue2; DWORD newValue2; 

newValueb duplo; double newValueb; 
DWORD newValueb2; DWORD newValueb2; 

halfCircle dupla = 0xFFFFFFFF / 2; double halfCircle = 0xFFFFFFFF/2; 

/ Sec * 1 * / /*Sec 1*/ 
if (cP.coordEW oP.coordEW> & & oP.coordNS <= cP.coordNS) if(oP.coordEW > cP.coordEW && oP.coordNS <= cP.coordNS) 
{ { 
EWdif oP.coordEW = - cP.coordEW; EWdif = oP.coordEW - cP.coordEW; 
NSdif = cP.coordNS - oP.coordNS; NSdif = cP.coordNS - oP.coordNS; 
angleA = atan * (NSdif / EWdif) 57,29578; angleA = atan(NSdif/EWdif) * 57.29578; 
angleP = (angleA/360); angleP = (angleA/360); 
newValue = 0xFFFFFFFF - (* angleP 0xFFFFFFFF); newValue = 0xFFFFFFFF - (0xFFFFFFFF*angleP); 
newValue2 newValue =; newValue2 = newValue; 
Poke (cP.lookXa (void *) & newValue2, 4); Poke((void*)cP.lookXa, &newValue2,4); 
} } 

/ S * 2 * / /*Sec 2*/ 
if (oP.coordEW <cP.coordEW = & & oP.coordNS <cP.coordNS) if(oP.coordEW <= cP.coordEW && oP.coordNS < cP.coordNS) 
{ { 
EWdif cP.coordEW = - oP.coordEW; EWdif = cP.coordEW - oP.coordEW; 
NSdif = cP.coordNS - oP.coordNS; NSdif = cP.coordNS - oP.coordNS; 
angleA = atan * (NSdif / EWdif) 57,29578; angleA = atan(NSdif/EWdif) * 57.29578; 
angleP = (angleA/360); angleP = (angleA/360); 
halfCircle newValue = + (* angleP 0xFFFFFFFF); newValue = halfCircle + (0xFFFFFFFF*angleP); 
newValue2 newValue =; newValue2 = newValue; 
Poke (cP.lookXa (void *) & newValue2, 4); Poke((void*)cP.lookXa, &newValue2,4); 
} } 

/ Seg * 3 * / /*Sec 3*/ 
if (<& & cP.coordEW oP.coordNS> oP.coordEW cP.coordNS =) if(oP.coordEW < cP.coordEW && oP.coordNS >= cP.coordNS) 
{ { 
EWdif cP.coordEW = - oP.coordEW; EWdif = cP.coordEW - oP.coordEW; 
NSdif = oP.coordNS - cP.coordNS; NSdif = oP.coordNS - cP.coordNS; 
angleA = atan * (NSdif / EWdif) 57,29578; angleA = atan(NSdif/EWdif) * 57.29578; 
angleP = (angleA/360); angleP = (angleA/360); 
halfCircle newValue = - (0xFFFFFFFF angleP *); newValue = halfCircle - (0xFFFFFFFF*angleP); 
newValue2 newValue =; newValue2 = newValue; 
Poke (cP.lookXa (void *) & newValue2, 4); Poke((void*)cP.lookXa, &newValue2,4); 
} } 

/ Sec * 4 * / /*Sec 4*/ 
if (oP.coordEW> cP.coordEW = & & oP.coordNS> cP.coordNS) if(oP.coordEW >= cP.coordEW && oP.coordNS > cP.coordNS) 
{ { 
EWdif oP.coordEW = - cP.coordEW; EWdif = oP.coordEW - cP.coordEW; 
NSdif = oP.coordNS - cP.coordNS; NSdif = oP.coordNS - cP.coordNS; 
angleA = atan * (NSdif / EWdif) 57,29578; angleA = atan(NSdif/EWdif) * 57.29578; 
angleP = (angleA/360); angleP = (angleA/360); 
newValue = 0 + (* angleP 0xFFFFFFFF); newValue = 0 + (0xFFFFFFFF*angleP); 
newValue2 newValue =; newValue2 = newValue; 
Poke (cP.lookXa (void *) & newValue2, 4); Poke((void*)cP.lookXa, &newValue2,4); 
} } 

/ / Feito o X-look, agora isso é para o olhar Y- // Done the X-look, now this is for the Y-look 

flatDist dupla = sqrt ((EWdif EWdif *) + (NSdif NSdif *)); / / Pega o nível de distância entre nós eo inimigo, usando Pitágoras double flatDist = sqrt((EWdif*EWdif)+(NSdif*NSdif)); // Get the level distance between us and the enemy, using pythagoras 

if (oP.coordUD == cP.coordUD) if(oP.coordUD == cP.coordUD) 
{ { 
BYTE ZERO4 [4] = {0x00, 0x00, 0x00, 0x00}; BYTE zero4[4] = {0x00,0x00,0x00,0x00}; 
Poke (cP.lookYa (void *), ZERO4, 4); / / altura Se somos iguais, definir o nosso olhar para Y 0 (nível) Poke((void*)cP.lookYa,zero4, 4); // If we are equal height, set our Y-look to 0 (level) 

} Else if (oP.coordUD> cP.coordUD) } else if(oP.coordUD > cP.coordUD) 
{ { 
UDdif = oP.coordUD - cP.coordUD / / Trabalho a nossa UDdif UDdif = oP.coordUD - cP.coordUD; // Work out our UDdif 
angleB = atan * (UDdif flatDist /) 57,29578; / mesmas coisas antigas como antes angleB = atan(UDdif/flatDist) * 57.29578; // Same old stuff as before 
angleBP = (angleB/360); angleBP = (angleB/360); 
newValueb = 0 + (* angleBP 0xFFFFFFFF); newValueb = 0 + (0xFFFFFFFF*angleBP); 
newValueb2 newValueb =; newValueb2 = newValueb; 
Poke (cP.lookYa (void *) & newValueb2, 4); Poke((void*)cP.lookYa, &newValueb2,4); 

} Else if (oP.coordUD <cP.coordUD) } else if (oP.coordUD < cP.coordUD) 
{ { 
UDdif = cP.coordUD - oP.coordUD; UDdif = cP.coordUD - oP.coordUD; 
angleB = atan * (UDdif flatDist /) 57,29578; angleB = atan(UDdif/flatDist) * 57.29578; 
angleBP = (angleB/360); angleBP = (angleB/360); 
newValueb = 0xFFFFFFFF - (* angleBP 0xFFFFFFFF); newValueb = 0xFFFFFFFF - (0xFFFFFFFF*angleBP); 
newValueb2 newValueb =; newValueb2 = newValueb; 
Poke (cP.lookYa (void *) & newValueb2, 4); Poke((void*)cP.lookYa, &newValueb2,4); 
} } 
} }

E aí temos que, no início do esqueleto de um aimbot.

Você pode adicionar outras caracteristica a seu aimbot , tais como:

Lista negra (o objectivo é só para certas pessoas ... use a parte do nome do jogador estrutura para verificar se elas estão nele ou não)

Conta de lag (balas de chumbo em frente de pessoas para dar conta do atraso no jogo (se o seu MP), e as viagens de bala)

Conta de bala de imersão (o objectivo é acima de um jogador assim balas mergulhar nelas)

Arcos das Granadas (treino onde jogar granadas em ordem para que vá em seu alvo)

Inimigos como único objetivo (para que não visam a companheiros de equipa)

Só mirar se estiver vivo (para nao ficar mirando no corpo no chão)

Há tantas coisas que você pode adicionar a este, isto é apenas a base.

Basta pensar em todas as coisas que você faz durante o jogo

Se você não é programador ( cerca de 99,9 % do site não são) , nem tente entender o código , é a mesma coisa de você querer pular de para-quedas sozinho , sem nehuma instrução.

Foi usado google tradutor , então varias palavras estão fora da concordancia nominal e verbal. Na base ( // ) são comentarios , que não tem efeitos nehum na base.

CRÉDITOS:

A mim @mahsartor pela tradução e explicação de algumas funções.

E a EvoByte pela source.

@we11ngton
@soad
@Sorting Hat
@habacuque
@leoissobackup
@Strikex
@ para todos os programadores

Source Aimbot ²

Post a Reply

Tags for this Thread