Codificando um Aimbot Melhor

[Acre1 2809]

Muitos de vocês estão familiarizados com o infame método "CalcAngle" circulando por muitas fontes, tutoriais e fóruns. Eu culpo a proliferação desse método em Fleep, que o distribuiu em um de seus tutoriais. Resumindo, ele é bem ruim e tem algumas práticas de programação ruins, mais notavelmente o número mágico de 57,2957 ... Também é difícil acompanhar o que realmente está acontecendo.
 

Código:

1. void CalcAngle ( float * src , float * dst , float * ângulos )
2. {
3. delta duplo [ 3 ] = { ( src [ 0 ]- dst [ 0 ]), ( src [ 1 ]- dst [ 1 ]), ( src [ 2 ]- dst [ 2 ]) };
4. hip duplo = sqrt ( delta [ 0 ]* delta [ 0 ] + delta [ 1 ]* delta [ 1 ]);
5. ângulos [ 0 ] = ( float ) ( asinf ( delta [ 2 ]/ hyp ) * 57.295779513082f );
6. ângulos [ 1 ] = ( float ) ( atanf ( delta [ 1 ]/ delta [ 0 ]) * 57.295779513082f );
7. ângulos [ 2 ] = 0,0f ;
8. se ( delta [ 0 ] >= 0.0 ) { ângulos [ 1 ] += 180.0f ; }
9. }

Então, em vez de copiar e colar essa caixa preta de uma função, vou lhe ensinar um método melhor, rápido e extremamente preciso para calcular essencialmente a mesma coisa. Isso funcionará com cheats internos ou externos, mas eu sugiro fortemente que você tente fazer interno, pois o mecanismo Source fornece alguns métodos auxiliares muito úteis.

Se você não sabe o que o CalcAngle faz, ele simplesmente pega duas posições 3D em src e dst e gera o ângulo para dst em angles . Isso é usado principalmente em aimbots, onde você passa a posição do olho do jogador local em src , a cabeça do alvo em dst e então define os ângulos de visão de angles .

SEÇÃO Nº 1: UM POUCO SOBRE VETORES

Um vetor é um tipo de dado de dimensão n que armazena valores de coordenadas cartesianas. No nível mais básico, é uma linha linear. Os vetores mais comuns são bidimensionais e tridimensionais. Um vetor unidimensional é geralmente chamado de escalar e são apenas números reais (ou seja, nenhum número complexo). Existem vetores de dimensões mais altas, mas não podemos representá-los em um plano cartesiano, pois não podemos imaginá-los no espaço mundial.

Aqui está a aparência de um vetor tridimensional (3,7,5):

http://i.imgur.com/YxFoEO8.png

Os vetores podem ser expressos de várias maneiras:

Forma do vetor unitário : 3i + 7j + 5k

Isso é frequentemente usado em matemática, mas totalmente inútil em ciência da computação. i, j e k são x, y e z, respectivamente.

Forma do conjunto ordenado : (3, 7, 5)

Assim como um par ordenado em um gráfico cartesiano. Os vetores neste tutorial estarão quase exclusivamente nesta forma.

Forma polar : (9,11, 56,71 °)

Esta é a forma mais interessante, pois este é o vetor representado não em um plano cartesiano, mas em um plano polar. O primeiro termo é a magnitude ou hipotenusa, e o segundo termo é o ângulo que o vetor forma. Nós essencialmente converteremos para esta forma no final deste tutorial.

http://i.imgur.com/MJf26NX.png

Como nosso vetor é tecnicamente dois triângulos combinados, podemos fazer trigonometria regular nele. Sem dúvida, a parte mais importante é encontrar a magnitude do vetor. Conforme descrito anteriormente, a magnitude é o comprimento do vetor. Há duas maneiras de fazer isso. Podemos usar tan e resolver para a hipotenusa XY, e então usar tan novamente e resolver para a magnitude. Mas podemos fazer isso mais rápido . Você pode ter aprendido a fórmula da Distância 2D em uma aula de álgebra. Isso é derivado do teorema de Pitágoras, a^2 + b^2 = c^2 .

Vamos usar a variante 3D disso, que é como a fórmula 2D, mas um termo extra para a outra dimensão.
 

Código:

1. magnitude = sqrt (( x2 - x1 )^ 2 + ( y2 - y1 )^ 2 + ( z2 - z1 )^ 2 )

Claro, como estamos lidando com vetores, a distância sempre será da origem. Então, a fórmula pode ser simplificada ainda mais.
 

Código:

1. magnitude = sqrt ( x ^ 2 + y ^ 2 + z ^ 2 )

• Usuários internos : O Source SDK fornece a classe Vector que é inicializada por Vector(x, y, z) e tem uma função útil Vector::Length que calculará a magnitude.
• Usuários externos : sugiro que você crie uma estrutura que contenha as coordenadas x, y e z e uma função que calcule a magnitude do vetor.

Esse é o básico dos vetores! Você pode precisar consultar esta seção do tutorial mais tarde.

SEÇÃO #2: O PROBLEMA

Então, queremos fazer um aimbot. Como o CalcAngle, precisamos descobrir os ângulos de visão que nos farão mirar diretamente em nosso inimigo.

A primeira coisa que precisamos fazer é obter a posição dos olhos do nosso jogador local no mundo. Isso é bem fácil. Você só precisa obter o vetor de origem e adicioná-lo ao deslocamento da visão. Então você deve encontrar a posição da cabeça do inimigo.
 

• Usuários internos : posições de cabeça de jogador remoto podem ser encontradas usando a função IClientEntity::SetupBones e então usando a classe CStudioHdr para obter o hitbox. Há muitos recursos no fórum sobre como fazer isso.
• Usuários externos : Você precisará iterar a estrutura do osso e encontrar o osso que está procurando. Há vários tópicos sobre isso.
• Dica : O ID do osso da cabeça para jogadores é 10 .

Então o que precisamos encontrar é a cabeça do alvo em relação ao nosso jogador, em essência, o vetor entre nós e nosso alvo.

http://i.imgur.com/4rDLYUQ.png

Podemos encontrar esse vetor facilmente subtraindo a posição do nosso olho da cabeça do alvo. O vetor resultante será a posição do nosso alvo em relação à nossa cabeça . Subtrair vetores é muito fácil. Você simplesmente subtrai como faria com pares ordenados.

Em nosso exemplo:

Código:

1. ( 3 , 4.5 , 5 )
2. - ( - 2 , - 5 , 5 )
3. ------------------
4. ( 5 , 9,5 , 0 )

• Usuários internos : O SDK fornece a função auxiliar VectorSubtract(a, b, c) , onde os vetores a serem subtraídos são a e b , e o vetor resultante é c .
• Usuários externos : O DirectX fornece a função auxiliar D3DXVec3Subtract(out, a, b) .

Este é o vetor resultante:

http://i.imgur.com/SIb3bsS.png


SEÇÃO #3: DIVERSÃO COM TRIGONOMETRIA

Ótimo! Agora temos o vetor que queremos mirar. Agora só precisamos calcular o ângulo necessário para mirar neste vetor.

Deste ponto em diante, digamos que os ângulos de visão do jogador de exemplo estão em (12°, 30°), que é pitch e yaw, respectivamente. Vamos plotar os ângulos de visão em um plano de coordenadas polares (suponha que o raio = 1).



http://i.imgur.com/T6Br7ew.png

Agora lembre-se de que pitch é o Y do nosso vetor e yaw é o X do nosso vetor. Conforme descrito na seção de vetores deste tutorial, o vetor forma um triângulo retângulo com a magnitude como a hipotenusa. Como tal, podemos usar funções trigonométricas padrão para encontrar o ângulo.

A magnitude do nosso vetor de exemplo é 10,73.

Vamos representar graficamente o vetor em nossos círculos:

http://i.imgur.com/kaWuYB7.png

Quando você visualiza dessa forma, é muito fácil ver o triângulo.
 

• Temos um X e um Y, então podemos usar arctan, ou tangente inversa, para encontrar a guinada.
• Temos Z e a hipotenusa, então podemos usar arccos, ou cosseno inverso, para encontrar o passo.

Então isso se torna um problema muito fácil.

 

Código:

1. yaw = arctan ( y / x ) // pensa sin = opp/hyp, cos = adj/hyp, tan = sin/cos

Código:

1. pitch = arccos ( z / hipotenusa )

Lembre-se: a hipotenusa é a magnitude de um vetor.
 

Usuários internos : Você pode usar a função VectorAngles(vetor, ângulo) do SDK para calcular facilmente o passo e a guinada.

SEÇÃO #4: SUAVIZANDO

Se você está procurando fazer um aimbot de fúria ou algo assim, você está praticamente pronto! No entanto, se você está procurando implementar uma mira suave, isso também é muito fácil de fazer. Eu gosto de chamar esse método de método de suavização de "coeficiente não linear".

A primeira coisa que precisamos fazer é subtrair nossos ângulos calculados dos ângulos de visão atuais do jogador. Como a subtração do vetor, isso nos dará o ângulo relativo aos nossos ângulos de visão atuais, então você pode simplesmente adicionar esse ângulo resultante aos ângulos de visão atuais para ter o mesmo efeito.

Para suavizar, basta adicionar o resultado dividido por alguma constante aos ângulos de visão.

Por exemplo, para suavizar a mira por um fator de 4, você usaria:
 

Código:

1. cmd -> ângulos de visão += ângulo entre / 4

Eu chamo isso de não linear porque o movimento do mouse se torna não linear devido ao comportamento desta função.

CONCLUSÃO

1. Encontre o vetor do alvo em relação ao jogador local.
2. Converta esse vetor em um ângulo.
3. Aplique o coeficiente não linear se quiser suavizá-lo.

Espero que você tenha aprendido algo sobre matemática, e espero que isso desperte seu interesse em aprender mais em vez de copiar e colar .