Problem mit der Logik - Aimbot

[snow]

Hallo,

ich versuche mich gerade an meinem ersten Aimbot.
Mir ist erstmal nur wichtig, dass er in die Richtung des Gegners zielt, die Höhe ist dabei (noch) egal.

Ich schaffe es einfach nicht, dass genau auf den Gegner / in seine Richtung gezielt wird.

Mein Code:

void AimAtEnemy(SPlayer *player, SPlayer *enemy) {

	float fZDistance = std::abs(player->fZ - enemy->fZ);
	float fXDistance = std::abs(player->fX - enemy->fX);

	float fAngle = RAD_TO_DEG(atan2f(fZDistance, fXDistance));

	if (IsSE(player, enemy)) {

		player->fYaw = 180.0f - player->fYaw - fAngle;
	}

	else if (IsSW(player, enemy)) {

		player->fYaw = 180.0f - player->fYaw + fAngle;
	}

	else if (IsNW(player, enemy)) {

		player->fYaw = player->fYaw - fAngle;
	}

	else if (IsNE(player, enemy)) {

		player->fYaw = player->fYaw + fAngle;
	}
}

Die Adressen stimmen alle, ein Fehler durch einen falschen Wert oder so kann ausgeschlossen werden.

Ich weiß einfach nicht, wie ich den endgültigen Winkel berechnen soll / muss. :/
Ich bekomme ja einen absoluten Wert für die Distanzen und daher den selben Wert, egal ob -x oder x und -z oder z. Muss ich evtl. meinen Blickwinkel einbeziehen in die Kalkulation? Wenn ich nach Südwesten schaue und der Gegner Nordöstlich von mir ist, 180° dazu addieren und dann die Addition des Winkels machen?

Gefühlt ist es total einfach, aber mir fehlt einfach der letzte Hinweis..

Wäre über Hilfe echt dankbar, da ansonsten alles funktioniert.

Grüße

[Shadow992]

Möglicherweise hilft dir das:

[Lazeboy]

wenn du den yaw berechnest bekommst du den winkel welcher unabhängig von deinem jetzigen yaw-winkel ist. Du musst also dein winkel nur setzen und nicht irgendwas drauf addieren. Bastel dir ne skizze und guck doch mal genau wie sich der winkel durch verschiedene positionierungen des Gegners verändert.

[Master674b]

Ich hätte es irgendwie so gemacht:

Pseudocode:

vec3 diff = target - camPos
float distance2 = sqrt(pow(diff.x, 2) + pow(diff.y, 2))
float yaw = normalize0to2pi(atan2(diff.y, diff.x))
float pitch = normalize0to2pi(atan2(diff.z, distance2))

Das mit den verschiedenen Positionierungen ist totaler Schwachsinn.
Gegenkathethe durch Ankathethe und fertig.

Bei yaw ist halt einfach X die Ankathethe und Y die Gegenkathethe.
Bei pitch muss folglich der Betrag des Vektors XY (Pythagoras) die Ankathethe sein und Z die Gegenkathethe.

[Lazeboy]

Originally Posted by Master674b

Ich hätte es irgendwie so gemacht:

Pseudocode:

vec3 diff = target - camPos
float distance2 = sqrt(pow(diff.x, 2) + pow(diff.y, 2))
float yaw = normalize0to2pi(atan2(diff.y, diff.x))
float pitch = normalize0to2pi(atan2(diff.z, distance2))

Das mit den verschiedenen Positionierungen ist totaler Schwachsinn.
Gegenkathethe durch Ankathethe und fertig.

Bei yaw ist halt einfach X die Ankathethe und Y die Gegenkathethe.
Bei pitch muss folglich der Betrag des Vektors XY (Pythagoras) die Ankathethe sein und Z die Gegenkathethe.

coole sache als ich mich damit beschäftigt habe, hab ich halt mir da irgendwas zusammen gebastelt mit meiner Formelsammlung und das dann angepasst. Den Weg mit dem normalisieren hatte ich mit noch nicht angeguckt, aber scheint genau das zu machen was ich da mit positionabfragen versucht habe auf Umwegen kreiert habe.

PS: So hab ich das bei cs:s gemacht:

                        float pitch = 0;
 			float yaw = 0;
 			
 			float dx = (bla->BotClassPtr->playerX-0.116728*bla->BotClassPtr->velocityX) - (cameraX/*-0.116728*pPlayer->velocityX*/);
 			float dy = (bla->BotClassPtr->playerY-0.116728*bla->BotClassPtr->velocityY) - (cameraY/*-0.116728*pPlayer->velocityY*/);
 			float dz = (bla->BotClassPtr->stomachZ) - cameraZ;
 	
 			float distance_2D = ( float )sqrt( ( dx * dx ) + ( dy * dy ) );
 			float distance_3D = ( float )sqrt( ( dx * dx ) + ( dy * dy ) + ( dz * dz ) );
 
 			yaw = asinf(dy/distance_2D) * RTOD;
 			pitch = asinf(dz/distance_3D) * RTOD;
 		
 			if(cameraX > bla->BotClassPtr->playerX)
 			{
 				if(cameraY < bla->BotClassPtr->playerY)
 					yaw = 180-yaw;
 				else
 					yaw = -180+(yaw*-1.0f);//-180+(-yaw) -> -180-yaw
 			}
 								
 			*(float*)(EngineBase+YAW) = yaw;
 			*(float*)(EngineBase+PITCH) = -pitch;