NonSDK Project

typedef void* (*CreateInterfaceFn)(const char *pName, int *pReturnCode);
 
CreateInterfaceFn CaptureFactory(char *FactoryModuleName)
{
	CreateInterfaceFn ret = NULL;
 
	while(!ret)
	{
		HMODULE FactoryModule = GetModuleHandleA(FactoryModuleName);
 
		if(FactoryModule)
			ret = reinterpret_cast<CreateInterfaceFn>(GetProcAddress(FactoryModule,"CreateInterface"));
 
		Sleep(10);
	}
 
	return ret;
}
 
void *CaptureInterface(CreateInterfaceFn Fn, char *InterfaceName)
{
	unsigned long *ret = NULL;
 
	while(!ret)
	{
		ret = reinterpret_cast<unsigned long*>(Fn(InterfaceName,NULL));
		Sleep(10);
	}
 
	return ret;
}
 
DWORD cEntList = *(DWORD*)CaptureInterface(CaptureFactory("client.dll"),"VClientEntityList003");
DWORD cEngine = *(DWORD*)CaptureInterface(CaptureFactory("engine.dll"),"VEngineClient013");
 
int GetLocalPlayer()
{
	int ret = 0;
	_asm
	{
		MOV ECX, DWORD PTR DS:[cEngine]
		MOV EAX, DWORD PTR DS:[ECX]
		CALL DWORD PTR DS:[EAX+0x30]
		MOV ret, EAX
	}
	return ret;
}
 
CBaseEntity *GetEntityByIndex(int index)
{
	CBaseEntity *ret = null;
	_asm
	{
		MOV ECX, DWORD PTR DS:[cEntList]
		MOV EAX, DWORD PTR DS:[ECX]
		PUSH index
		CALL DWORD PTR DS:[EAX+0xC]
		MOV ret, EAX
	}
	if(ret == null)
		return null;
	_asm
	{
		MOV EDX, DWORD PTR DS:[ret]
		MOV ECX, EAX
		CALL DWORD PTR DS:[EDX+0x1C]
		MOV ret, EAX
	}
	return ret;
}
 
CBaseEntity *GetLocalEntity()
{
	return GetEntityByIndex(GetLocalPlayer());
}
 
int GetMaxEntities()
{
	int ret = 0;
	_asm
	{
		MOV ECX, DWORD PTR DS:[cEntList]
		MOV EAX, DWORD PTR DS:[ECX+0x24]
		MOV ret, EAX
	}
	return ret;
}

const char *GetBaseEntityClassName(CBaseEntity *entity)
{
	DWORD add = ((DWORD)entity)+0x8;
	const char *ret;
	_asm
	{
		MOV ESI, entity
		LEA EDI, DWORD PTR DS:[ESI+0x8]
		MOV EAX, DWORD PTR DS:[EDI]
		MOV ECX, EDI
		CALL DWORD PTR DS:[EAX+0x8]
		MOV EAX, DWORD PTR DS:[EAX+0x8]
		MOV ret, EAX
	}
	return ret;
}
 
bool GetPlayerInfo(int index, player_info_t *pInfo)
{
	bool ret = false;
	_asm
	{
		MOV ECX, DWORD PTR DS:[cEngine]
		MOV EAX, DWORD PTR DS:[ECX]
		PUSH pInfo
		PUSH index
		CALL DWORD PTR DS:[EAX+0x20]
		MOV ret, AL
	}
	return ret;
}
 
bool GetBaseEntityIsDormant(CBaseEntity *entity)
{
	bool ret = false;
	_asm
	{
		MOV ECX, entity
		LEA EAX, DWORD PTR DS:[ECX+0x8]
		MOV EAX, DWORD PTR DS:[EAX]
		CALL DWORD PTR DS:[EAX+0x20]
		MOV ret, AL
	}
	return ret;
}

Vector GetBaseEntityEyePosition(CBaseEntity *entity)
{
	Vector *eye = (Vector*)((DWORD)entity+0xE0);
	return *GetBaseEntityOrigin(entity)+*eye;
}
 
float *GetWorldToScreenMatrix()
{
	float *ret;
	_asm
	{
		MOV ECX, cEngine
		MOV EAX, DWORD PTR DS:[ECX]
		CALL DWORD PTR DS[EAX+0x90]
		MOV ret, EAX
	}
	return ret;
}
 
bool GetVisible(Vector &start, Vector &end)
{
	trace_t tr;
	Ray_t ray;
	ray.Init(start,end);
	__asm
	{
		MOV ECX, cEngineTrace
		MOV EAX, DWORD PTR DS:[ECX]
		LEA EDX, tr
		PUSH EDX
		PUSH 0
		//PUSH 0x4602400B
		PUSH 0x4600400B
		LEA EDX, ray
		PUSH EDX
		CALL DWORD PTR DS:[EAX+0x10]
	}
	return (tr.fraction > 0.97f);
}

Vector *GetBaseEntityOrigin(CBaseEntity *entity)
{
	Vector *ret;
	_asm
	{
		MOV ECX, entity
		MOV EAX, DWORD PTR DS:[ECX]
		CALL DWORD PTR DS:[EAX+0x24]
		MOV ret, EAX
	}
	return ret;
}
 
Vector *GetBaseEntityViewAngle(CBaseEntity *entity)
{
	Vector *ret;
	_asm
	{
		MOV ECX, entity
		MOV EAX, DWORD PTR DS:[ECX]
		CALL DWORD PTR DS:[EAX+0x28]
		MOV ret, EAX
	}
	return ret;
}

int GetBaseEntityIndex(CBaseEntity *entity) //k
{
	return *(int*)((DWORD)entity+IndexOffset);
}
 
char GetBaseEntityLifeState(CBaseEntity *entity) //k
{
	return *(char*)((DWORD)entity+LifeStateOffset);
}
 
int GetBaseEntityHealth(CBaseEntity *entity) //k
{
	return *(int*)((DWORD)entity+HealthOffset);
}
 
int GetBaseEntityFlags(CBaseEntity *entity) //k
{
	return *(int*)((DWORD)entity+FlagsOffset);
}
 
int GetBaseEntityTeamNum(CBaseEntity *entity) //k
{
	return *(int*)((DWORD)entity+TeamNumOffset);
}
 
bool IsConnected()
{
	bool ret = false;
	_asm
	{
		MOV ECX, DWORD PTR DS:[cEngine]
		MOV EAX, DWORD PTR DS:[ECX]
		CALL DWORD PTR DS:[EAX+0x6C]
		MOV ret, AL
	}
	return ret;
}

class cRadarPlayer
{
public:
	int valid;
	char unknown0[12];
	char name[32];
	int team;
	int health;
	Vector origin;
	Vector viewangles;
};
 
cRadarPlayer *GetRadarPlayerByIndex(int index)
{
	cRadarPlayer *ret = null;
	_asm
	{
		MOV ECX, DWORD PTR DS:[cRadarPlayerArray]
		MOV EAX, index
		LEA EAX, DWORD PTR DS:[EAX+EAX*0x4]
		SHL EAX, 6
		LEA EAX, DWORD PTR DS:[EAX+ECX+0x28]
		MOV ret, EAX
	}
	return ret;
}

 
typedef struct MapPlayer_s {
                int             index;          // player's index
                int             userid;         // user ID on server
                int             icon;           // players texture icon ID
                Color   color;          // players team color
                char    name[MAX_PLAYER_NAME_LENGTH];
                int             team;           // N,T,CT
                int             health;         // 0..100, 7 bit
                Vector  position;       // current x,y pos
                QAngle  angle;          // view origin 0..360
                Vector2D trail[MAX_TRAIL_LENGTH];       // save 1 footstep each second for 1 minute
        } MapPlayer_t;
 

cRadarPlayer *ret = null;
MOV ret, EAX
return ret;

mov eax, classPoint //like engine class
call [eax + 0x123]  //0x123 is your needed functionpointer

 
MOV ECX,DWORD PTR DS:[Classpoint]
MOV EDX,DWORD PTR DS:[ECX]
MOV EAX,DWORD PTR DS:[EDX+123]
CALL EAX
 

 
MOV ECX,DWORD PTR DS:[Classpoint]
MOV EDX,DWORD PTR DS:[ECX+123]
CALL EDX