Ultima modifica:
Ringraziamento speciale a nome di tutti a zio mark grazie ! [R.I.P Banned]
Chi non ha mai desiderato creare un aimbot? Bene siamo solo io e quel ciccione peloso
Allora , quello di cui abbiamo bisogno sono le coordinate X , Y e Z (nord est ovest che ci servirà poi per determinare la posizione dei nemici , vanno bene anche altri punti di riferimento , il punto è comprendere il concetto e l'idea base di come funzioni un aimbot).
Una volta presi potremo determinare l'angolazione del nemico in base al nostro punto
Ok ora che avete capito la teoria , buttiamoci nella pratica !
Prima di fare ciò abbiamo bisogno di 3 funzioni
Player_data? Esatto , mi rende il programma più pulito , mi piace usare certe strutture. Inoltre player data ci puo' fornire informazioni sul player come
Non so perchè uso gli address per tutto nelle strutture ma tutto ciò lo si puo' fare benissimo in una giornata.
Comunque sia tutto ciò ci è utile sia per noi che per il nostro aimbot
Il metodo più facile di iniziare è usar artmoney's text search
Co-ords:
NS - Muoversi verso nord , search increased , muoversi verso sud , search descreased
EW - Muoversi verso est, search increased, muoversi verso ovest, search decreased
UD - Muoversi verso l'alto , search increased, muoversi verso il basso, search decreased
LookX - Muovere il mouse destra sinistra, search has changed...
LookY - Muovere il mouse verso il basso o verso l'alto, search has changed
Devi essere in grado di trovare l'address base da solo ed il pointer trovarlo in game.
Io uso 2 pointers , 1 quando i points del player sono 0 ( o 1 , 1 posto nella memoria) e 1 come punto base dell'address del mio giocatore.
Ora possiamo modificare le funzioni di GetMyPlayerData e getPlayerData per prendere le nostre info.
In cima sono definite le basi.
Ok adesso abbiamo tutte le funzioni e le informazioni che ci servono , è il momento di creare l'aimbot!
Non abbiate troppe speranze , dovete leggere ancora molto , bevete qualcosa e tornate colmi di pazienza e calma
//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
Ok , per fare questo serve la matematica , se non ne sapete potete pure rinunciare.
L'aimbot funziona in 4 settori. La parte più facile è per trovare le distanze , iniziamo da quella.
Prima di tutto dobbiamo determinare la posizione.
Sector 1 = South-East della nostra posizione
Sector 2 = South-West della nostra posizione
Sector 3 = North-West della nostra posizione
Sector 4 = North-East della nostra posizione
Adesso aggiungiamo i settori al nostro source
Nota : Dobbiamo dire al nostro aimbot cosa fare anche quando , ad esempio , sono a sud rispetto a noi.
Adesso dobbiamo , però , trovare l'angolo , motivo per il quale faremo un triangolo tra EW Axis , noi , e il player.
Eccovi un piccolo disegnino
Piccola legenda :
Player blu = Noi
Player rosso = Nemico (no dai?)
Verde = Il triangolo che facciamo
Viola = L'angolo che dobbiamo trovare
Arancione = la distanza degli angoli
Adesso possiamo trovare la funzione tangente
Tan(angle)=Opposite/Adjacent
In tutti i nostri settori , la tangente è la differenza di EW e l'opposta NS.
Ora però tramutiamo ciò in codice
Nota : I calcoli non sono sempre e tutti uguali ! Devi fare il più grande sul più piccolo e non viceversa
Bene , adesso che sappiamo ciò basta applicare la formula :
Tan(angle) = Opposite/Adjacent
Tan(angle) = NSdif/EWdif
Adesso dobbiamo trovare la formula inversa per ricavare la tangente dell'angolo.
La funzione da utilizzare è atan (potete pure utilizzare atan2, ma non c'è tempo adesso di mostrarvi come si fa).
Quest'ultimo prende 1 doppio parametro e ridà il doppio del valore dell'angolo in radianti. Ma ciò per noi non va bene , noi vogliamo l'angolo in gradi.
Per trasformare i radianti in angoli basta fare una moltiplicazione di "57.29578" lo potete trovare facilmente su internet .
Comunque sia per la nostra vista X non abbiamo un massimo di 360 ° , abbiamo aumentato a 0xFFFFFFFF (4294967295) , adesso dobbiamo trovare la percentuale di questo angolo in 360°.
Per trovarlo basta fare così , ad esempio se l'angolo è di 90
90/360=0.25(percentuale decimale dell'angolo)
0xFFFFFFFF * 0.25 = 3FFFFFFF , questo è il value che ci servirà.
Motivo per il quale bisogna mettere ciò nel source !
Adesso è... il momento di un altro disegno da babbuino !
Ricorda che lo 0 nella nostra vista X è est..
Sector 1 (SE) = 0xFFFFFFFF (est)- il nostro nuovo valore
Sector 2 (SW) = 0xFFFFFFFF/2 (ovest) + il nostro nuovo valore
Sector 3 (NW) = 0xFFFFFFFF/2 (ovest) - il nostro nuovo valore
Sector 4 (NE) = 0 (est) + il nostro nuovo valore
Adesso da valori doubles li dobbiamo trasformare in DWORDS. Quindi questa è la nuova parte di codice :
Wohohoho adesso abbiamo la nostra vista X del nemico.
Se hai letto tutto quello scritto sopra ti meriti un applauso *applausi* sto schifo ci ho messo 3 anni a scriverlo![:\](/forum/data/assets/smilies/mhhae.gif "Mhhae :\")
Ok adesso passiamo alla vista Y , ma prima vi conviene bere ancora qualcos'altro e fare uno spuntino
//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
Ottimo , adesso per la nostra vista Y indovinate che bisogna fare?
Un bellissimo... triangolo ! Dato che la vista X l'abbiamo già fatta , adesso ci rimane la quella frontale e il livello di distanza tra noi e il nemico quanto sopra sotto di noi è. Questo è il metodo 1 sopra citato.
Ed ora è il momento di.. un altro disegno da babbuino! (dovrei mettere sto schifo su devian art)
Adesso abbiamo solo 2 'settori' .. se il nemico è sopra o sotto di noi.
Il dislivello tra noi e lui è descritto nel teorema di pitagora EWdif and NWdif
Infatti noi utilizzeremo quello. Ed eccovi il codice :
E adesso abbiamo lo scheletro di un aimbot . Bisogna aggiungere solo poche cose :
Shitlist (Head body e quelle cazzate)
Granate (l'arco della granata)
Sparare solo al team nemico.
Have fun , fine!
Chi non ha mai desiderato creare un aimbot? Bene siamo solo io e quel ciccione peloso
Come creare un aimbot !
Requisiti utili :
Cercare pointers per risolvere DMA
Come è strutturato il gioco
Conoscenza della matematica compresa la trigonometria
(Esattamente 3\4 di community hanno appena chiuso la discussione , ma tu sei tra quei pochi che è veramente interessato , congratulazioni !)
Requisiti utili :
Cercare pointers per risolvere DMA
Come è strutturato il gioco
Conoscenza della matematica compresa la trigonometria
(Esattamente 3\4 di community hanno appena chiuso la discussione , ma tu sei tra quei pochi che è veramente interessato , congratulazioni !)
Allora , quello di cui abbiamo bisogno sono le coordinate X , Y e Z (nord est ovest che ci servirà poi per determinare la posizione dei nemici , vanno bene anche altri punti di riferimento , il punto è comprendere il concetto e l'idea base di come funzioni un aimbot).
Una volta presi potremo determinare l'angolazione del nemico in base al nostro punto
Ok ora che avete capito la teoria , buttiamoci nella pratica !
Prima di fare ciò abbiamo bisogno di 3 funzioni
Codice:
PLAYER_DATA GetMyPlayerData(void)
PLAYER_DATA GetPlayerData(BYTE PlayerNumber)
void SetCrosshairOnEnemy(BYTE PlayerNumber)Player_data? Esatto , mi rende il programma più pulito , mi piace usare certe strutture. Inoltre player data ci puo' fornire informazioni sul player come
Codice:
typedef struct _PLAYER_DATA {
DWORD baseadd; // address base
DWORD coordEW; // est ovest coordinate (x)
DWORD coordNS; // nord sud (Y) coordinate
DWORD coordUD; // sopra sotto (Z) coordinate
DWORD coordEWa; // le coordinate del player (est ovest)
DWORD coordNSa; // Le coordinate del player (nord sud)
DWORD coordUDa; // Le coordinate del player (sopra sotto)
DWORD lookX; // La vista dell'utente dal punto X (cambia se ti muovi)
DWORD lookY; // La vista dell'utente dal punto Y (cambia se muovi il mouse)
DWORD lookXa; // L'address della X
DWORD lookYa; // L'address della Y
char name; // Il nome del player
DWORD namea; // L'address del nome
} PLAYER_DATA;Non so perchè uso gli address per tutto nelle strutture ma tutto ciò lo si puo' fare benissimo in una giornata.
Comunque sia tutto ciò ci è utile sia per noi che per il nostro aimbot
Il metodo più facile di iniziare è usar artmoney's text search
Co-ords:
NS - Muoversi verso nord , search increased , muoversi verso sud , search descreased
EW - Muoversi verso est, search increased, muoversi verso ovest, search decreased
UD - Muoversi verso l'alto , search increased, muoversi verso il basso, search decreased
LookX - Muovere il mouse destra sinistra, search has changed...
LookY - Muovere il mouse verso il basso o verso l'alto, search has changed
Devi essere in grado di trovare l'address base da solo ed il pointer trovarlo in game.
Io uso 2 pointers , 1 quando i points del player sono 0 ( o 1 , 1 posto nella memoria) e 1 come punto base dell'address del mio giocatore.
Ora possiamo modificare le funzioni di GetMyPlayerData e getPlayerData per prendere le nostre info.
In cima sono definite le basi.
Codice:
#define mBase 0xBD63D8 // mBase = La nostra base
#define hBase 0xB0D228 // hBase = La base dell'host
///
PLAYER_DATA GetMyPlayerData(void)
{
PLAYER_DATA Player; // Crea la struttura player data vuota
ZeroMemory(&Player, sizeof(PLAYER_DATA)); //L'inizia da 0
Peek((void*)mBase,(void*)&Player.baseadd,4); // Prende gli address base di player dal pointer
Player.coordEWa = Player.baseadd + 0x8; // Prende le addies di tutto...i 0x8, 0xC e l'altro schifo sono offset
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); // Noi adesso abbiamo tutti gli addies addies,legge tutte le info da em
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; // Da al nostro player data player e ne riceve il value
}
///
PLAYER_DATA GetPlayerData(BYTE PlayerNum) // Prende il numero del player come parametro
PLAYER_DATA Player;
ZeroMemory(&Player, sizeof(PLAYER_DATA));
Peek((void*)hBase,(void*)&Player.baseadd,4);
Player.baseadd = Player.baseadd + (PlayerNum*0x388); // 0x388 è la distanza dei player partendo dal player 1
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;
}///Non abbiate troppe speranze , dovete leggere ancora molto , bevete qualcosa e tornate colmi di pazienza e calma
//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
Ok , per fare questo serve la matematica , se non ne sapete potete pure rinunciare.
L'aimbot funziona in 4 settori. La parte più facile è per trovare le distanze , iniziamo da quella.
Prima di tutto dobbiamo determinare la posizione.
Sector 1 = South-East della nostra posizione
Sector 2 = South-West della nostra posizione
Sector 3 = North-West della nostra posizione
Sector 4 = North-East della nostra posizione
Adesso aggiungiamo i settori al nostro source
Nota : Dobbiamo dire al nostro aimbot cosa fare anche quando , ad esempio , sono a sud rispetto a noi.
Codice:
void SetCrosshairOnEnemy(BYTE PlayerNumber){
PLAYER_DATA oP = GetPlayerData(PlayerNumber); // oP = Il posto del player opposto (il nemico)
PLAYER_DATA cP = GetMyPlayerData(); // cP = Player corrente (il nostro giocatore) .. scusate per i nomi difficili asd
/*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)Adesso dobbiamo , però , trovare l'angolo , motivo per il quale faremo un triangolo tra EW Axis , noi , e il player.
Eccovi un piccolo disegnino
Piccola legenda :
Player blu = Noi
Player rosso = Nemico (no dai?)
Verde = Il triangolo che facciamo
Viola = L'angolo che dobbiamo trovare
Arancione = la distanza degli angoli
Adesso possiamo trovare la funzione tangente
Tan(angle)=Opposite/Adjacent
In tutti i nostri settori , la tangente è la differenza di EW e l'opposta NS.
Ora però tramutiamo ciò in codice
Codice:
void SetCrosshairOnEnemy(BYTE PlayerNumber)
{
PLAYER_DATA oP = GetPlayerData(PlayerNumber);
PLAYER_DATA cP = GetMyPlayerData();
double EWdif; // Dopo avremo bisogno di 2 differenze
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;
}
}Nota : I calcoli non sono sempre e tutti uguali ! Devi fare il più grande sul più piccolo e non viceversa
Bene , adesso che sappiamo ciò basta applicare la formula :
Tan(angle) = Opposite/Adjacent
Tan(angle) = NSdif/EWdif
Adesso dobbiamo trovare la formula inversa per ricavare la tangente dell'angolo.
La funzione da utilizzare è atan (potete pure utilizzare atan2, ma non c'è tempo adesso di mostrarvi come si fa).
Quest'ultimo prende 1 doppio parametro e ridà il doppio del valore dell'angolo in radianti. Ma ciò per noi non va bene , noi vogliamo l'angolo in gradi.
Per trasformare i radianti in angoli basta fare una moltiplicazione di "57.29578" lo potete trovare facilmente su internet .
Comunque sia per la nostra vista X non abbiamo un massimo di 360 ° , abbiamo aumentato a 0xFFFFFFFF (4294967295) , adesso dobbiamo trovare la percentuale di questo angolo in 360°.
Per trovarlo basta fare così , ad esempio se l'angolo è di 90
90/360=0.25(percentuale decimale dell'angolo)
0xFFFFFFFF * 0.25 = 3FFFFFFF , questo è il value che ci servirà.
Motivo per il quale bisogna mettere ciò nel source !
Codice:
void SetCrosshairOnEnemy(BYTE PlayerNumber){
PLAYER_DATA oP = GetPlayerData(PlayerNumber);
PLAYER_DATA cP = GetMyPlayerData();
double EWdif;
double NSdif;
double angleA; // l'angolo in gradi tra noi e il nemico
double angleP; // la percentuale dell'angolo
/*Sec 1*/
if(oP.coordEW > cP.coordEW && oP.coordNS <= cP.coordNS)
{
EWdif = oP.coordEW - cP.coordEW;
NSdif = cP.coordNS - oP.coordNS;
angleA = atan(NSdif/EWdif) * 57.29578; // Ricorda, il 57.29578 è per convertire da radianti a gradi :-)
angleP = (angleA/360);
}
/*Sec 2*/
if(oP.coordEW <= cP.coordEW && oP.coordNS < cP.coordNS)
{
EWdif = cP.coordEW - oP.coordEW;
NSdif = cP.coordNS - oP.coordNS;
angleA = atan(NSdif/EWdif) * 57.29578;
angleP = (angleA/360);
}
/*Sec 3*/
if(oP.coordEW < cP.coordEW && oP.coordNS >= cP.coordNS)
{
EWdif = cP.coordEW - oP.coordEW;
NSdif = oP.coordNS - cP.coordNS;
angleA = atan(NSdif/EWdif) * 57.29578;
angleP = (angleA/360);
}
/*Sec 4*/
if(oP.coordEW >= cP.coordEW && oP.coordNS > cP.coordNS)
{
EWdif = oP.coordEW - cP.coordEW;
NSdif = oP.coordNS - cP.coordNS;
angleA = atan(NSdif/EWdif) * 57.29578;
angleP = (angleA/360);
}
}Adesso è... il momento di un altro disegno da babbuino !
Ricorda che lo 0 nella nostra vista X è est..
Sector 1 (SE) = 0xFFFFFFFF (est)- il nostro nuovo valore
Sector 2 (SW) = 0xFFFFFFFF/2 (ovest) + il nostro nuovo valore
Sector 3 (NW) = 0xFFFFFFFF/2 (ovest) - il nostro nuovo valore
Sector 4 (NE) = 0 (est) + il nostro nuovo valore
Adesso da valori doubles li dobbiamo trasformare in DWORDS. Quindi questa è la nuova parte di codice :
Codice:
void SetCrosshairOnEnemy(BYTE PlayerNumber)
{
PLAYER_DATA oP = GetPlayerData(PlayerNumber);
PLAYER_DATA cP = GetMyPlayerData();
double EWdif;
double NSdif;
double angleA;
double angleP;
double newValue; // Double value nuovo
DWORD newValue2; // Per convertire da double a dword
double halfCircle = 0xFFFFFFFF/2; // per rendere il codice più leggibile :-)
/*Sec 1*/
if(oP.coordEW > cP.coordEW && oP.coordNS <= cP.coordNS)
{
EWdif = oP.coordEW - cP.coordEW;
NSdif = cP.coordNS - oP.coordNS;
angleA = atan(NSdif/EWdif) * 57.29578;
angleP = (angleA/360);
newValue = 0xFFFFFFFF - (0xFFFFFFFF*angleP); // descritto sopra :-)
newValue2 = newValue; //
Poke((void*)cP.lookXa, &newValue2,4); // scrive i nostri nuovi valori
}
/*Sec 2*/
if(oP.coordEW <= cP.coordEW && oP.coordNS < cP.coordNS)
{
EWdif = cP.coordEW - oP.coordEW;
NSdif = cP.coordNS - oP.coordNS;
angleA = atan(NSdif/EWdif) * 57.29578;
angleP = (angleA/360);
newValue = halfCircle + (0xFFFFFFFF*angleP);
newValue2 = newValue;
Poke((void*)cP.lookXa, &newValue2,4);
}
/*Sec 3*/
if(oP.coordEW < cP.coordEW && oP.coordNS >= cP.coordNS)
{
EWdif = cP.coordEW - oP.coordEW;
NSdif = oP.coordNS - cP.coordNS;
angleA = atan(NSdif/EWdif) * 57.29578;
angleP = (angleA/360);
newValue = halfCircle - (0xFFFFFFFF*angleP);
newValue2 = newValue;
Poke((void*)cP.lookXa, &newValue2,4);
}
/*Sec 4*/
if(oP.coordEW >= cP.coordEW && oP.coordNS > cP.coordNS)
{
EWdif = oP.coordEW - cP.coordEW;
NSdif = oP.coordNS - cP.coordNS;
angleA = atan(NSdif/EWdif) * 57.29578;
angleP = (angleA/360);
newValue = 0 + (0xFFFFFFFF*angleP);
newValue2 = newValue;
Poke((void*)cP.lookXa, &newValue2,4);Wohohoho adesso abbiamo la nostra vista X del nemico.
Se hai letto tutto quello scritto sopra ti meriti un applauso *applausi* sto schifo ci ho messo 3 anni a scriverlo
Ok adesso passiamo alla vista Y , ma prima vi conviene bere ancora qualcos'altro e fare uno spuntino
//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
Ottimo , adesso per la nostra vista Y indovinate che bisogna fare?
Un bellissimo... triangolo ! Dato che la vista X l'abbiamo già fatta , adesso ci rimane la quella frontale e il livello di distanza tra noi e il nemico quanto sopra sotto di noi è. Questo è il metodo 1 sopra citato.
Ed ora è il momento di.. un altro disegno da babbuino! (dovrei mettere sto schifo su devian art
)
Adesso abbiamo solo 2 'settori' .. se il nemico è sopra o sotto di noi.
Il dislivello tra noi e lui è descritto nel teorema di pitagora EWdif and NWdif
Infatti noi utilizzeremo quello. Ed eccovi il codice :
Codice:
void SetCrosshairOnEnemy(BYTE PlayerNumber)
{
PLAYER_DATA oP = GetPlayerData(PlayerNumber);
PLAYER_DATA cP = GetMyPlayerData();
double EWdif;
double NSdif;
double UDdif;
double angleA;
double angleP;
double angleB;
double angleBP;
double newValue;
DWORD newValue2;
double newValueb;
DWORD newValueb2;
double halfCircle = 0xFFFFFFFF/2;
/*Sec 1*/
if(oP.coordEW > cP.coordEW && oP.coordNS <= cP.coordNS)
{
EWdif = oP.coordEW - cP.coordEW;
NSdif = cP.coordNS - oP.coordNS;
angleA = atan(NSdif/EWdif) * 57.29578;
angleP = (angleA/360);
newValue = 0xFFFFFFFF - (0xFFFFFFFF*angleP);
newValue2 = newValue;
Poke((void*)cP.lookXa, &newValue2,4);
}
/*Sec 2*/
if(oP.coordEW <= cP.coordEW && oP.coordNS < cP.coordNS)
{
EWdif = cP.coordEW - oP.coordEW;
NSdif = cP.coordNS - oP.coordNS;
angleA = atan(NSdif/EWdif) * 57.29578;
angleP = (angleA/360);
newValue = halfCircle + (0xFFFFFFFF*angleP);
newValue2 = newValue;
Poke((void*)cP.lookXa, &newValue2,4);
}
/*Sec 3*/
if(oP.coordEW < cP.coordEW && oP.coordNS >= cP.coordNS)
{
EWdif = cP.coordEW - oP.coordEW;
NSdif = oP.coordNS - cP.coordNS;
angleA = atan(NSdif/EWdif) * 57.29578;
angleP = (angleA/360);
newValue = halfCircle - (0xFFFFFFFF*angleP);
newValue2 = newValue;
Poke((void*)cP.lookXa, &newValue2,4);
}
/*Sec 4*/
if(oP.coordEW >= cP.coordEW && oP.coordNS > cP.coordNS)
{
EWdif = oP.coordEW - cP.coordEW;
NSdif = oP.coordNS - cP.coordNS;
angleA = atan(NSdif/EWdif) * 57.29578;
angleP = (angleA/360);
newValue = 0 + (0xFFFFFFFF*angleP);
newValue2 = newValue;
Poke((void*)cP.lookXa, &newValue2,4);
}
//Questo è per la vista X , ora la vista Y
double flatDist = sqrt((EWdif*EWdif)+(NSdif*NSdif)); // Ottiene il livello tra noi il nemico usando pitagora
if(oP.coordUD == cP.coordUD)
{
BYTE zero4[4] = {0x00,0x00,0x00,0x00};
Poke((void*)cP.lookYa,zero4, 4); // Se c'è la stessa altezza, setta la nostra vista Y a 0
} else if(oP.coordUD > cP.coordUD)
{
UDdif = oP.coordUD - cP.coordUD; // Work out our UDdif
angleB = atan(UDdif/flatDist) * 57.29578; // Same old stuff as before
angleBP = (angleB/360);
newValueb = 0 + (0xFFFFFFFF*angleBP);
newValueb2 = newValueb;
Poke((void*)cP.lookYa, &newValueb2,4);
} else if (oP.coordUD < cP.coordUD)
{
UDdif = cP.coordUD - oP.coordUD;
angleB = atan(UDdif/flatDist) * 57.29578;
angleBP = (angleB/360);
newValueb = 0xFFFFFFFF - (0xFFFFFFFF*angleBP);
newValueb2 = newValueb;
Poke((void*)cP.lookYa, &newValueb2,4);
}
}E adesso abbiamo lo scheletro di un aimbot . Bisogna aggiungere solo poche cose :
Shitlist (Head body e quelle cazzate)
Granate (l'arco della granata)
Sparare solo al team nemico.
Have fun , fine!
