EDITED, 00:31 @ 25.02.
Quote:
Originally Posted by . χaωe
Moin,
Ich hab mal eine Formel entwickelt um zu berechnen zu wie viel Prozent ein Gegner mich an Aimt bzw. wie weit er von mir weg guckt. (Wollte ich später für AimBot verwenden).
Dafür habe ich das Skalarprodukt aus meiner Position (M), der Position des Gegners (E) und der Position des Blickpunktes vom Gegner (B) berechnet. In der Theorie bedeutet es ja, wenn der Winkel = 180° ist guckt der Gegner in die genau entgegen gesetzte Richtung also schaut er mich zu 0% an.
|
Das Skalarprodukt zweiter Vektoren ist das Produkt ihrer Längen sowie des Cosinus des Winkels zwischen ihnen. Der Cosinus ist aber genau dann -1, wenn der Winkel 180° plus ganzzahliges Vielfaches von 360° ist - Also wenn du in die entgegengesetzte Richtung schaust.
Damit funktioniert deine Methode.
Quote:
Originally Posted by . χaωe
Um das nun umzurechnen habe ich das Skalarprodukt erst zu einem Winkel umgerechnet (180/PI * radians) und das schließlich in Prozent (100/180 * Ergebnis).
|
Schaue dir doch bitte die Makros D3DXToDegree und D3DXToRadian an. Man muss das Rad ja schließlich nicht neu erfinden.
Quote:
Originally Posted by . χaωe
Nun wollte ich fragen ob diese Formel überhaupt Praxistauglich ist. Da mein verständniss von D3D noch nicht sonderlich gut ist, und ich nicht weiß ob der Blickpunkt der in der ViewMatrix steht auch für diese Formel verwendbar ist.
Wen es interessiert, hier ist mein in C++ geschriebener SourceCode dafür
Für eine Antwort wäre ich sehr dankbar :)
Wenn noch Fragen offen sind bin ich gerne bereit diese schnell zu beantworten ;)
mfg, .Sawe
|
Der Sourcecode ist stark unoptimiert, dein Ansatz ist wie oben beschrieben aber umsetzbar. Da du dich aber mit der Mathematik schon beschäftigt hast, möchte ich dir gerne trotzdem helfen - aber das nicht hier, sondern via IM.
Quote:
Originally Posted by Nomad'
Ich darf dich vorwarnen, rotierende Matrizen sind nicht meins, also kann ich dir nur oberflächlich helfen.
|
Ich nehme den Post einfach mal auseinander, damit er weiß, was er davon verwenden kann.
Quote:
Originally Posted by Nomad'
Ich würde es so versuchen: Du hast erst mal 2 Punkte, den Standort deines Gegner G und deinen Standort, S. Außerdem hast du einen Vektor b, der die Blickrichtung deines Gegner beschreibt (der Ortsvektor zum Blickpunkt, wie du ihn nanntest). Diese 3 Punkte setzt du einfach alle in eine gerade Ebene (x3 = 0 oder so). Jetzt berechnest du den Schnittwinkel zwischen b und SG, dann hast du den gesuchten Blickwinkel. Wenn b und SG identisch sind, schaut er genau auf dich. Wenn sie echt parallel sind, dann schaut er genau in die andere Richtung.
|
Ich schreibe hierzu einfach mal meinen Ansatz dazu (der funktioniert, ich verwende ihn derzeit):
Man hat die beiden Positionen, du hast sie G und S genannt.
Die Geradengleichung G + r * (S - G) muss also die selbe Funktion beschreiben, wie G + s * b, wenn b die Blickrichtung des Gegners beschreibt. r und s sind hierbei reelle Zahlen. Für S - G schreibe ich im folgenden T.
Es muss also gelten, dass b das selbe ist wie T / |T|.
b und T / |T| sind normierte Vektoren, b ist hierbei wie folgt definiert:
b[0] = cos(pitch)*cos(yaw);
b[1] = -sin(yaw)*cos(pitch);
b[2] = sin(pitch);
Quote:
Originally Posted by Nomad'
Trotzdem verstehe ich den Sinn nicht ganz. Selbst wenn er dich nur noch gerade so auf seinem Bildschirm sehen kann, heißt das ja nicht direkt dass er dich weniger gut sieht als wenn er direkt auf dich guckt.
|
Das Problem ist hierbei der Visible Check.
Um also noch einmal mit meinem Code abzuschließen, der übrigens qualitativ, nicht quantitativ ist:
Code:
// #include <d3dx9.h>
// #include <math.h>
float GetMisalignment(
D3DXVECTOR3 *pvLocalPosition, // Your current position ordered X;Y;Z
D3DXVECTOR3 *pvEnemyPosition, // Your targets position ordered X;Y;Z
D3DXVECTOR3 *pvEnemyRotation) // Your targets rotation ordered Yaw;Pitch;Roll in degree, Roll is basically not needed
{
pvEnemyRotation->x = D3DXToRadian(pvEnemyRotation->x);
pvEnemyRotation->y = D3DXToRadian(pvEnemyRotation->y);
//pvEnemyRotation->z = D3DXToRadian(pvEnemyRotation->z);
D3DXVECTOR3 vTranslation = *pvEnemyPosition - *pvLocalPosition,
vEnemyView = D3DXVECTOR3(cosf(pvEnemyRotation->x) * cosf(pvEnemyRotation->y),
-sinf(pvEnemyRotation->x) * cosf(pvEnemyRotation->y),
sinf(pvEnemyRotation->y)),
vResult;
D3DXVec3Normalize(&vTranslation, &vTranslation);
vResult = vTranslation - vEnemyView;
return D3DXVec3Length(vResult);
}
Um noch einmal auf deinen anderen Ansatz zurückzukommen:
Code:
// #include <d3dx9.h>
// #include <math.h>
float GetMisalignment(
D3DXVECTOR3 *pvLocalPosition, // Your current position ordered X;Y;Z
D3DXVECTOR3 *pvEnemyPosition, // Your targets position ordered X;Y;Z
D3DXVECTOR3 *pvEnemyRotation) // Your targets rotation ordered Yaw;Pitch;Roll in degree, Roll is basically not needed
{
pvEnemyRotation->x = D3DXToRadian(pvEnemyRotation->x);
pvEnemyRotation->y = D3DXToRadian(pvEnemyRotation->y);
//pvEnemyRotation->z = D3DXToRadian(pvEnemyRotation->z);
D3DXVECTOR3 vTranslation = *pvLocalPosition - *pvEnemyPosition,
vEnemyView = D3DXVECTOR3(cosf(pvEnemyRotation->x) * cosf(pvEnemyRotation->y),
-sinf(pvEnemyRotation->x) * cosf(pvEnemyRotation->y),
sinf(pvEnemyRotation->y));
D3DXVec3Normalize(&vTranslation, &vTranslation);
return (D3DXVec3Dot(&vTranslation, &vEnemyView) + 1.0f) / 2.0f;
}
Das returnt dann einen Wert zwischen 0 und 1, 0 heißt, er zielt genau auf dich, 1 heißt, er zielt genau in die andere Richtung.