[C++] HL1 Box ESP + Smooth Aimbot Tutorial

**ko1N** · 10.04.2007 23:57

Box ESP + Smooth Aimbot Tutorial

Willkommen zu meinem ersten Tutorial
Nach nicht mal einer Woche hack-coding möcht ich euch mal schnell mit einem sehr einfachen ESP und Aimbot tutorial versorgen den ich eben just4fun geproggt hab...

Wäre nett wenn ihr mir credits für den code geben würdet (hat mich fast ne halbe stunde gekostet *g*)

So los gehts:

Ganz am anfang stehen 2 neue funktionen: Eine um zu checken in welchem Team wir sind und eine die unsere Box malt.
Fangen wir mit ersterer an. Am besten setzt ihr sie über eure HUD_ReDraw funktion.

Code:

int GetTeam(char *model)
{
	// Terror team models
	if (strstr(model, "arctic")	||
		strstr(model, "guerilla")	||
		strstr(model, "leet")		||
		strstr(model, "terror"))
		return 1;

	// Counter team models
	else if (strstr(model, "gign")	||
		strstr(model, "gsg9")		||
		strstr(model, "sas")		||
		strstr(model, "urban")		||
		strstr(model, "vip"))
		return 2;

	return 0;
}

Wir suchen mit strstr einen string innerhalb eines anderen strings. Heisst wir suchen z.b. nach gign in dem pfad des models das übergeben wird.

Nun fehlt uns nur noch die Funktion um unsere Box zu malen:

Code:

void DrawBox(int x, int y, int r, int g, int b, int a, int iRadius, int iThickness)
{
	int iRad = iRadius / 2;

	// oben
	gEngfuncs.pfnFillRGBA(x - iRad, y - iRad, iRadius, iThickness, r, g, b, a);

	// unten
	gEngfuncs.pfnFillRGBA(x - iRad, y + iRad, iRadius + (iThickness / 2), iThickness, r, g, b, a);

	// links
	gEngfuncs.pfnFillRGBA(x - iRad, y - iRad, iThickness, iRadius, r, g, b, a);

	// rechts
	gEngfuncs.pfnFillRGBA(x + iRad, y - iRad, iThickness, iRadius, r, g, b, a);
}

Dieser Code malt 4 farbflächen und ordnet sie so an, dass ein gewohnter Box ESP entsteht. Wobei iThickness die dicke der Box und iRadius den Radius der Box beschreibt.

Nun fehlt uns "nur" noch die Hauptfunktion unseres kleinen Aimbots/Esp's. Um performance zu sparen machen wir nur eine einzige schleife die direkt den ESP auf den Kopf malt und den Aimbot aktivieren kann

Code:

void DoEspAim(void)
{
	// Spieler Entities
	cl_entity_t *pEnt = NULL, *pLocal = gEngfuncs.GetLocalPlayer();
	// Spielerinfos
	hud_player_info_t pInfo;
	// Spielerinfo holen
	gEngfuncs.pfnGetPlayerInfo(pLocal->index, &pInfo);
	// Team suchen
	int iOwnTeam = GetTeam(pInfo.model); // Team holen

Wir definieren 2 entity pointer und eine playerInfo struct und speichern unser team in iOwnTeam (Damit wir später nicht auf uns selbst schiessen).

Danach definieren wir noch ein paar andere variablen die wir brauchen um den Spieler der am nähsten zum Crosshair positioniert ist festzuhalten.

Code:

	float fScreenPos[10];
	float fDistFromCenter[3];
	float fCenterDistance;

	// Bildschirmgroeße
	int iScreenCenterX = gEngfuncs.GetWindowCenterX();
	int iScreenCenterY = gEngfuncs.GetWindowCenterY();

	// Naechster spieler
	cl_entity_t *pNearestEnt = NULL;
	float fNearest = -1.0f;
	float fNearestAimTarget[3] = {0,0,0};

Nun durchlaufen wir in einer for-schleife alle möglichen Spieler (32) und speichern ihre Daten in unserer playerInfo struktur.

Code:

	for (int i = 0; i < 33; i++)
	{
		// Wir selbst wollen nicht auf uns zielen
		if (pLocal->index == i) continue;

		// Entity holen und prüfen
		pEnt = gEngfuncs.GetEntityByIndex(i);
		if (!isValidEnt(pEnt)) continue;

		// PlayerInfo und Team auslesen
		gEngfuncs.pfnGetPlayerInfo(i, &pInfo);
		int iTeam = GetTeam(pInfo.model);

Danach setzen wir die Z-Koordinate unseres momentanen Spielers etwas niedriger um immer schön auf den Kopf zu aimen (Ja ich weiss man könnte hier auch mit Vector, Bone oda Hitbox Aimbots herumspielen aber das ist ein SEHR simples Tutorial das doch einen ziemlich guten und einfachen Aimbot hat).
Danach holen wir unsere Weltposition mittels CalcScreen.

Code:

		pEnt->origin.z -= -20; // Wir brauchen die Kopf-Position
		if (CalcScreen(pEnt->origin, fScreenPos))
		{
			// Er ist sichtbar!

Erinnert ihr euch noch an den guten alten phytagoras? Ja genau der! Wir müssen nun die Distanz des Spielers auf dem Bildschirm bis zum Crosshair berechnen und zwar mir genau diesem Satz (a² + b² = c²).

Code:

			// Berechnung in Relation zum Bildschirmzentrum
			fDistFromCenter[0] = iScreenCenterX - fScreenPos[0];
			fDistFromCenter[1] = iScreenCenterY - fScreenPos[1];

			// Der phytagoras ohne Wurzel
			fCenterDistance = square(fDistFromCenter[0]) + square(fDistFromCenter[1]);

Um performance zu sparen hab ich mir das Wurzelziehen gespart da wir ehh nur alle Werte die wir selbst berechnen untereinander vergleichen.
Nun kommen wir endlich zum malen des ESP's:

Code:

			if (iTeam == 1) // Team = Terror = Rot
			{
				DrawBox(fScreenPos[0], fScreenPos[1], 255, 10, 10, 255, 25, 2);
			}
			else if (iTeam == 2) // Team = CT = Blau
			{
				DrawBox(fScreenPos[0], fScreenPos[1], 10, 10, 255, 255, 25, 2);
			}
			else // Die Welt stellt auch ein entity da und wird nicht geparsed und fliegt aus der while heraus
			{
				continue;
			}

Nun prüfen wir noch (was nur noch für den Aimbot relevant ist) ob unser gefundener Spieler im gegnerischen Team ist (wir wollen nur auf Gegner aimen)

Code:

if (iTeam == iOwnTeam) continue;

Nun vergleichen wir die Werte mit denen in unserem Memory und ersetzen diese falls ein Gegner näher ist als ein anderer

Code:

			if (fNearest < 0.0f || fCenterDistance < fNearest)
			{
				// Spieler entity
				pNearestEnt = pEnt;
				// Distanz falls noch ein Spieler naeher ist
				fNearest = fCenterDistance;
				// Screenpositionen kopieren
				fNearestAimTarget[0] = fScreenPos[0];
				fNearestAimTarget[1] = fScreenPos[1];
			}
		}
	}

So nun sind wir auch schon fast durch. Wir checken nur noch schnell ob wir überhaupt eine Entity gefunden haben und ob die werte höher als 0 sind (Wozu sollen wir auf ein Target zielen auf dem wir sowieso schon zu 100% drauf sind? / Fehlererkennung)

Code:

	if (pNearestEnt != NULL && fNearestAimTarget[0] > 0 && fNearestAimTarget[1] > 0)
	{
		// Smoothness Faktor (je hoeher desto langsamer ist der Aimbot)
		#define AIM_SMOOTH 2

		// Ist die Rechte Maustaste gedrückt?
		if (GetAsyncKeyState(VK_RBUTTON))
		{
			//Smoothness berechnen:
			float x = fNearestAimTarget[0] - iScreenCenterX;
			float y = fNearestAimTarget[1] - iScreenCenterY;

			x /= AIM_SMOOTH;
			y /= AIM_SMOOTH;

			fNearestAimTarget[0] = iScreenCenterX + x;
			fNearestAimTarget[1] = iScreenCenterY + y;

			// Dann Aime auf das Ziel
			SetCursorPos((int)fNearestAimTarget[0], (int)fNearestAimTarget[1]);
		}
	}

Ihr müsst nur noch letztere Funktion aus eurer HUD_ReDraw funktion callen und es sollte funktionieren...
Bevor ihr dumme Fragen stellt checkt ob eure EngFuncs genauso heissen und ihr alle Funktionen habt. Falls euch die Funktionen isValidEnt oder CalcScreen fehlen einfach melden!

Sinnvollerweise könntet ihr den Code noch erweitern wie z.b.:
- Aimthrough
- Smoothnessfaktor einstellbar
- Verbesserte Teamdetection
- Was euch sonst so einfällt...

Und so könnte euer ESP zum schluss aussehen:

P.S.: Ihr dürft das tut mit meiner erlaubnis auf andren Seiten posten. Notfalls könnt ihr immernoch zu diesem post linken...

P.P.S.: Als kleines schmanckerln noch ne kleine funktion um Keys zu überprüfen. Es ist eine ganz einfache abfrage nach globalen Tastendrücken und wenn man diese Funktion z.b. in jeder HUD_ReDraw funktion ausführt kann man Prima einen Tastentoggle simulieren:

Code:

// Jeder Key bekommt einen Arrayeintrag
bool bKeyPressed[256];
bool IsKeyPressed(int iKey)
{
	// Suche nach globalem windows tastendruck
	if (GetAsyncKeyState(iKey))
	{
		if (!bKeyPressed[iKey])
		{
			bKeyPressed[iKey] = true;
			return true;
		}
	}
	else
		bKeyPressed[iKey] = false;

	return false;
}

Und dementsprechend braucht ihr global noch eine neue Variable für Panic

Code:

bool bPanic = false;

Und dementsprechend in eurer HUD_ReDraw:

Code:

	if (IsKeyPressed(VK_F12)) bPanic = !bPanic;
	if (bPanic) DoAim();

greetz to iarmus, h1web, p4ddY, xgx, anarx, gordon, gdc

reupload für weym0

Übrigens ist das das alte tutorial das mal auf mpcbase und g-d war...

**Gordon** · 11.04.2007 05:22

Nice, nur wie mir mal aufgefallen ist, sind im Fenstermodus die Koordination nicht korrekt.

ch9zn · 11.04.2007 10:55

Schick Schick habe zwar keinen Plan von coden aber werde es früher oder später sicher mal gebrauchen können :>

**Bimbo** · 11.04.2007 10:57

jo super tut ! Freu mich das manche sich hier die arbeit machen und tuts machen !

**Timberland** · 11.04.2007 13:54

Irgendwie fehlen da Credits.
panzer zum Beispiel.

**ko1N** · 11.04.2007 14:22

Zitat von Gordon`

Nice, nur wie mir mal aufgefallen ist, sind im Fenstermodus die Koordination nicht korrekt.

Joa war eine meiner ersten arbeiten mit CS habe es nur auf anfrage erneut uploaded!

P.S. Ihr müsst über die engine die screen infos (am besten beim ersten call von hud_redraw) holen

**noryx** · 01.05.2007 00:08

hallo leute ich habe mal ne frage unzwar ob man dieses prinzip auch bei anderen shooter anwenden kann oder es spezial nur auf cs bezogen ist und wenn ja könntet ihr mir sagen was ich so großartig daran ändern müsste danke schon mal in voraus

**Monkeyhacker** · 01.05.2007 01:00

sachen wie

Code:

// Terror team models
	if (strstr(model, "arctic")	||
		strstr(model, "guerilla")	||
		strstr(model, "leet")		||
		strstr(model, "terror"))
		return 1;

	// Counter team models
	else if (strstr(model, "gign")	||
		strstr(model, "gsg9")		||
		strstr(model, "sas")		||
		strstr(model, "urban")		||
		strstr(model, "vip"))
		return 2;

wirste nur bei cs anwenden können, weil nur cs T und CT Models hat (:

**Gordon** · 01.05.2007 06:51

Naja - Muss man schon an die jeweilige Engine anpassen. CS und CSS sind ähnlich, aber auch anders :|

sk0r · 01.05.2007 10:56

Das geht auch schlecht wegen dem Half-Life SDK. Dieses ist von Valve und desshalb, logischer Weise, nur für ihr Spiel.

Thema: [C++] HL1 Box ESP + Smooth Aimbot Tutorial

Themen-Optionen

Anzeige

[C++] HL1 Box ESP + Smooth Aimbot Tutorial

Die folgenden 4 Benutzer haben sich bereits bedankt:

Lesezeichen

Lesezeichen

Berechtigungen