Actualmente estoy usando este código:

struct vec3_t
{
public:
    float x, y, z;
};

vec3_t Subtract(vec3_t src, vec3_t dst)
{
    vec3_t diff;
    diff.x = src.x - dst.x;
    diff.y = src.y - dst.y;
    diff.z = src.z - dst.z;
    return diff;
}
float Magnitude(vec3_t vec)
{
    return std::sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);
}
float Distance(vec3_t src, vec3_t dst)
{
    vec3_t diff = Subtract(src, dst);
    return Magnitude(diff);
}
vec3_t CalcAngle(vec3_t src, vec3_t dst)
{
    vec3_t angles;
    angles.x = (-(float)std::atan2(dst.x - src.x, dst.y - src.y)) / PI * 180.0f + 180.0f;
    angles.y = (std::atan2(dst.z - src.z, Distance(src, dst))) * (180.0f / PI);
    angles.z = 0.0f;

    printf("%f - %f\n", src.z - dst.z, angles.y);


    return angles;
}

Sin embargo, mis ángulos no funcionan completamente cuando aumenta el delta del valor z. El ángulo carece de inclinación y apunta por encima de la posición del objetivo.

Sin embargo, cuando el delta del eje Z es menor que 20, el ángulo funciona y apunta al jugador que quiero.

Tengo algunos ejemplos aquí:

Cuando el delta es realmente pequeño

Pic of aiming of bot

Cuando el delta es excelente

Pic of missing bot

PD: lo llamo todo de la siguiente manera

vec3_t CurrentPos;
CurrentPos.x = x.ReadMemory<float>(LocalPlayer + PlayerOffsetList["PosX"]);
CurrentPos.y = x.ReadMemory<float>(LocalPlayer + PlayerOffsetList["PosY"]);
CurrentPos.z = x.ReadMemory<float>(LocalPlayer + PlayerOffsetList["PosZ"]);

vec3_t EnemyPos;
EnemyPos.x = Enemy.Posx;
EnemyPos.y = Enemy.Posy;
EnemyPos.z = Enemy.Posz;

vec3_t Result;
Result = AimbotMath.CalcAngle(EnemyPos, CurrentPos);

x.WriteMemory<float>(AddrList["ViewX"], (Result.x + 90.0f));
x.WriteMemory<float>(AddrList["ViewY"], Result.y);
3
HowITsDone 22 feb. 2018 a las 18:02

2 respuestas

La mejor respuesta

Suponiendo, en su método CalcAngles que x es guiñada e y es cabeceo:

vec3_t CalcAngle(vec3_t src, vec3_t dst)
{
    vec3_t angles;
    vec3_t delta = Subtract(dst, src);
    angles.x = -(float)std::atan2(delta.x, delta.y) / PI * 180.0f + 180.0f;
    //zero out the z to get the *horizontal* distance
    vec3_t horizontal = delta;
    horizontal.z = 0;
    angles.y = std::atan2(delta.z, Magnitude(horizontal)) * (180.0f / PI);
    angles.z = 0.0f;

    printf("%f - %f\n", delta.z, angles.y);


    return angles;
}

Tenga en cuenta que dejé su orden de x y y, junto con el desplazamiento de 180.0f porque supongo que es correcto para su punto de referencia. Normalmente atan2 toma (y, x).

3
avariant 22 feb. 2018 a las 15:27
std::atan2(dst.z - src.z, Distance(src, dst))

atan2 toma los deltas en dos ejes, normalmente x y en y . Sin embargo, lo alimentas con la distancia de la hipotenusa. El segundo argumento aquí debería ser la diferencia en y , probablemente, no la distancia total.

Algo así como:

angles.x = (-(float)std::atan2(dst.x - src.x, dst.y - src.y)) / PI * 180.0f + 180.0f;
angles.y = (-(float)std::atan2(dst.z - src.z, DistanceXY(src, dst)) / PI * 180.0f + 180.0f;

No lo probé, por lo que es posible que deba ajustar el letrero hacia arriba o hacia abajo, o girar 90 o 180 grados. Pero la forma debería ser la correcta.

editar : de hecho, probablemente solo necesite utilizar una función de distancia 2D que no utilice el componente z.

0
Jeffrey 22 feb. 2018 a las 15:24