Halo Maps Forum

Evil Aim Source Code:

Aww sorry guys, halo map's code tags don't work right. Guess this source code won't work, so sad.
MAIN.CPP


/********************************************************************************

    Halo POS - Get the pos of any player in a server.

    Copyright (C) 2008 Del



    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.



    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.



    You should have received a copy of the GNU General Public License

    along with this program.  If not, see .

*********************************************************************************

	File:    main.cpp

	Project: EvilAim v1 (Modified to Halo POS)

	Author:  Steve(Del) (Modifications by E3pO)

	Date:    November 6, 2008

	Game:    Halo Custom Edition

	Version: 1.08

	

	Tools Used: Memory Hacking Software -- L.Spiro

				Microsoft Visual C++ 2008 Express Edition

				OllyDbg



	Credits: Evobyte -- Aimbot theory & documentation

	         Odie5533 -- Open sourced Halo PC aimbot

			 Bitterbanana -- Inspiration

			 E3pO -- Testing



	Information: Website -- www.deltronzero.com

				 E-mail -- deltronzero@hotmail.com

*********************************************************************************/

#pragma comment (lib, "d3dx9.lib")

#pragma comment (lib, "d3d9.lib")

#pragma warning( disable : 4996 )

#define tGreen  D3DCOLOR_ARGB( 255,   0, 255,   0 )

//Initializes a color with the supplied alpha, red, green, and blue values.

#include "main.h"

#include 

#include 

#include 

#include  //input output

#include 

#include 

#include 

#include 



using namespace std;



//our hook function....it's weird but its like this

// oEndScene = (tEndScene)DetourFunction((PBYTE)d3d funcion addy to detour,(PBYTE)my function);

#define HOOK(func,addy)	o##func = (t##func)DetourFunction((PBYTE)addy,(PBYTE)hk##func)

#define ES	0

#define DIP	1

#define SSS	2

#define BS 3



char *GetDirectoryFile(char *filename);

ofstream ofile;	

char dlldir[320];



unsigned int	g_uiStride	= NULL; //make stride global cuz we grab it from SetStreamSource

LPD3DXFONT		g_pFont	= NULL; //font object

LPDIRECT3DTEXTURE9 pTextureInterface;

bool sprite = true;

bool bToggle = false;

//------------------------------------------------------------------------------

bool GetPlayerByIndex(unsigned int index)

{

	StaticPlayer = 0, ObjectTableArray = 0, Masterchief = 0;

	StaticPlayer = (Static_Player*)(StaticPlayerHeader->FirstPlayer + (index * StaticPlayerHeader->SlotSize));

	if(StaticPlayer->ObjectID != 65535 && StaticPlayer->ObjectID != 0)

	{

		if(StaticPlayer->ObjectIndex != Local->ObjectIndex && StaticPlayer->ObjectID != Local->ObjectID)

		{

			ObjectTableArray = (Object_Table_Array*)(ObjectTableHeader->FirstObject + (StaticPlayer->ObjectIndex * ObjectTableHeader->Size));

			Masterchief = (AMasterchief*)ObjectTableArray->Offset;

			return true;

		}

	}

	return false;

}

//------------------------------------------------------------------------------

bool GetLocalPlayer(unsigned int index)

{

	LocalPlayer = 0, ObjectTableArray = 0, LocalMC = 0;

	LocalPlayer = (Static_Player*)(StaticPlayerHeader->FirstPlayer + (index * StaticPlayerHeader->SlotSize));

	if(LocalPlayer->ObjectID != 65535 && LocalPlayer->ObjectID != 0)

	{

		ObjectTableArray = (Object_Table_Array*)(ObjectTableHeader->FirstObject + (LocalPlayer->ObjectIndex * ObjectTableHeader->Size));

		LocalMC = (AMasterchief*)ObjectTableArray->Offset;

		return true;

	}

	return false;

}

//------------------------------------------------------------------------------

float Get2dDistance(float x, float y)

{

	return ((float)sqrt((x * x) + (y * y)));

}

//------------------------------------------------------------------------------

float GetAngleDistance(float fLocal[3],float f2Enemy[3])

{

	return (float)(60 * acos(sin(fLocal[1]) * sin(f2Enemy[1]) + cos(fLocal[1]) * cos(f2Enemy[1]) * cos(f2Enemy[0] - fLocal[0])));	

}

//------------------------------------------------------------------------------

bool GetAngleToEnemy(unsigned int index)

{

	float mx,my,mz;

	gHook.m_fLead = 7.0f;



	if(GetPlayerByIndex(index))

	{

		mx = Masterchief->Head[10] - Camera->m_fWorld[0];

		my = Masterchief->Head[11] - Camera->m_fWorld[1];

		mz = Masterchief->Head[12] - Camera->m_fWorld[2];



		mx += (Masterchief->m_Velocity[0] *gHook.m_fLead);

		my += (Masterchief->m_Velocity[1] *gHook.m_fLead);

		mz += (Masterchief->m_Velocity[2] *gHook.m_fLead);



		float dist = Get2dDistance(mx,my);

		gHook.m_fRot[0] = (float)atanf(my/mx);

		gHook.m_fRot[1] = (float)atan2f(mz, dist);



		if(gHook.m_fRot[0] = 0.0f)

			gHook.m_fRot[0] = (float)(PI - gHook.m_fRot[0]);

        if (mx  0.0f && my MaxSlots; i++)

				{

					if(GetAngleToEnemy(i))

					{

						if(GetLocalPlayer(Local->PlayerIndex))

						{	

							if(LocalPlayer->Team == StaticPlayer->Team)

								continue;



							float dist = GetAngleDistance(Local->m_fRot,gHook.m_fRot);

							if (dist != 0 && (dist m_fRot[0]   = gHook.m_fRot[0];

					Local->m_fRot[1]   = gHook.m_fRot[1];

				}

				else

					gHook.m_bAim = true;

			}

		}

		else

			gHook.m_bAim = true;



		Sleep(10);

	}



	return 0;

}



//---------------------------------------------------------------------------------------------------------------------------------



typedef HRESULT (WINAPI* tSetStreamSource)(LPDIRECT3DDEVICE9 pDevice,UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride);

tSetStreamSource oSetStreamSource;



typedef HRESULT (WINAPI* tEndScene)(LPDIRECT3DDEVICE9 pDevice);

tEndScene oEndScene;



typedef HRESULT (WINAPI* tBeginScene)(LPDIRECT3DDEVICE9 pDevice);

tBeginScene oBeginScene;



char *GetDirectoryFile(char *filename)

{

	static char path[320];

	strcpy(path, dlldir);

	strcat(path, filename);

	return path;

}





//---Hooked DirectX Functions-------------------------------------------------------------------------------------------------------

//Ends a scene that was begun by calling IDirect3DDevice9::BeginScene. We can draw text and shIV here / menus

HRESULT WINAPI hkEndScene(LPDIRECT3DDEVICE9 pDevice)

{

	if(g_pFont == NULL){

		D3DXCreateFontA(pDevice, 15, 0, FW_BOLD, 1, 0, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, ANTIALIASED_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Verdana", &g_pFont);

	}

	if(GetAsyncKeyState(VK_CONTROL)&1)

	{	

		  bToggle=!bToggle;

	}



	if(g_pFont != NULL)

	{

   char buf[10];

   int result = 0; 

   float value = Masterchief->Head[10];

		RECT rectg = { 50, 30, 500,200 };

		if (result >= SIZE) 

		{

		g_pFont->DrawTextA(NULL, "Created by E3pO & SilentK(The God)", -1, &rectg, 0,tGreen);

        return 0;

		}

}

	return oEndScene(pDevice);

}



HRESULT WINAPI hkBeginScene(LPDIRECT3DDEVICE9 pDevice)

{

	__asm pushad

		__asm popad

	return oBeginScene(pDevice);

}





HRESULT WINAPI hkSetStreamSource(LPDIRECT3DDEVICE9 pDevice,UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride)

{

	__asm nop



	if(StreamNumber == 0){

		g_uiStride = Stride; // get stride - stream is almost always 0, sometimes there is more streams

	}



	return oSetStreamSource(pDevice, StreamNumber, pStreamData, OffsetInBytes, Stride);

}

//--Credits to DrUnKeN ChEeTaH--------------------------------------------------------------------------------------------------------

LRESULT CALLBACK MsgProc(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam){return DefWindowProc(hwnd, uMsg, wParam, lParam);} 

void DX_Init(DWORD* table)

{

	WNDCLASSEX wc = {sizeof(WNDCLASSEX),CS_CLASSDC,MsgProc,0L,0L,GetModuleHandle(NULL),NULL,NULL,NULL,NULL,_T("DX"),NULL};

	RegisterClassEx(&wc);

	HWND hWnd = CreateWindow(_T("DX"),NULL,WS_OVERLAPPEDWINDOW,100,100,300,300,GetDesktopWindow(),NULL,wc.hInstance,NULL);

	LPDIRECT3D9 pD3D = Direct3DCreate9( D3D_SDK_VERSION );

	D3DPRESENT_PARAMETERS d3dpp; 

	ZeroMemory( &d3dpp, sizeof(d3dpp) );

	d3dpp.Windowed = TRUE;

	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;

	d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;

	LPDIRECT3DDEVICE9 pd3dDevice;

	pD3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,hWnd,D3DCREATE_SOFTWARE_VERTEXPROCESSING,&d3dpp,&pd3dDevice);

	DWORD* pVTable = (DWORD*)pd3dDevice;

	pVTable = (DWORD*)pVTable[0];



	table[ES]	= pVTable[42];

	table[DIP]	= pVTable[82];

	table[SSS]	= pVTable[100];

	table[BS]   = pVTable[41];

    //if you want to add more functions, you have to look up the vtable index number for that function

	// i have a list i can give u...so for example lets add..BeginScene...

	DestroyWindow(hWnd);

}

//------------------------------------------------------------------------------------------------------------------------------------

DWORD WINAPI MyThread(LPVOID)

{

	DWORD VTable[4] = {0};

   // wait for d3d9 to load or whatev

	while(GetModuleHandleA("d3d9.dll")==NULL){

		Sleep(250);

	}

   // start our hook

	DX_Init(VTable);



	// hook / detour our d3d functions

	HOOK(EndScene,VTable[ES]);

	HOOK(SetStreamSource,VTable[SSS]);

//	HOOK(BeginScene,VTable[BS]);



	return 0;

}





//------------------------------------------------------------------------------

BOOL APIENTRY DllMain( HMODULE hModule, DWORD  ulReason, LPVOID lpReserved )

{

	if( ulReason == DLL_PROCESS_ATTACH )

	{

		CreateThread( 0, 0, Aimbot, 0, 0, 0 );

		CreateThread( 0, 0, MyThread, 0, 0, 0 );

	}

	return TRUE;

}

//------------------------------------------------------------------------------

MAIN.H


/********************************************************************************

	EvilAim v1 -- Halo Custom Edition Aimbot

    Copyright (C) 2008 Del



    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.



    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.



    You should have received a copy of the GNU General Public License

    along with this program.  If not, see .

*********************************************************************************

	File:    main.h

	Project: EvilAim v1

	Author:  Steve(Del)

	Date:    September 20, 2008

	Game:    Halo Custom Edition

	Version: 1.08



	Tools Used: Memory Hacking Software -- L.Spiro

				Microsoft Visual C++ 2008 Express Edition

				OllyDbg



	Credits: Evobyte -- Aimbot theory & documentation

	         Odie5533 -- Open sourced Halo PC aimbot

			 Bitterbanana -- Inspiration

			 E3pO -- Testing



	Information: Website -- www.deltronzero.com

				 E-mail -- deltronzero@hotmail.com

*********************************************************************************/

#ifndef MAIN_H

#define MAIN_H

//------------------------------------------------------------------------------

#include 

#include 

#include "structs.h"

//------------------------------------------------------------------------------

#define PI 3.141592653589793f

//------------------------------------------------------------------------------

Object_Table_Header *ObjectTableHeader = (Object_Table_Header*)ObjectTableHeaderAddy;     //4BB206B4 = trial

Static_Player_Header *StaticPlayerHeader = (Static_Player_Header*)StaticPlayerHeaderAddy; //4BD7AF94 = trial

ALocal *Local = (ALocal*)LocalAddy; //4BD7D408 = trial

ACamera *Camera = (ACamera*)CameraAddy; //006A3964 = trial

Object_Table_Array *ObjectTableArray;

AMasterchief *Masterchief;

AMasterchief *LocalMC;

Static_Player *StaticPlayer;

Static_Player *LocalPlayer;

dzHook gHook;

//------------------------------------------------------------------------------

#endif /* MAIN_H */

STRUCTS.H


/********************************************************************************

	EvilAim v1 -- Halo Custom Edition Aimbot

    Copyright (C) 2008 Del



    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.



    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.



    You should have received a copy of the GNU General Public License

    along with this program.  If not, see .

*********************************************************************************

	File:    structs.h

	Project: EvilAim v1

	Author:  Steve(Del)

	Date:    September 20, 2008

	Game:    Halo Custom Edition

	Version: 1.08



	Tools Used: Memory Hacking Software -- L.Spiro

				Microsoft Visual C++ 2008 Express Edition

				OllyDbg



	Credits: Evobyte -- Aimbot theory & documentation

	         Odie5533 -- Open sourced Halo PC aimbot

			 Bitterbanana -- Inspiration

			 E3pO -- Testing



	Information: Website -- www.deltronzero.com

				 E-mail -- deltronzero@hotmail.com

*********************************************************************************/

#ifndef STRUCTS_H

#define STRUCTS_H

//-------------------------------------------

struct dzHook

{

	float m_fRot[3];

	float m_fLead;

	float m_fDist;

	float m_fShortest;

	bool  m_bAim;

	unsigned int m_uiClosest;

} extern gHook;

//-------------------------------------------

struct Object_Table_Header

{

   unsigned char TName[32];          // 'object'

   unsigned short MaxObjects;        // Maximum number of objects - 0x800(2048 objects)

   unsigned short Size;                  // Size of each object array - 0x0C(12 bytes)

   unsigned long Unknown0;           // always 1?

   unsigned char Data[4];              // '@t@d' - translates to 'data'?

   unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)

   unsigned short Num;                  // Number of objects in the current game

   unsigned short NextObjectIndex; // Index number of the next object to spawn

   unsigned short NextObjectID;      // ID number of the next object to spawn

   unsigned long FirstObject;          // Pointer to the first object in the table   

};

extern Object_Table_Header *ObjectTableHeader;

//-------------------------------------------

struct Object_Table_Array

{

   unsigned short ObjectID;           // Matches up to Object ID in static player table ( for players )

   unsigned short Unknown0;

   unsigned short Unknown1;

   unsigned short Size;                 // Structure size

   unsigned long Offset;                  // Pointer to the object data structure

};

extern Object_Table_Array *ObjectTableArray;

//-------------------------------------------

struct AMasterchief

{

   unsigned short BipdMetaIndex;   // [Biped]characters\cyborg_mp\cyborg_mp

   unsigned short BipdMetaID;      // [Biped]characters\cyborg_mp\cyborg_mp

   unsigned char Zeros_00[4];

   unsigned char BitFlags_00[4];

   unsigned long Timer_00;

   unsigned char BitFlags_01[4];

   unsigned long Timer_01;

   unsigned char Zeros_01[68];

   float m_World[3];

   float m_Velocity[3];

   float m_LowerRot[3];

   float m_Scale[3];

   unsigned char Zeros_02[12];

   unsigned long LocationID;

   unsigned long Pointer_00;

   float xUnknown;

   float yUnknown;

   float zUnknown;

   unsigned char Zeros_03[20];

   unsigned short PlayerIndex;

   unsigned short PlayerID;

   unsigned long Unknown00;

   unsigned char Zeros_04[4];

   unsigned short AntrMetaIndex; // [Animation Trigger]characters\cyborg\cyborg

   unsigned short AntrMetaID;   // [Animation Trigger]characters\cyborg\cyborg

   unsigned char BitFlags_02;

   unsigned char Unknown01;

   float Health;

   float Shield_00;

   unsigned long Zeros_05;

   float Unknown02;

   unsigned long Unknown03;

   float Unknown04;

   float Unknown05;

   unsigned char Unknown06[24];

   unsigned short VehicleWeaponIndex;

   unsigned short VehicleWeaponID;

   unsigned short WeaponIndex;

   unsigned short WeaponID;

   unsigned short VehicleIndex; // Ex: Turret on Warthog

   unsigned short VehicleID;

   unsigned short SeatType;

   unsigned char BitFlags_03[2];

   unsigned long Zeros_06;

   float Shield_01;

   float Flashlight_00;

   float Zeros_07;

   float Flashlight_01;

   unsigned char Zeros_08[20];

   unsigned long Unknown07;

   unsigned char Zeros_09[28];

   unsigned char Unknown08;

   unsigned char Unknown10[148];

   unsigned long IsInvisible; // normal = 0x41 invis = 0x51 (bitfield?)

   unsigned char IsCrouching;      // crouch = 1, jump = 2

   unsigned char Unknown11[3];

   unsigned char Unknown09[884];

   float LeftThigh[13];

   float RightThigh[13];

   float Pelvis[13];

   float LeftCalf[13];

   float RightCalf[13];

   float Spine[13];

   float LeftClavicle[13];

   float LeftFoot[13];

   float Neck[13];

   float RightClavicle[13];

   float RightFoot[13];

   float Head[13];

   float LeftUpperArm[13];

   float RightUpperArm[13];

   float LeftLowerArm[13];

   float RightLowerArm[13];

   float LeftHand[13];

   float RightHand[13];

};

extern AMasterchief *Masterchief;

extern AMasterchief *LocalMC;

//-------------------------------------------

struct Static_Player_Header

{

   unsigned char TName[32]; // 'players'

   unsigned short MaxSlots; // Max number of slots/players possible

   unsigned short SlotSize; // Size of each Static_Player struct

   unsigned long Unknown; // always 1?

   unsigned char Data[4]; // '@t@d' - translated as 'data'?

   unsigned short IsInMainMenu; // 0 = in game 1 = in main menu / not in game

   unsigned short SlotsTaken; // or # of players

   unsigned short NextPlayerIndex; // Index # of the next player to join

   unsigned short NextPlayerID; // ID # of the next player to join

   unsigned long FirstPlayer; // Pointer to the first static player

};

extern Static_Player_Header *StaticPlayerHeader;

//-------------------------------------------

struct Static_Player

{

   unsigned short PlayerID;            // Stats at 0x70EC

   unsigned short PlayerID2;            // ???

   wchar_t PlayerName0[12];           // Unicode / Max - 11 Chars + EOS (12 total)

   long Unknown0;                     // Always -1 / 0xFFFFFFFF

   unsigned long Team;                // 0 = Red / 1 = Blue

   unsigned long SwapID;              // ObjectID

   unsigned short SwapType;           // 8 = Vehicle / 6 = Weapon

   short SwapSeat;                    // Warthog - Driver = 0 / Passenger = 1 / Gunner = 2 / Weapon = -1

   unsigned long RespawnTimer;        // ?????? Counts down when dead, Alive = 0

   unsigned long Unknown1;            // Always 0

   unsigned short ObjectIndex;

   unsigned short ObjectID;           // Matches against object table

   unsigned long Unknown3;            // Some sort of ID

   unsigned long LocationID;          // This is very, very interesting. BG is split into 25 location ID's. 1 -19

   long Unknown4;                     // Always -1 / 0xFFFFFFFF

   unsigned long BulletCount;         // Something to do with bullets increases - weird.

   wchar_t PlayerName1[12];           // Unicode / Max - 11 Chars + EOS (12 total)

   unsigned long Unknown5;            // 02 00 FF FF

   unsigned long PlayerIndex;

   unsigned long Unknown6;

   float SpeedModifier;

   unsigned char Unknown7[108];

   unsigned short Ping;

};

extern Static_Player *StaticPlayer;

extern Static_Player *LocalPlayer;

//-------------------------------------------

struct ALocal

{

	unsigned short PlayerIndex;

	unsigned short PlayerID;

	unsigned char Unknown00[160];

	unsigned short ObjectIndex;

	unsigned short ObjectID;

	unsigned char Unknown01;

	float m_fRot[3];

};

extern ALocal *Local;

//-------------------------------------------

struct ACamera

{

	float m_fWorld[3];

};

extern ACamera *Camera;

//-------------------------------------------

unsigned long LocalAddy = 0x402AD408;

unsigned long StaticPlayerHeaderAddy = 0x402AAF94;

unsigned long ObjectTableHeaderAddy = 0x400506B4;

unsigned long CameraAddy = 0x00647424;

//-------------------------------------------

#endif /* STRUCTS_H */

Edited by Fairchild on Sep 17, 2009 at 10:58 PM