///////////////////////////////////////////////////////////////////////////////////////////////
//
//
// AUTONAME, NAMECHANGER, NAMESTEALER, TEST
// By 85
// [ElHacker.Net]
// [09/03/13]
//
//
///////////////////////////////////////////////////////////////////////////////////////////////

// Counter-Strike Base Hook
// By Chod & h1web
// Release Date: 26th October 2008

///////////////////////////////////////////////////////////////////////////////////////////////
#pragma optimize("gtp",on)
//#pragma comment(linker,"/MERGE:.data=.text /MERGE:.rdata=.text /SECTION:.text,EWR")

#include "apihook.h"
#include "include.h"

///////////////////////////////////////////////////////////////////////////////////////////////

char g_szBaseDir[ 256 ];
cl_enginefunc_t * o_pEngFuncs = NULL;

///////////////////////////////////////////////////////////////////////////////////////////////

void logme(char * fmt, ... )
{
	va_list va_alist;
	char buf[512];
	va_start (va_alist, fmt);
	_vsnprintf (buf, sizeof(buf), fmt, va_alist);
	va_end (va_alist);

	ofstream fout; 
	char path[256];
	sprintf(path,"%sDionysus.txt",g_szBaseDir);
	fout.open(path, ios::app); 

	if(fout.fail()) return;

	fout << buf << endl; 
	fout.close();
}

///////////////////////////////////////////////////////////////////////////////////////////////

// This is just a test for the namechanger !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
bool ok=false;
static unsigned int randi=0;
static char names[32][256];
static unsigned int last_timer=0;
//extern cl_enginefunc_t * o_pEngFuncs;
void logme(char * fmt, ... );
////////////////////////////////////////////////////
void ModificadorDeNombresConSTR(char* str){
 
	// Detección de doble whitespace
	if(strstr(str,"  ")!=NULL)
    {
        strcpy(strstr(str,"  "),strstr(str,"  ")+1);
        return;
    }
 
	// Detección de whitespace
	if(strstr(str," ")!=NULL)
    {
        char buf[256];
        strcpy(buf,str);
        strcpy(strstr(buf," ")+1,strstr(str," "));
        strcpy(str,buf);
        return;
    }
 
	// Char inicial y final iguales
    if(str[0]==str[strlen(str)-1])
    {
        char buf[256];
        char sbuf[2]="X";// Al asignarle valor se le agrega el 0 automáticamente.
        sbuf[0]=str[0];
        strcpy(buf,sbuf);
        strcat(buf,str);
        strcpy(str,buf);
        return;
    }
 
	// Reemplazo de ocurrencias (para escritura 1337 XD)
	if(strstr(str,"A")!=NULL)
    {
        *strstr(str,"A")='4';
        return;
    }
 
	if(strstr(str,"B")!=NULL)
    {
        *strstr(str,"B")='5';
        return;
    }
 
	if(strstr(str,"E")!=NULL)
    {
        *strstr(str,"E")='3';
        return;
    }
 
	if(strstr(str,"G")!=NULL)
    {
        *strstr(str,"G")='6';
        return;
    }
 
	if(strstr(str,"L")!=NULL)
    {
        *strstr(str,"L")='1';
        return;
    }
 
	if(strstr(str,"O")!=NULL)
    {
        *strstr(str,"O")='0';
        return;
    }
 
	if(strstr(str,"S")!=NULL)
    {
        *strstr(str,"S")='5';
        return;
    }
 
	if(strstr(str,"T")!=NULL)
    {
        *strstr(str,"T")='7';
        return;
    }
 
	// Char final y prefinal iguales
	if(str[strlen(str)-1]==str[strlen(str)-2])
    {
        str[strlen(str)-1]=0;
        return;
    }
 
	// Reducción de longitud
	if(strlen(str)>16)
    {
        str[strlen(str)-1]=0;
        return;
    }
 
	// Agrega un punto al final
	strcat(str,".");
}


int AddEntResult = 1;
//===================================================================================
void HUD_AddEntity (int type, struct cl_entity_s *ent, const char *modelname)
{

	if(o_pEngFuncs)
	{
	//////////////////////////////////////////////////////////////////Modificado por 85

	if(o_pEngFuncs->GetLocalPlayer()->curstate.solid)
	{
		//logme("tgt %d",(timeGetTime()/1000));
		//logme("last_timer %d",last_timer);
		int ii = (timeGetTime()/1000);
		SYSTEMTIME time;
		GetLocalTime(&time);
		//int ii =time.wSecond;
		//int ii = 0;
		//logme("o_pEngFuncs %X",o_pEngFuncs);
		//logme("ii %d",ii);

		if(((ii) - last_timer)>2.0)
		{
			int names_count=0;
			int i;
			for(i=0; i<33;i++)
			{
				cl_entity_s * pEnt = o_pEngFuncs->GetEntityByIndex(i);
				if(pEnt && pEnt->curstate.solid && pEnt!=o_pEngFuncs->GetLocalPlayer())
				{
					hud_player_info_t pInfo;
					o_pEngFuncs->pfnGetPlayerInfo(i, &pInfo);//pEnt->curstate.solid
					char name[256];
					//strcpy(name,pInfo.name);
					memcpy(name,pInfo.name,128);
					name[128]=0;
					if(name[0]!='('){	
						randi++;
						strcpy(names[names_count++],name);
					}
				}
			}

			int n;
			if(names_count>0)
			{
				char cmdstr[256];
				char name[256];
				char buf[2]="A";
				n=randi%names_count;
				strcpy(cmdstr,"name \"");
				strcpy(name,names[n]);
				/////////////////////////////////////////////////
				ModificadorDeNombresConSTR(name);// Hola, me reconocen?
				//////////////////////////////////////////
				strcat(cmdstr,name);
				strcat(cmdstr,"\"");
				o_pEngFuncs->pfnClientCmd(cmdstr);
				//o_pEngFuncs->pfnDrawConsoleString( 300, 300, cmdstr );
				//logme(cmdstr);
			}

			last_timer = (ii);
		}
	}///////////////////////////////////////////////////////////////
	}///////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////////////

int retval = 1;
AddEntResult = retval;
}
DWORD* slots=(DWORD*)0x01EB74E8;
static bool loaded = false;
static bool done = false;
DWORD retaddress;
__declspec( naked )void Gateway2_HUD_AddEntity( void )
{
	__asm
	{
		mov AddEntResult, eax;
		call HUD_AddEntity;
		mov eax, AddEntResult;
		jmp retaddress;
	}
}
DWORD AddEnt = (DWORD)&Gateway2_HUD_AddEntity;
__declspec( naked )void Gateway1_HUD_AddEntity( void )
{
	
	__asm
	{
		push esi;
		mov esi,dword ptr ss:[esp+0x14];
		mov retaddress,esi;
		push AddEnt
		pop esi;
		mov dword ptr ss:[esp+0x14],esi;
		pop esi;
		ret;
	}
}
__declspec(naked) void nullStub()
{
	_asm ret;
}
void OnlyHook(LARGE_INTEGER *lp, bool force = true)
{
	static bool patched = false;
	bool a = (o_pEngFuncs->GetLocalPlayer()->curstate.solid && !done);
	if( /*a ||*/force || GetAsyncKeyState(VK_END)&0x8000 ) 
	{
		unsigned char* c;
		if(!patched)
		{
			patched=true;
			for(int s=0;s<40;s++)
			{
				c = (unsigned char*)slots[s];
				if( c[0] != 0xc3 )
				{
					patched=false;
					MessageBox(NULL, "Things look wrong... very wrong", NULL, MB_OK);
				}
			}
		}
		c = (unsigned char*)slots[20];
		if( c[0] == 0xc3 ){
		slots[20] = (DWORD)&Gateway1_HUD_AddEntity;}//HUD_AddEntity
		done = true;
	}
	if (force)
		return;
}

typedef BOOL (WINAPI *QueryPerformanceCounterFunc)(LARGE_INTEGER*);
QueryPerformanceCounterFunc QueryPerformanceCounterPtr=NULL;
BOOL WINAPI newQueryPerformanceCounter(LARGE_INTEGER *lp)
{
	BOOL  ret       = (*QueryPerformanceCounterPtr)(lp);
	OnlyHook(lp, false);
	return ret;
}

FARPROC (WINAPI *oGetProcAddress)(HMODULE hModule, LPCSTR lpProcName);

///////////////////////////////////////////////////////////////////////////////////////////////

FARPROC WINAPI _GetProcAddress(HMODULE hModule, LPCSTR lpProcName)
{
	FARPROC nResult = oGetProcAddress(hModule, lpProcName);

	if (HIWORD(lpProcName))
	{
		if (!lstrcmp(lpProcName, "GetProcAddress"))
		{
			return (FARPROC) &_GetProcAddress;
		}
		
		else if(!strcmp(lpProcName,"QueryPerformanceCounter"))
        {
			QueryPerformanceCounterPtr = (QueryPerformanceCounterFunc)nResult;
			return (FARPROC)&newQueryPerformanceCounter;
        }
	}
	
	return nResult;
}

///////////////////////////////////////////////////////////////////////////////////////////////

BOOL APIENTRY DllMain ( HINSTANCE hInst, DWORD reason, LPVOID reserved )
{
    if( reason == DLL_PROCESS_ATTACH )
	{
		if(!o_pEngFuncs){
		o_pEngFuncs=(cl_enginefunc_t *)0x01EB72D8;
		}

		// setup base directory
		GetModuleFileName( hInst, g_szBaseDir, sizeof( g_szBaseDir ) );
		char* pos = g_szBaseDir + strlen( g_szBaseDir );
		while( pos >= g_szBaseDir && *pos!='\\' ) --pos; pos[ 1 ]=0;

		oGetProcAddress=(FARPROC(WINAPI *)(HMODULE, LPCSTR))InterceptDllCall(GetModuleHandle(NULL), "Kernel32.dll", "GetProcAddress", (DWORD)&_GetProcAddress);
	}
    
	return TRUE;
}

///////////////////////////////////////////////////////////////////////////////////////////////

HIGH MEMORY (crece de arriba hacia abajo)
EBP+08h   Primer Parámetro       //cmp dword ptr [ebp+0x8], 0x00000009 //mode
EBP+04h   Direccion de retorno   // return address (0x401318 (EXE))
EBP+0     Valor original de EBP // agregado (push ebp)
LOW MEMORY