Wr3ngine Public [Aimbot, ESP, STW, WTW, CHAMS etc..]

Kazbah__ · 06/01/2012, 16:00

Updated 01/06/2012

Dll Error:

Spoiler

(Packed)

Credits:
Kazbah
BuRn3R<3
GigaByte™
System32
Croner
ZeroX
Neo III

How To Fix Failed To Inject :

Spoiler

~~__BuRn3R~~ · 06/01/2012, 16:04

Geiler Hack

~~Fake~Life~~ · 06/01/2012, 16:31

des ist zwar nicht der Wr3ngine public hack (gibts nicht) aber egal.

Kazbah__ · 06/01/2012, 16:33

Quote:

des ist zwar nicht der Wr3ngine public hack (gibts nicht) aber egal.

ja mach mal die augen auf ... aber egal...

InstantBlood · 06/01/2012, 21:07

nice hack kebab!
achja wann bringst du mir kebab fleisch?

Yamchi · 06/01/2012, 21:27

Guter Hack, habs mir schon auf cc geholt.

~~BrainShot~~ · 06/01/2012, 21:52

WAY HAMMER :=)

~~[WR]King7~~ · 06/01/2012, 23:16

Quote:

Originally Posted by SiiKSiiNz

ja mach mal die augen auf ... aber egal...

~~~Slow~Really~~~ · 06/02/2012, 02:18

Besste hack ever <3 !

~~Crytec'~~ · 06/02/2012, 09:33

Nice Hack

BlȺckWɧite_♫ · 06/02/2012, 09:44

n1
Workz bit64 ♥

'xLeatz. · 06/02/2012, 11:58

n1

Win 7 64 Bit

~~kkBioX~~ · 06/02/2012, 16:52

Hi, wie viele Leute wollen noch mein Menü benutzen, nur weil ihres scheisse aussah?

Falls jemand das Menü genau wie Kazbah haben will, hier sind die LTFX Datein ( "Burners" Base ist bald im Sourcecode Forum zu finden )

cLTFX: ( Thanks to: NeoIII, System32, NikM ( DrawBorder help ), ShaD ( some Tipps )

Code:

		/*
		D3D9 Base by system32
		Only Released On ***********
		Do Not Leech!
		Add Credits!
		
		Credits:
		system32
		Croner
		NeoI.I.I <- Menu
		*/
#include <windows.h> 
#include "cLTFX.h" 
#include "Xor.h"
#include <stdio.h> 
#include <math.h> 
#include <time.h>

#define Col_Green D3DCOLOR_ARGB( 255, 1, 255, 0 )
#define Col_Red D3DCOLOR_ARGB( 255, 220, 0, 0 )
#define Col_Red2 D3DCOLOR_ARGB( 255, 220, 0, 0 )
#define Col_Black D3DCOLOR_ARGB( 220, 0, 0, 0 )
#define Col_Yellow D3DCOLOR_ARGB( 255, 255, 255,0 )
#define Col_Blue D3DCOLOR_ARGB( 255, 0, 140, 220 )
#define Col_White D3DCOLOR_ARGB( 255, 255, 255, 255 )
#define Col_Black2 D3DCOLOR_ARGB( 220, 255, 255,0 )
#define Col_Cyno D3DCOLOR_ARGB(175,000,255,255,0 )

#pragma warning ( disable : 4996 )

char	sFPS[20]="[ FPS: 0 ]";

char *GSZTimeStrings[] = 
{
    "00", "01", "02", "03", "04", "05", "06", "07", "08", "09",
    "10", "11", "12", "13", "14", "15", "16", "17", "18", "19",
    "20", "21", "22", "23", "24", "25", "26", "27", "28", "29",
    "30", "31", "32", "33", "34", "35", "36", "37", "38", "39",
    "40", "41", "42", "43", "44", "45", "46", "47", "48", "49",
    "50", "51", "52", "53", "54", "55", "56", "57", "58", "59"
};
cMenu::cMenu( int MAX_MENU, int MAX_GROUP ) 
{ 
    MAX_ITEMS        = 0; 
    MAX_GROUPS        = 0; 
    menuItem        = new pItem[  MAX_MENU  ]; 
    menuGroup        = new pGroup[ MAX_GROUP ]; 
    this->bMenu        = true; 
    this->bMusic    = false; 
} 

cMenu::~cMenu( ) 
{ 
    MAX_ITEMS    = 0; 
    MAX_GROUPS    = 0; 
    delete        menuItem; 
    delete        menuGroup; 
} 

void cMenu::SetActiveMode( bool m_bMode )                { bMenu = m_bMode;} 
void cMenu::SetMusicMode( bool m_bMode )                { bMusic = m_bMode; } 
void cMenu::SetColor( int type, const D3DCOLOR color )    { MenuColors[type] = 0; MenuColors[type] = color; } 
void cMenu::SetInitialCoords( int x, int y )            { menuPos.x = ( x > 0 ) ? x : 1; menuPos.y = ( y > 0 ) ? y : 1; } 
void cMenu::SetSettingFile( char *SettingsFile )        { strncpy( szSettingsFile, SettingsFile, 256 ); bCanUseSettings = true; } 
void cMenu::InitializeMenu( void )                        { bInitialized = true; } 

void cMenu::InitalizeFont(char *font, int size, IDirect3DDevice9* pD3Ddev) 
{ 
    menuFont = new CD3DFont(font, size, 0x0001); 
    menuFont->InitDeviceObjects(pD3Ddev); 
    menuFont->RestoreDeviceObjects();

    this->FontCreated = true; 
    this->firstInit = true; 
} 

void cMenu::PostReset(char *font, int size, IDirect3DDevice9* pD3Ddev) 
{ 
    if(menuFont == NULL) 
    { 
        menuFont = new CD3DFont(font, size,0x0001); 
        menuFont->InitDeviceObjects(pD3Ddev); 
        menuFont->RestoreDeviceObjects(); 
        this->FontCreated = true; 
    } 
} 

void cMenu::PreReset( void ) 
{ 
    if(menuFont) 
    { 
        menuFont->InvalidateDeviceObjects(); 
        menuFont->DeleteDeviceObjects(); 
        menuFont = NULL; 
        this->FontCreated = false; 
    } 
} 

int cMenu::AddMenuGroup(char title[20]) 
{ 
    if( !bInitialized )return -1; 

    int index = MAX_GROUPS; 
    strncpy( menuGroup[index].title, title, 20 ); 
    menuGroup[index].value    = 0.00f; 
    menuGroup[index].GroupID= index; 
    menuGroup[index].min = 0; 
    menuGroup[index].max = 1; 

    if( !menuGroup[index].settings && bCanUseSettings ) 
    { 
        char VarKey[20] = {0}; 
        strncpy( VarKey, title, 20); 
        RemoveChar(VarKey,'['); 
        RemoveChar(VarKey,']'); 
        menuGroup[index].settings = true; 
        menuGroup[index].value = ( float )iGetValue( MenuGroupOptions, VarKey, 0, szSettingsFile ); 
        if( menuGroup[index].value > menuGroup[index].max ) 
            menuGroup[index].value = ( float )menuGroup[index].max;     
        if( menuGroup[index].value < menuGroup[index].min) 
            menuGroup[index].value = ( float )menuGroup[index].min; 
    } 
    MAX_GROUPS++; 
    return index; 
} 

int cMenu::AddMenuItem(char title[20], float *cvar, int min, int max, int GroupID, int vKey, char *Opt, ...) 
{ 
    if( !bInitialized )return -1; 
    if( MAX_GROUPS < GroupID )return -1; 

    int index = MAX_ITEMS; 
    strncpy( menuItem[index].title, title, 20 ); 
    menuItem[index].value    = cvar;  
    menuItem[index].max        = max; 
    menuItem[index].min        = min; 
    menuItem[index].GroupID = GroupID; 
	menuItem[index].IsText	= false;

    if( !menuItem[index].settings && bCanUseSettings ) 
    { 
        char VarKey[20] = {0}; 
        strncpy( VarKey, title, 20); 
        RemoveChar(VarKey,'['); 
        RemoveChar(VarKey,']'); 
        menuItem[index].settings = true; 
        menuItem[index].value[0] = ( float )iGetValue( MenuItemOptions, VarKey, 0, szSettingsFile ); 
        if( menuItem[index].value[0] > max ) 
            menuItem[index].value[0] = ( float )max;     
        if( menuItem[index].value[0] < min) 
            menuItem[index].value[0] = ( float )min; 
    } 
    if( vKey == 0 && bCanUseSettings ) 
    { 
        char VarKey[20] = {0}; 
        strncpy( VarKey, title, 20); 
        RemoveChar(VarKey,'['); 
        RemoveChar(VarKey,']'); 
        menuItem[index].vKey = iGetValue( MenuHotkeys, VarKey, 0, szSettingsFile );  
    } 
    else  
        menuItem[index].vKey = vKey; 

    if( Opt != NULL ) 
    { 
        menuItem[index].useDesc = true; 
        va_list vl; 
        int i = 0; 
        char* str=Opt; 
        va_start(vl,Opt); 
        do { 
            strncpy( menuItem[index].desc[i], str, 50); 
            str=va_arg(vl,char*); 
            i++; 
        } while (str!=NULL); 
        va_end(vl); 
    } else  
        menuItem[index].useDesc = false; 

    MAX_ITEMS++; 
    return index; 
} 

void cMenu::SaveMenuSettings( void ) 
{ 
    if( !bInitialized || !bCanUseSettings )return; 

    for( int i = 0; i <= ( MAX_GROUPS - 1 ); i++ ) 
    { 
        char VarKey[20] = {0}; 
        strncpy( VarKey, menuGroup[i].title, 20); 
        RemoveChar(VarKey,'['); 
        RemoveChar(VarKey,']'); 
        iSetValue( MenuGroupOptions, VarKey, ( int )menuGroup[i].value, szSettingsFile ); 
    } 
    for( int i = 0; i <= ( MAX_ITEMS - 1 ); i++) 
    { 
        char VarKey[20] = {0}; 
        strncpy( VarKey, menuItem[i].title, 20); 
        RemoveChar(VarKey,'['); 
        RemoveChar(VarKey,']'); 
        iSetValue( MenuItemOptions, VarKey, ( int )menuItem[i].value[0], szSettingsFile ); 
        int vKey = iGetValue( MenuHotkeys, menuItem[i].title, 1337, szSettingsFile ); 
        if( vKey == 1337 ) 
            iSetValue( MenuHotkeys, VarKey, 0, szSettingsFile ); 
    } 
} 

int cMenu::GetMaxItemsToDraw( void ) 
{ 
    if( !bInitialized )return -1; 

    int ItemsToDraw = 0; 
    for( int i = 0; i <= ( MAX_GROUPS - 1 ); i++ ) 
    { 
        ItemsToDraw++; 
        if(menuGroup[i].value) 
        { 
            for( int f = 0; f <= ( MAX_ITEMS - 1 ); f++) 
            { 
                if(menuItem[f].GroupID == menuGroup[i].GroupID) 
                    ItemsToDraw++; 
            } 
        } 
    } 
    return ItemsToDraw-1; 
} 

int cMenu::GetMaxItemsInGroup( int index ) 
{ 
    if( !bInitialized )return -1; 

    int Items = 0; 
    for( int i = 0; i <= ( MAX_ITEMS - 1 ); i++) 
    { 
        if(menuItem[i].GroupID == index) 
            Items++; 
    } 
    return Items; 
} 

int cMenu::GetRealIterator( int Item, int &Type ) 
{ 
    if( !bInitialized )return false; 

    int Items = 0; 

    for( int i = 0; i <= ( MAX_GROUPS - 1 ); i++ ) 
    { 
        if( Items == Item ) 
        {     
            Type = T_GROUP; 
            return i; 
        } 
        Items++; 

        if(menuGroup[i].value) 
        { 
            for( int f = 0; f <= ( MAX_ITEMS - 1 ); f++) 
            { 
                if(menuItem[f].GroupID == menuGroup[i].GroupID) 
                { 
                    if( Items == Item ) 
                    {     
                        Type = T_ITEM; 
                        return f; 
                    } 
                    Items++; 
                } 
            } 
        } 
    } 
    return -1; 
} 

void cMenu::DisableAllMenuItems() 
{ 
    if( !bInitialized )return; 

    curItem = 0; 

    for (int i = 0; i <= ( MAX_ITEMS - 1 ); i++) 
        menuItem[i].value[0] = 0.00f; 

    for( int i = 0; i <= ( MAX_GROUPS - 1 ); i++ ) 
        menuGroup[i].value = 0.00f; 
} 

bool cMenu::IsMouseInVector( int x, int y, int w, int h )  
{  
    return (( m_mouse.x >= x )&&( m_mouse.x <= ( x + w ) )&&( m_mouse.y >= y )&&( m_mouse.y <= ( y + h ) )) ? true : false;  
} 


int	  FPScounter = 0;
float FPSfLastTickCount = 0.0f;
float FPSfCurrentTickCount;

void FPScheck(char *str, char *format)
{
	FPSfCurrentTickCount = clock() * 0.001f;
	FPScounter++;

	if((FPSfCurrentTickCount - FPSfLastTickCount) > 1.0f) {
	    FPSfLastTickCount = FPSfCurrentTickCount;
		sprintf(str,format,FPScounter);
	    FPScounter = 0;
	} 
}


void cMenu::DrawMenu( char* title, IDirect3DDevice9* pDevice ) 
{ 
    if( !bMenu || !bInitialized )
    return; 

    int x = menuPos.x; 
    int y = menuPos.y; 
    int curDrawItem = 0; 


    int MaxItems = GetMaxItemsToDraw( ); 
    if( MaxItems < 1 || MAX_GROUPS < 1 || MAX_ITEMS < 1 ) 
        return; 

	/*CocaCola*/
    /*====================================================*/ 
    DrawBox( (x-12), y-6, 170, 23, 1,Col_Black , Col_Blue, pDevice );
	DrawBox( (x-12), (y+20), 170, ((MaxItems*13) + 30),1, Col_Black, Col_Blue, pDevice );  
	DrawBox( (x-12), y+((MaxItems*13) + 53), 170, 23, 1,Col_Black , Col_Blue, pDevice );
	DrawGameTextPixelFlag( (x-12+85), (y - 2), Col_Blue,DT_CENTER, title); y+=35;

	///////////////
	struct tm * current_tm;
	time_t current_time;time (&current_time);
	current_tm = localtime (&current_time);
	char *logbuf = new char[ 256 ];
	char *sNabel = new char [50];

	//Draw Date & Time
	sprintf( logbuf, "[%02d:%02d:%02d]",current_tm->tm_hour, current_tm->tm_min, current_tm->tm_sec);
	sprintf( sNabel, /*visit www.************/XorStr<0x2D,21,0x0E146E63>("\x5B\x47\x5C\x59\x45\x12\x44\x43\x42\x18\x50\x50\x5B\x49\x42\x4F\x13\x50\x5A\x34"+0x0E146E63).s);
	//DrawGameTextPixel( (x-2) , y+((MaxItems*13) + 22), Col_Blue,logbuf);
	DrawGameTextPixel( (x+10) , y+((MaxItems*13) + 22), Col_Blue, sNabel);

	//Draw FPS
	FPScheck(sFPS,"[%d FPS]");
	//DrawGameTextPixelFlag( (x+152) , y+((MaxItems*13) + 22), Col_Blue,DT_RIGHT, sFPS);



	
    /*====================================================*/ 

    for( int i = 0; i <= ( MAX_GROUPS - 1 ); i++ ) 
    { 
        D3DCOLOR GroupColor = Col_White; 

        if( IsMouseInVector( (menuPos.x + 5), ( ( menuPos.y + 36 ) + (curDrawItem * 13) ), 120, 10 ) ) 
            GroupColor = MenuColors[C_MOUSEOVER]; 
        else if( curDrawItem == curItem )  {
            GroupColor = Col_Yellow; 
			DrawBorder (x-10, y + (curDrawItem * 13)-8, 165, 13, 1, Col_Blue, pDevice);
		}
        else        
            GroupColor = Col_Blue; 
		
		FillARGB(x-5, y+(curDrawItem * 13)-8, 156, 14, D3DCOLOR_ARGB( 180 , 51, 51, 51 ), pDevice );	// We dont need nice background now
		DrawGameTextPixel( x-5, y + (curDrawItem * 13)-8, GroupColor, menuGroup[i].title);
		DrawGameTextPixelFlag( x + 152, y + (curDrawItem * 13)-8, GroupColor,DT_RIGHT, ( menuGroup[i].value ) ? "[ - ]": "[ + ]" );
        curDrawItem++; 

        if(menuGroup[i].value)
        { 
            for( int f = 0; f <= ( MAX_ITEMS - 1 ); f++) 
            { 
                if(menuItem[f].GroupID == menuGroup[i].GroupID) 
                { 
                    D3DCOLOR DrawColor = Col_White; 
                    if( IsMouseInVector( (menuPos.x + 5), ( ( menuPos.y + 36 ) + (curDrawItem * 13) ), 120, 10 ) ) 
                        DrawColor = MenuColors[C_MOUSEOVER]; 
                    else if( curDrawItem == curItem )  
					{
                        DrawColor = Col_Blue; 
					    DrawBorder (x-10, y + (curDrawItem * 13)-8, 165, 13, 1, Col_Cyno, pDevice);
					}
                    else if( menuItem[f].value[0] )       
                        DrawColor = Col_Green;

					DrawGameTextPixel(x + 10, y + (curDrawItem * 13)-8, DrawColor, menuItem[f].title);
                    if( ( int )menuItem[f].max != 1 && ( int )menuItem[f].value[0] != 0 )  
					{ 
						if( menuItem[f].useDesc ) {
							DrawBox( (x-2), y+ (curDrawItem * 13)-5, 6, 7, 1, Col_Green,C_DEFAULT , pDevice );
							DrawGameTextPixelFlag( x + 152, y+ (curDrawItem * 13)-8, Col_Green,DT_RIGHT, menuItem[f].desc[(int)menuItem[f].value[0] - 1]);}
						else   {
							DrawGameTextPixelFlag( x + 152, y+ (curDrawItem * 13)-8, Col_Green,DT_RIGHT, "%2.2f", menuItem[f].value[0] );}
                    } else {
						if(menuItem[f].value[0] == 0){
							DrawBox( (x-2), y+ (curDrawItem * 13)-5, 6, 7, 1, Col_Red,C_DEFAULT , pDevice );
							DrawGameTextPixelFlag( x + 152, y+ (curDrawItem * 13)-8, Col_Red,DT_RIGHT, ((int)menuItem[f].value[0]) ? "On" : "Off" );}
							
						else{
							DrawBox( (x-2), y+ (curDrawItem * 13)-5, 6, 6, 1 , Col_Green,C_DEFAULT, pDevice );
							DrawGameTextPixelFlag( x + 152, y+ (curDrawItem * 13)-8, Col_Green,DT_RIGHT, ((int)menuItem[f].value[0]) ? "On" : "Off" );}
                    } 
                    curDrawItem++; 
                } 
            } 
        } 
    } 
}


void cMenu::Date_Time(int x, int y, LPDIRECT3DDEVICE9 pDevice)
{
	
}


void cMenu::HandleItemHotkeys( WPARAM wKey ) 
{ 
    if( !bInitialized )return; 

    for (int i = 0; i <= ( MAX_ITEMS - 1 ); i++) 
    { 
        if( menuItem[i].vKey == NULL )continue; 
        if( wKey == menuItem[i].vKey ) 
        { 
            float iNextValue = ( menuItem[i].value[0] + 1 ); 

            if( iNextValue <= menuItem[i].max ) 
            { 
                menuItem[i].value[0]++; 
            } 

            if( iNextValue > menuItem[i].max ) 
            { 
                menuItem[i].value[0] = ( float )menuItem[i].min; 
            } 
        } 
    } 
} 

void cMenu::HandleKeyNavigation(/* WPARAM wKey */) 
{ 
	if ( GetAsyncKeyState(VK_INSERT) & 1 )
	{
		SetActiveMode(!bMenu);
	}

    if( bMenu == false || bInitialized == false )return; 


    if( GetAsyncKeyState(VK_UP) & 1 ) 
    { 
        if( curItem <= 0 ) 
            curItem = GetMaxItemsToDraw( ) + 1; 
        if( curItem > 0 ) 
            curItem--; 
    } 

    if( GetAsyncKeyState(VK_DOWN) & 1 ) 
    { 
        if( curItem >= GetMaxItemsToDraw( ) ) 
            curItem = ( 0 - 1 ); 
        if( curItem < GetMaxItemsToDraw( ) ) 
            curItem++; 
    } 

    if( GetAsyncKeyState(VK_RIGHT) & 1 )  
    { 
        int iType = -1; 
        int iterator = GetRealIterator(curItem,iType); 
        if( iterator == -1 )return; 

        if( iType == T_GROUP ) 
        { 
            if( menuGroup[iterator].value < menuGroup[iterator].max ) 
            { 
                menuGroup[iterator].value++; 
            } 
        } else if( iType == T_ITEM ) { 
            if( menuItem[iterator].value[0] < menuItem[iterator].max )  
            { 
                menuItem[iterator].value[0]++; 
            } 
        } 
    } 

    if( GetAsyncKeyState(VK_LEFT) & 1 )  
    { 
        int iType = -1; 
        int iterator = GetRealIterator(curItem,iType); 
        if( iterator == -1 )return; 

        if( iType == T_GROUP ) 
        { 
            if( menuGroup[iterator].value > menuGroup[iterator].min ) 
            { 
                menuGroup[iterator].value--; 
            } 
        } else if( iType == T_ITEM ) { 
            if( menuItem[iterator].value[0] > menuItem[iterator].min )  
            { 
                menuItem[iterator].value[0]--; 
            } 
        } 
    } 
} 

void cMenu::HandleMouseNavigation( WPARAM wKey ) 
{ 
    if( bMenu == false || bInitialized == false || moving[0] || moving[1] || moving[2] )return; 

    int curNavItem = 0; 
    for( int i = 0; i <= ( MAX_GROUPS - 1 ); i++ ) 
    { 
        if( IsMouseInVector( (menuPos.x + 5), ( ( menuPos.y + 36 ) + (curNavItem * 13) ), 120, 10 ) && m_mouse.m_bIsLeftSingleClicked ) 
        { 
            //Groups 
            float fNextValue = ( menuGroup[i].value + 1 ); 

            if( fNextValue <= menuGroup[i].max ) 
            { 
                menuGroup[i].value++; 
                if( curItem > curNavItem )curItem += GetMaxItemsInGroup( menuGroup[i].GroupID ); 
            } 

            if( fNextValue > menuGroup[i].max ) 
            { 
                menuGroup[i].value = ( float )menuGroup[i].min; 
                if( curItem > curNavItem )curItem -= GetMaxItemsInGroup( menuGroup[i].GroupID ); 
            } 

            if( curItem < 0 )curItem = 0; 
            if( curItem > GetMaxItemsToDraw( ) )curItem = GetMaxItemsToDraw( ); 
        } 
        curNavItem++; 

        if(menuGroup[i].value) 
        { 
            for( int f = 0; f <= ( MAX_ITEMS - 1 ); f++) 
            { 
                if(menuItem[f].GroupID == menuGroup[i].GroupID) 
                { 
                    if( IsMouseInVector( (menuPos.x + 5), ( ( menuPos.y + 36 ) + (curNavItem * 13) ), 120, 10 ) && m_mouse.m_bIsLeftSingleClicked ) 
                    { 
                        //MenuItems 
                        float fNextValue = ( menuItem[f].value[0] + 1 ); 

                        if( fNextValue <= menuItem[f].max ) 
                            menuItem[f].value[0]++; 

                        if( fNextValue > menuItem[f].max ) 
                            menuItem[f].value[0] = ( float )menuItem[f].min; 
                    } 
                    curNavItem++; 
                } 
            } 
        } 
    } 
} 

void cMenu::DragMenuWindow(void) 
{ 
    if( bMenu == false || bInitialized == false || menu.moving[1] || menu.moving[2])return; 

    if (m_mouse.m_bIsLeftHeld) 
    { 
        if( IsMouseInVector(menuPos.x-20,menuPos.y-20,170,40) ) 
        { 
            menuPos.x = ( m_mouse.x - 30 ); 
            menuPos.y = ( m_mouse.y - 10 ); 
            moving[0] = true; 
        } 
    } else { 
        moving[0] = false; 
    } 
} 

void cMenu::HandleKeys( WPARAM wParams, LPARAM lParams, UINT msg ) 
{ 
    //store the left click state for single-click checking 
    bool m_bLeftClickOldState = m_mouse.m_bIsLeftSingleClicked; 

    //clear the old data...sucka! 
    m_mouse.m_bIsRightClicked =                false; 
    m_mouse.m_bIsLeftSingleClicked =        false; 
    m_mouse.m_bIsMiddleClicked =            false; 
    m_mouse.m_bIsLeftHeld =                    false; 

    if( msg == WM_KEYDOWN ) 
    { 
        if( wParams == VK_INSERT || wParams == VK_F12 ) 
        { 
            SetActiveMode( !bMenu ); 
        } else { 
            //HandleKeyNavigation(/* wParams */); 
            HandleItemHotkeys( wParams ); 
        } 
    } 

    if( msg == WM_NCHITTEST ) 
    { 
        m_mouse.x = ( ( int )( short )LOWORD( lParams ) ); 
        m_mouse.y = ( ( int )( short )HIWORD( lParams ) ); 
    } 
    //when we don't check msg, this means its being held ( useful for dragging windows ) 
    m_mouse.m_bIsRightClicked =        ( wParams == MK_RBUTTON ) ? true : false; 
    m_mouse.m_bIsLeftHeld =            ( wParams == MK_LBUTTON ) ? true : false; 
    m_mouse.m_bIsMiddleClicked =    ( wParams == MK_MBUTTON ) ? true : false; 

    if( m_bLeftClickOldState == false ) 
    { 
        m_mouse.m_bIsLeftSingleClicked = ( msg == WM_LBUTTONDOWN && wParams == MK_LBUTTON ); 
    } 
    DragMenuWindow(); 
    HandleMouseNavigation( wParams ); 
} 

//Draw Funcs 
void cMenu::DrawText( int x, int y, DWORD color, char *szFormat, ... ) 
{ 
    if( !szFormat )return; 

    char logbuf[256] = { 0 }; 

    va_list va_alist; 
    va_start (va_alist, szFormat); 
    _vsnprintf(logbuf, sizeof(logbuf), szFormat, va_alist); 
    va_end (va_alist); 

    RECT font_rect; 
    SetRect( &font_rect, x, y, 0, 0 ); 
    menuFont->DrawText( ( FLOAT )x, ( FLOAT )y, color, logbuf ); 
} 

void cMenu::DrawGameTextPixel(int x, int y, DWORD color, char *szFormat, ... ) 
{ 
    if( !szFormat )return; 

    char logbuf[256] = { 0 }; 

    va_list va_alist; 
    va_start (va_alist, szFormat); 
    _vsnprintf(logbuf, sizeof(logbuf), szFormat, va_alist); 
    va_end (va_alist); 

    menuFont->DrawText((float)x+1, (float)y, D3DCOLOR_ARGB( 255, 0, 0, 0 ), logbuf); 
    menuFont->DrawText((float)x-1, (float)y, D3DCOLOR_ARGB( 255, 0, 0, 0 ), logbuf); 
    menuFont->DrawText((float)x, (float)y+1, D3DCOLOR_ARGB( 255, 0, 0, 0 ), logbuf); 
    menuFont->DrawText((float)x, (float)y-1, D3DCOLOR_ARGB( 255, 0, 0, 0 ), logbuf); 

    //menuFont->DrawText((float)x, (float)y, color, logbuf, D3DFONT_SHADOW); 
    menuFont->DrawText((float)x, (float)y, color, logbuf); 
} 

void cMenu::DrawGameTextPixelFlag(int x, int y, DWORD color, DWORD flags, char *szFormat, ... ) 
{ 
    if( !szFormat )return; 

    char logbuf[256] = { 0 }; 

    va_list va_alist; 
    va_start (va_alist, szFormat); 
    _vsnprintf(logbuf, sizeof(logbuf), szFormat, va_alist); 
    va_end (va_alist); 

    if( flags == RIGHT ) 
    { 
        SIZE Size = {0,0}; 
        if(menuFont->GetTextExtent(logbuf, &Size) == S_OK) 
        { 
            x -= Size.cx; 
        } 
        flags = 0; 
    } else if( flags == CENTER ) 
    { 
        SIZE Size = {0,0}; 
        if(menuFont->GetTextExtent(logbuf, &Size) == S_OK) 
        { 
            x -= (Size.cx/2); 
        } 
        flags = 0; 
    } 

    menuFont->DrawText((float)x+1, (float)y, D3DCOLOR_ARGB( 255, 0, 0, 0 ), logbuf, flags); 
    menuFont->DrawText((float)x-1, (float)y, D3DCOLOR_ARGB( 255, 0, 0, 0 ), logbuf, flags); 
    menuFont->DrawText((float)x, (float)y+1, D3DCOLOR_ARGB( 255, 0, 0, 0 ), logbuf, flags); 
    menuFont->DrawText((float)x, (float)y-1, D3DCOLOR_ARGB( 255, 0, 0, 0 ), logbuf, flags); 

    //menuFont->DrawText((float)x, (float)y, color, logbuf, D3DFONT_SHADOW); 
    menuFont->DrawText((float)x, (float)y, color, logbuf, flags); 
}  

int cMenu::GetTextWidth(char* text) 
{ 
    SIZE Size = {0,0}; 
    if( menuFont->GetTextExtent(text,&Size) == S_OK ) 
        return Size.cx; 
    return 0; 
} 

void cMenu::FillRGB( int x, int y, int w, int h, D3DCOLOR color, IDirect3DDevice9* pDevice ) 
{ 
    if( w < 0 )w = 1; 
    if( h < 0 )h = 1; 
    if( x < 0 )x = 1; 
    if( y < 0 )y = 1; 

    D3DRECT rec = { x, y, x + w, y + h }; 
    pDevice->Clear( 1, &rec, D3DCLEAR_TARGET, color, 0, 0 ); 
} 
void cMenu::FillARGB( int x, int y, int w, int h, D3DCOLOR color, IDirect3DDevice9* pDevice ) 
{ 

    struct Vertex 
	{
        float x,y,z,ht;
        DWORD Color;
    };

    Vertex V[4];
    V[0].Color = V[1].Color = V[2].Color = V[3].Color = color;
    V[0].z   = V[1].z   = V[2].z   = V[3].z   = 0.0f;
    V[0].ht = V[1].ht = V[2].ht = V[3].ht = 0.0f;

    V[0].x = V[1].x = (float)x;
    V[0].y = V[2].y = (float)(y + h);
    V[1].y = V[3].y = (float)y;
    V[2].x = V[3].x = (float)(x + w);

	pDevice->SetTexture(0, NULL);
	pDevice->SetFVF(D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1); 
	pDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,V,sizeof(Vertex));

    //FillRGB( x, y, w, h, color, pDevice ); 
} 

void cMenu::FillARGBGradient( int x, int y, int w, int h, D3DCOLOR color1, DWORD color2, IDirect3DDevice9* pDevice ) 
{ 
    //removed. 
    //do it yourself you dont really need it... 
} 

void cMenu::DrawBorder( int x, int y, int w, int h, int px, D3DCOLOR BorderColor, IDirect3DDevice9* pDevice ) 
{ 
    FillARGB( x, (y + h - px), w, px,    BorderColor, pDevice ); 
    FillARGB( x, y, px, h,                BorderColor, pDevice ); 
    FillARGB( x, y, w, px,                BorderColor, pDevice ); 
    FillARGB( (x + w - px), y, px, h,    BorderColor, pDevice ); 
} 

void cMenu::DrawBox( int x, int y, int w, int h, int di, D3DCOLOR BoxColor, D3DCOLOR BorderColor, IDirect3DDevice9* pDevice ) 
{ 
    FillARGB( x, y, w, h,        BoxColor, pDevice ); 
    DrawBorder( x, y, w, h, di,    BorderColor, pDevice ); 
} 

void cMenu::DrawHealthBox( int x, int y, DWORD m_dColorOut, DWORD m_dColorIn, int m_iHealth, int m_iMaxHealth, IDirect3DDevice9* pDevice ) 
{ 
    float mx = ( float )m_iMaxHealth / 8; 
    float w = ( float )m_iHealth / 8; 
    x -= ( ( int )mx / 2 ); 

    //background 
    FillARGB( x, y, ( int )mx, 4, m_dColorOut, pDevice ); 
    //inside 
    FillARGB( x, y, ( int )w, 4, m_dColorIn, pDevice ); 
    //outline 
    DrawBorder( x - 1, y - 1, ( int )mx + 2, 6, 1,    D3DCOLOR_ARGB( 255, 30, 30, 30 ), pDevice ); 
} 

void cMenu::DrawMouse( IDirect3DDevice9* pDevice, bool DrawIt ) 
{ 
    if( bMenu == false && !DrawIt )return; 

    DWORD black = D3DCOLOR_ARGB( 255, 0, 0, 0 ); 
    DWORD color = D3DCOLOR_ARGB( 255, 0, 0, 255 ); 
    int x = m_mouse.x, y = m_mouse.y; 

    //removed, thats a stylie thing that you can do yourself :) 
} 

void cMenu::DrawRadar( int x, int y, int size, IDirect3DDevice9* pDevice ) 
{ 
    //not needed on the menu but well i used it... 
    //int x = 300, y = 300, size = 150; 
//    DrawBox( x, y, size, size, D3DCOLOR_ARGB( 150, 51, 51, 51 ), D3DCOLOR_ARGB( 250, 25, 220, 251 ), pDevice ); 
    //DrawBox( (x+5), (y+5), (size-10), (size-10), D3DCOLOR_ARGB( 255, 31, 31, 31 ), D3DCOLOR_ARGB( 255, 184, 184, 184 ), pDevice ); 
    FillARGB( (x+(size/2)), (y+6), 1, (size-12), D3DCOLOR_ARGB( 255, 0, 255, 0 ), pDevice ); 
    FillARGB( (x+6), (y+(size/2)), (size-12), 1, D3DCOLOR_ARGB( 255, 0, 255, 0 ), pDevice ); 
} 

void cMenu::DrawDot( int x, int y, int r, int g, int b, IDirect3DDevice9* pDevice ) 
{ 
    DWORD color = D3DCOLOR_ARGB( 255, r, g, b ); 
    FillRGB(x-1,y-1,2,2,color,pDevice); 
} 

void cMenu::DrawLine(int x1, int y1, int x2, int y2, D3DCOLOR col, IDirect3DDevice9* pDevice) 
{ 
    const DWORD D3D_FVF = D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1; 
    LineVertex points[2] =  
    { 
        { (float)x1, (float)y1, 0.0f, 0.0f, col, 1.0f, 1.0f }, 
        { (float)x2, (float)y2, 0.0f, 0.0f, col, 1.0f, 1.0f }, 
    }; 
    //allow for translucency 
    pDevice->SetRenderState( D3DRS_ALPHABLENDENABLE,true ); 
    pDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE ); 
    pDevice->SetRenderState( D3DRS_FOGENABLE, false ); 

    pDevice->SetFVF(D3D_FVF); 
    pDevice->SetTexture(0, NULL); 
    pDevice->DrawPrimitiveUP(D3DPT_LINESTRIP, 1, points, sizeof(LineVertex)); 
} 

LineVertex cMenu::CreateD3DTLVERTEX (float X, float Y, float Z, float RHW, D3DCOLOR color, float U, float V) { LineVertex v = {X,Y,Z,RHW,color,U,V}; return v; } 

void cMenu::DrawCircle(int x, int y, float radius, D3DCOLOR color, IDirect3DDevice9* pDevice) 
{ 
    //cool for Sphere ESP :D 
    const DWORD D3D_FVF = D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1; 
    const int NUMPOINTS = 24; 
    const float PI = ( float )3.141592654f; 
    LineVertex Circle[NUMPOINTS + 1]; 
    float X, Y, Theta, WedgeAngle; 
    WedgeAngle = (float)((2*PI) / NUMPOINTS); 

    for(int i=0; i<=NUMPOINTS; i++) 
    { 
        Theta = i * WedgeAngle; 
        X = (float)(x + radius * cos(Theta)); 
        Y = (float)(y - radius * sin(Theta)); 
        Circle[i] = CreateD3DTLVERTEX(X, Y, 0.0f, 1.0f, color, 0.0f, 0.0f); 
    } 
    pDevice->SetFVF(D3D_FVF); 
    pDevice->SetTexture(0, NULL); 
    pDevice->DrawPrimitiveUP(D3DPT_LINESTRIP, NUMPOINTS, &Circle[0], sizeof(Circle[0])); 
}  

void cMenu::iSetValue( char* szSection, char* szKey, int iValue, char* szFilePath ) 
{ 
    char szValue[255]; 
    sprintf( szValue, "%d", iValue ); 
    WritePrivateProfileString( szSection,  szKey, szValue, GetDirectoryFile( szFilePath ) ); 
}  

int cMenu::iGetValue( char* szSection, char* szKey, int iDef, char* szFilePath ) 
{ 
    return GetPrivateProfileInt( szSection, szKey, iDef, GetDirectoryFile( szFilePath ) ); 
}  

void cMenu::RemoveChar( char *str, char toRemove ) 
{ 
    int iLen = (int)strlen(str); 
    int iSize = 0; 
    for(int i = 0; i < iLen; i++) 
    { 
        if(str[i]==toRemove)continue; 
        str[iSize]=str[i]; 
        iSize++; 
    } 
    str[iSize] = '\0'; 
}  

void cMenu::InitABCDEF(HMODULE hDll)
{
	DisableThreadLibraryCalls(hDll);
	GetModuleFileNameA(hDll, dlldir, 512);

	for (int i = strlen(dlldir); i > 0; i--)
	{
		if (dlldir[i] == '\\')
		{
			dlldir[i+1] = 0;
			break;
		}
	}
}

char* cMenu::GetDirectoryFile(char *filename)
{
	static char path[320];
	strcpy(path, dlldir);
	strcat(path, filename);
	return path;
}

Tipp: Farben könnt ihr hier verändern: /*CocaCola*/

Kazbah__ · 06/02/2012, 17:16

Quote:

Only Released On WarHax

die war doch eh schon mal public und mit deinem code da können eh viele nix anfangen

The-Ultimate-Boom · 06/02/2012, 18:17

Quote:

Originally Posted by Fake~Life

des ist zwar nicht der Wr3ngine public hack (gibts nicht) aber egal.

Du scheinst keine anung zu haben .
Kazbah : Nice hack bro.
Tested.. .. ...

Code:

#Edit: Work [Nice]
#System l : Windows 7Pro. 64Bit 
#System ll : Windows 7Ultimate. 64Bit 
#System lll : Windows 7Starter. 32Bit