WarRock Game structed source's

#include <d3d9.h> // We include our D3D9 Header
#include <d3dx9.h> // We include our D3DX9 Header 
#include "Adres.h"

struct Aeroman // We give our struct the name Aeroman
{
	void SuperCrosshair(IDirect3DDevice9 *pDevice,DWORD defenition,DWORD Collor,DWORD Size); // Our defenition of the Crosshair
	void Light(IDirect3DDevice9 *pDevice); // D3D Lightning
	void Message(char *txt); // A Private Message
	void URL(char *url);
	void Swim(char Height);
	void weapon(char index);
	void Superjump(DWORD Key,char Height);
	void Teleport(int Save,int Go);
	void Visualrain(char value);
	void Stamina(char index);
	void SPEED(char speedvalue);
	void CornerTeleport(int hotkey);
};

Aeroman * AeroMan; // Makes the use of the struct available

void Aeroman::SuperCrosshair(IDirect3DDevice9 *pDevice,DWORD defenition,DWORD Collor,DWORD Size) // Define our SuperCrosshair in the struct Aeroman
{
#define Rectcol D3DCOLOR_ARGB(100,125,0,255) // Define our 3D Collor

#define PlayerP     0xD4A730
#define NoRecoil1   0xC444
#define NoRecoil2   0xC43C
#define NoRecoil3	0xC440
#define Nospread    0xA59E10

int x   = ( GetSystemMetrics( 0 ) / 2); // Takes the full screen size / 2 - so it becomes the half 
int y   = ( GetSystemMetrics( 1 ) / 2); // Same happens here

D3DRECT rec1 = { x - Size, y, x + Size, y + 1    }; // We draw our first line
D3DRECT rec2 = { x, y - Size, x + 1 , y + Size-1 }; // Second line
D3DRECT rec3 = { x-1 - Size, y, x + Size, y - 1  }; // New crosshair line 1
D3DRECT rec4 = { x, y - Size, x - 1 , y + Size+1 }; // Second line of the second crosshair

if(defenition==1) // If our Function is enabled
{
	if(PlayerP != 0) // And our playerpointer is running A.K.A ingame then
	{
		pDevice->SetRenderState(D3DRS_FOGENABLE,false); // fog is disabled
		pDevice->SetRenderState(D3DRS_LIGHTING,true); // Lightning is enabled
		pDevice->SetRenderState(D3DRS_AMBIENT,D3DCOLOR_ARGB(10,0,10,10)); // Ambient collor is small glowing
		}else{ // if we are not ingame then
		pDevice->SetRenderState(D3DRS_FOGENABLE,true); // Fog will be enabled
		pDevice->SetRenderState(D3DRS_LIGHTING,false); // Lightning will be disabled
	}
} // End of the functions

*(float*)(PlayerP+NoRecoil1) = 0; //|
*(float*)(PlayerP+NoRecoil2) = 0; //|-Removes the recoil
*(float*)(PlayerP+NoRecoil3) = 0; //|
//*(float*)(Nospread)  = 0; //Removes the spread

pDevice->Clear(1, &rec1, D3DCLEAR_TARGET, Collor , 0, 0); // We draw the first line of crosshair one
pDevice->Clear(1, &rec2, D3DCLEAR_TARGET, Collor , 0, 0); // We draw the second line of crosshair one
pDevice->Clear(1, &rec3, D3DCLEAR_TARGET, Rectcol, 0, 0); // We draw the first line of crosshair two
pDevice->Clear(1, &rec4, D3DCLEAR_TARGET, Rectcol, 0, 0); // We draw the second line of crosshair two
}


void Aeroman::Light(IDirect3DDevice9 *pDevice)
{
	pDevice->SetRenderState(D3DRS_LIGHTING,true);
}

void Aeroman::Message(char *txt)
{
	MessageBoxA(0,txt,"WarRock Public D3D",0);
}

void Aeroman::URL(char *url)
{
	ShellExecuteA(0,0,url,0,0,SW_SHOWNORMAL);
}

void Aeroman::Swim(char Height)
{
	*(float*)(WaterHeight) = Height;
}

void Aeroman::weapon(char index)
{
	if(PlayerPTR != 0)
	{
		AeroMan->Swim(120);
		*(long*)(PlayerPTR+Weapon1) = index;
		AeroMan->Swim(0);
	}
}

void Aeroman::Superjump(DWORD Key,char Height)
{
	if(PlayerPTR != 0)
	{
		if(GetAsyncKeyState(Key)&1){ *(float*)(PlayerPTR+OFS_Z) = Height; }
	}
}

void Aeroman::Teleport(int Save, int Go)
{
int x,y,z;
float _X = 0.0; float _Y = 0.0; float _Z = 0.0;
if(PlayerPTR!=0)
{
	_X = *(float*)(PlayerPTR+OFS_X);
	_Y = *(float*)(PlayerPTR+OFS_Y);
	_Z = *(float*)(PlayerPTR+OFS_Z);

	if(GetAsyncKeyState(Save)&1)
	{
		x = _X;
		y = _Y;
		z = _Z;
	}

	if(GetAsyncKeyState(Go)&1)
	{
		*(float*)(PlayerPTR+OFS_X) = x;
		*(float*)(PlayerPTR+OFS_Y) = y;
		*(float*)(PlayerPTR+OFS_Z) = z;
	}
}
}

void Aeroman::Visualrain(char value)
{
	if(PlayerPTR != 0)
	{
		*(int*)(VisualRain) = value;
	}
	else
	{
		AeroMan->Message("Please enter a game before you put this hack on!");
	}
}

void Aeroman::Stamina(char index)
{
	if(index==1)
	{
		*(float*)(Stamina1) = 0;
		*(float*)(Stamina2) = 0;
		*(float*)(Stamina3) = 0;
		*(float*)(Stamina4) = 0;
		*(float*)(Stamina5) = 0;
	}
	else
	{
		*(float*)(Stamina1) = 50;
		*(float*)(Stamina2) = 50;
		*(float*)(Stamina3) = 50;
		*(float*)(Stamina4) = 50;
		*(float*)(Stamina5) = 50;
	}
}

void Aeroman::SPEED(char speed)
{
	*(float*)(Speed) = speed;
}




//---[Corner Teleport]---//

struct corner
{
	DWORD Pointer;  //0xD4A730
	float offset_x; //0x102E0
	float offset_y; //0x102F0
	float offset_z; //0x102E8
}; corner *pCorner;


void Aeroman::CornerTeleport(int hotkey)
{
	if(hotkey)
	{
	    /*pCorner->Pointer+pCorner->offset_x = 0;
		pCorner->Pointer+pCorner->offset_y = 0;
		pCorner->Pointer+pCorner->offset_z = 0;*/
	    pCorner->offset_x = 0.0;
		pCorner->offset_z = 0.0;
		pCorner->offset_y = 0.0;
	}
}

#include <d3d9.h>
#include <d3dx9.h>
#include <stdio.h>
#pragma warning(disable:4244)

/*
 * Software development kit coded by Aeroman.
 * Licensed to Microsoft©
 * Coded on 12th of june 2011
 * SuperDevelopMent Kit v3.19
 */

typedef unsigned int        interger_func;

struct SDK
{
	DWORD QuickStart(void *Function);
	DWORD Func1(DWORD adress,int state);
	DWORD Func2(DWORD adress,int state);
	DWORD Func3(DWORD adress,int state);
	DWORD Func4(DWORD adress,int state);
	DWORD Memcpy(DWORD adress,PBYTE *bytes,int max_bytes);
	void Crosshairs(IDirect3DDevice9 *pDevice,DWORD Collor,DWORD Size);
	void URL(char *url);
	void Messagebox(char *title,char *body);
	void URL_Messagebox(char *title,char *body,char *url);
	void Exit(int after_seconds);
	void sleep(int seconds);
	void OpenSlot(DWORD PlayerPtr,DWORD Slot);
	void StartSDK(void *thread,int after_seconds);
	void Game_Teleport(DWORD GamePointer,DWORD adress_x,DWORD adress_y,DWORD adress_z,int hotkey_save,int hotkey_go);
	void Game_Speed(DWORD speed_adress,int speed);
	void Game_Weapon(DWORD GamePointer,DWORD Weapons,int index);
	void Game_Esp(char Teamname,DWORD adress);
	void Game_Rain(DWORD adress,int index);
	void SDK_Credits();
}; SDK *Aero;


DWORD SDK::QuickStart(void *Function)
{
	CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)Function, NULL, NULL, NULL);
	return TRUE;
}

DWORD SDK::Func1(DWORD adress,int state)
{
	*(float*)(adress) = state;
	return 1;
}

DWORD SDK::Func2(DWORD adress,int state)
{
	*(int*)(adress) = state;
	return 1;
}

DWORD SDK::Func3(DWORD adress,int state)
{
	*(long*)(adress) = state;
	return 1;
}

DWORD SDK::Func4(DWORD adress,int state)
{
	*(double*)(adress) = state;
	return 1;
}

DWORD SDK::Memcpy(DWORD adress,PBYTE *bytes,int max_bytes)
{
	#define MemCommit memcpy
	MemCommit((void *)(adress),(bytes),max_bytes);
	return 1;
}

void SDK::Crosshairs(IDirect3DDevice9 *pDevice,DWORD Collor,DWORD Size)
{
#define Rectcol D3DCOLOR_ARGB(100,125,0,255)

int x   = ( GetSystemMetrics( 0 ) / 2);
int y   = ( GetSystemMetrics( 1 ) / 2);

D3DRECT rec1 = { x - Size, y, x + Size, y + 1    };
D3DRECT rec2 = { x, y - Size, x + 1 , y + Size-1 };
D3DRECT rec3 = { x-1 - Size, y, x + Size, y - 1  };
D3DRECT rec4 = { x, y - Size, x - 1 , y + Size+1 };

pDevice->Clear(1, &rec1, D3DCLEAR_TARGET, Collor , 0, 0);
pDevice->Clear(1, &rec2, D3DCLEAR_TARGET, Collor , 0, 0);
pDevice->Clear(1, &rec3, D3DCLEAR_TARGET, Rectcol, 0, 0);
pDevice->Clear(1, &rec4, D3DCLEAR_TARGET, Rectcol, 0, 0);
}

void SDK::URL(char *url)
{
	ShellExecuteA(0,0,url,0,0,SW_SHOWNORMAL);
}

void SDK::Messagebox(char *title,char *body)
{
	MessageBoxA(0,body,title,0);
}

void SDK::URL_Messagebox(char *title,char *body,char *url)
{
	SDK::Messagebox(title,body);
	SDK::URL(url);
}

void SDK::Exit(int after_seconds)
{
	INT inSec;
	inSec = after_seconds * 1000;
	ExitProcess(inSec);
}

void SDK::sleep(int seconds)
{
	INT inSec;
	inSec = seconds * 1000;
	Sleep(inSec);
}

void SDK::OpenSlot(DWORD PlayerPtr, DWORD Slot)
{
	*(long*)(PlayerPtr+Slot) = 1;
}

void SDK::StartSDK(void *thread,int after_seconds)
{
	INT inSec;
	inSec = after_seconds * 1000;
	SDK::Messagebox("Sdk","Succesfully started the function!");
	SDK::QuickStart(thread);
	SDK::sleep(inSec);
}

void SDK::Game_Teleport(DWORD GamePointer,DWORD adress_x, DWORD adress_y, DWORD adress_z, int hotkey_save, int hotkey_go)
{
	DWORD p = *(DWORD*)(GamePointer);
	DWORD x = *(DWORD*)(adress_x);
	DWORD z = *(DWORD*)(adress_y);
	DWORD y = *(DWORD*)(adress_z);

	INT X;
	INT Y;
	INT Z;
	INT cur_z;
	INT cur_y;
	INT cur_x;

	X = *(float*)((p)+(x));
	Y = *(float*)((p)+(y));
	Z = *(float*)((p)+(z));

	if(hotkey_save)
	{
		cur_z = Z;
		cur_y = Y;
		cur_x = X;
	}

	if(hotkey_go)
	{
		*(float*)((p)+(x)) = (cur_x);
		*(float*)((p)+(z)) = (cur_z);
		*(float*)((p)+(y)) = (cur_y);
	}
}

void SDK::Game_Speed(DWORD speed_adress, int speed)
{
	DWORD s = *(DWORD*)(speed_adress);
	INT original_value = 98.94f;
	INT on = 0;	

	if(GetAsyncKeyState(VK_DELETE)&1)
	{
		*(float*)(speed_adress) = (original_value);
	}
	else
	{
		*(float*)(speed_adress) = (speed);
	}
}

void SDK::Game_Weapon(DWORD GamePointer,DWORD Weapons,int index)
{
	#define GetWeapon long
	DWORD p = *(DWORD*)(GamePointer);
	DWORD w = *(DWORD*)(Weapons);
	DWORD i = *(DWORD*)(index);

	*(GetWeapon*)((p)+(w)) = (i);
}

void SDK::Game_Esp(char Teamname, DWORD adress)
{
	DWORD t = *(DWORD*)(Teamname);
	DWORD a = *(DWORD*)(adress);

	char info[28] = { "No info registered." };

	if(!t)
	{
		sprintf_s(info,"Team information: %s",a);
	}
}

void SDK::Game_Rain(DWORD adress,int index)
{
	DWORD a = *(DWORD*)(adress);
	DWORD i = *(DWORD*)(index);

	*(interger_func*)(a) = (i);
}

void SDK::SDK_Credits()
{
	SDK::Messagebox("Credits","Aeroman && Microsoft development networks.");
}

void Aeroman::Asm(void *adress,void *bytes,int size)
{
	DWORD HideASM;
	VirtualProtect(adress,size,PAGE_EXECUTE_READWRITE,&HideASM);
	memcpy(adress,bytes,size);
	VirtualProtect(adress,size,HideASM,&HideASM);
}

~MSDN
~AeroMan