CPlayer,cLTCharacterFx,CCharacterHitBox,ILTFontMan ager Acessing Class

Hi MPGH, Today I'll show you how to acess some class with 1 ADDR

You can get information about class HERE

Code:

#include <stdint.h>
#define ADDR_CROSSFIRE_ENGINE_CLASS 0x11701E4

#include "SDK\engine\sdk\inc\ltbasedefs.h"
#include "SDK\engine\sdk\inc\iltmessage.h"

class LTVector
{
public:
	float x, y, z;
};
class LTRotation
{
public:
	float x, y, z, w;
};
class LTObject
{
public:
	char _0x0000[4];
	LTVector BoxMin; //0x0004 
	LTVector BoxMax; //0x0010 
	char _0x001C[128];
	LTVector Scale; //0x009C 
	char _0x00A8[4];
	unsigned int Type; //0x00AC 
	char _0x00B0[8];
	LTVector Dimentions; //0x00B8 
	char _0x00C4[12];
	LTVector ModelCullingPosition; //0x00D0 
	char _0x00DC[4];
	LTVector Position; //0x00E0 
	LTRotation Rotation; //0x00EC 
	LTVector Velocity; //0x00FC 
	LTVector GlobalForceOverride; //0x0108 
	char _0x0114[8];
	LTVector Acceleration; //0x011C 
};//Size=0x0128
class CLTClient
{
public:
	char pad_0000[1092]; //0x0000
}; //Size: 0x0444

class ILTCSBase
{
public:
	CLTClient* pCLTClient; //0x0000
	char _0x0001[123];
	bool(WINAPIV *IntersectSegment)(IntersectQuery &iQuery, IntersectInfo *Info); //0x007C 
	char _0x0080[412];
	void(WINAPIV *RunConsoleCommand)(CHAR *Command); //0x021C 
	char _0x0220[508];
	LTRESULT SendToServer(ILTMessage_Read *pMsg, HOBJECT hSender, uint32 flags); //0x041C }; //Size: 0x0293

class CD3DDrawPrim
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTDrawPrim
{
public:
	CD3DDrawPrim* pD3DDrawPrim; //0x0000
	char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CLTPhysicsClient
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTClientPhysics
{
public:
	CLTPhysicsClient* pLTPhysicsClient; //0x0000
	char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CUIWidgetManager
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTWidgetManager
{
public:
	CUIWidgetManager* pUIWidgetManager; //0x0000
	char pad_0004[64]; //0x0004
}; //Size: 0x0044

class D3DRenderStyles
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTRenderStyles
{
public:
	D3DRenderStyles* pD3DRenderStyles; //0x0000
	char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CClientFileMgr
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class IClientFileMgr
{
public:
	CClientFileMgr* pCClientFileMgr; //0x0000
	char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CClientShell
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CCamera
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CSideCamera
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CameraInstanse
{
public:
	int         m_Left, m_Top, m_Right, m_Bottom;
	float       m_xFov, m_yFov;
	int         m_bFullScreen;
	LTVector    m_LightAdd;
}; //Size: 0x0104

class pLTObjectCamera
{
public:
	CameraInstanse* pCameraInstanse; //0x0000
	D3DXVECTOR3 X; //0x0004
	D3DXVECTOR3 Y; //0x0010
	D3DXVECTOR3 Z; //0x001C
	char pad_0028[60]; //0x0028
}; //Size: 0x0064

class CCameraBase
{
public:
	CCamera* pCCamera; //0x0000
	CSideCamera* pCSideCamera; //0x0004
	char pad_0008[56]; //0x0008
	pLTObjectCamera* pLTObject; //0x0040
	char pad_0044[448]; //0x0044
}; //Size: 0x0204

class PlayerViewManager
{
public:
	char pad_0000[4]; //0x0000
	LTObject* pLTObject; //0x0004
	char pad_0008[48]; //0x0008
	__int32 CurrentWeaponId; //0x0038
	char pad_003C[24]; //0x003C
	float WeaponZoom; //0x0054
}; //Size: 0x0058

class CPlayerClntBase
{
public:
	char pad_0000[76]; //0x0000
	__int32 CameraObject; //0x004C
	char pad_0050[636]; //0x0050
	PlayerViewManager* pPlayerViewManager; //0x02CC
	char pad_02D0[488]; //0x02D0
	LTObject* pLTObjectNormal; //0x04B8
	LTObject* pLTObjectZM; //0x04BC
	char pad_04C0[4]; //0x04C0
	float Yaw; //0x04C4
	float Pitch; //0x04C8
	float Roll; //0x04CC
	char pad_04D0[32]; //0x04D0
	float CameraYaw; //0x04F0
	char pad_04F4[128]; //0x04F4
	float WalkThroughtWalls1; //0x0574
	float WalkThroughtWalls2; //0x0578
	float WalkThroughtWalls3; //0x057C
	__int32 iHealth; //0x0580
	char pad_0584[88]; //0x0584
	__int32 NoRecoil; //0x05DC
	char pad_05E0[192]; //0x05E0
	__int32 iCurrentWeaponID; //0x06A0
	char pad_06A4[16]; //0x06A4
	__int32 NoReload; //0x06B4
	char pad_06B8[796]; //0x06B8
	float Gravity; //0x09D4
	char pad_09D8[620]; //0x09D8
}; //Size: 0x0C44

class CCharacterHitBox //do by yourself it's easy
{
public:
	char pad_0000[324]; //0x0000
}; //Size: 0x0144

class cLTCharacterFX
{
public:
	char pad_0000[508]; //0x0000
	int8_t IsDead; //0x01FC
	char pad_01FD[15]; //0x01FD
	int8_t SpawnShield; //0x020C
	char pad_020D[799]; //0x020D
	CCharacterHitBox* pCCharacterHitBox; //0x052C
	char pad_0530[124]; //0x0530
}; //Size: 0x05AC

class CPlayer
{
public:
	char pad_0000[8]; //0x0000
	LTObject* pLTObject; //0x0008
	int8_t ClientID; //0x000C
	int8_t Team; //0x000D
	char Name[12]; //0x000E
	char pad_001A[2]; //0x001A
	cLTCharacterFX* CharacterFX; //0x001C
	__int32 PlayerSlotTeam; //0x0020
	char pad_0024[4]; //0x0024
	float Has_C4; //0x0028
	float State; //0x002C
	__int32 Rank; //0x0030
	char pad_0034[8]; //0x0034
	int8_t Health; //0x003C
	char pad_003D[1]; //0x003D
	int8_t Kill; //0x003E
	char pad_003F[1]; //0x003F
}; //Size: 0x0040

class IClientShellStub
{
public:
	CClientShell* pCClientShell; //0x0000
	char pad_0004[36]; //0x0004
	CCameraBase* pCCameraBase; //0x0028
	char pad_002C[60]; //0x002C
	int8_t IsAlive; //0x0068
	char pad_0069[7]; //0x0069
	CPlayerClntBase* pCPlayerClntBase; //0x0070
	int8_t InGame; //0x0074
	char pad_0075[15]; //0x0075
	void* ILTCSBase; //0x0084
	char pad_0088[344]; //0x0088
	CPlayer CPlayer; //0x01E0 // PlayerStart
	char pad_0220[504]; //0x0220
}; //Size: 0x0418

class CSoundMgr
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTSound
{
public:
	CSoundMgr* pCSoundMgr; //0x0000
	char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CLTCursor
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTCursor
{
public:
	CLTCursor* pCLTCursor; //0x0000
	char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CLTVideoMgr
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTVideoMgr
{
public:
	CLTVideoMgr* pCLTVideoMgr; //0x0000
	char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CSysTexInterFace
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTTexInterface
{
public:
	CSysTexInterFace* pCSysTexInterFace; //0x0000
	char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CWorldClientBSP
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class IWorldClientBSP
{
public:
	CWorldClientBSP* pCWorldClientBSP; //0x0000
	char pad_0004[128]; //0x0004
}; //Size: 0x0084

class CWorldBlindObjectData
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class IWorldBlindObjectData
{
public:
	CWorldBlindObjectData* pCWorldBlindObjectData; //0x0000
	char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CUIFontManager
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTFontManager
{
public:
	CUIFontManager* pCUIFontManager; //0x0000
	char pad_0004[128]; //0x0004
}; //Size: 0x0084

class pCLTRenderMgr
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTRenderMgr
{
public:
	pCLTRenderMgr* pCLTRenderMgr; //0x0000
	char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CWorldParticleBlockerData
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class IWorldParticleBlockerData
{
public:
	CWorldParticleBlockerData* pCWorldParticleBlockerData; //0x0000
	char pad_0004[64]; //0x0004
}; //Size: 0x0044

class ILTModelClient
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTBenchMarkMgr
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class IWorldShareBSP
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTTransform
{
public:
	char pad_0000[132]; //0x0000
}; //Size: 0x0084

class IClientDebugGraphMgr
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ICommandLineArgsCommonImp
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class IServerFileMgr
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CNetHandler
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CRezPackItm
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CBaseHashItem
{
public:
	char pad_0000[196]; //0x0000
}; //Size: 0x00C4

class CRezItm
{
public:
	CRezPackItm* pCRezPackItm; //0x0000
	char pad_0004[28]; //0x0004
	CBaseHashItem* pBaseHashItem; //0x0020
	char pad_0024[32]; //0x0024
}; //Size: 0x0044

class ICompress
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CLTModelServer
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTModelServer
{
public:
	CLTModelServer* pCLTModelServer; //0x0000
	char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CLTCommonClient
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CLTCommonShared
{
public:
	CLTCommonClient* pCLTCommonClient; //0x0000
	char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CServerFunctions
{
public:
	float ShowGameVars; //0x0000 It's a function Pointer
	char pad_0004[8]; //0x0004
	float ShowUsedFiles; //0x000C It's a function Pointer
	char pad_0010[8]; //0x0010
	float World; //0x0018 It's a function Pointer
	char pad_001C[8]; //0x001C
	float ObjectInfo; //0x0024 It's a function Pointer
	char pad_0028[8]; //0x0028
	float DisableWMPhysics; //0x0030 It's a function Pointer
	char pad_0034[8]; //0x0034
	float ExhaustMemory; //0x003C It's a function Pointer
	char pad_0040[8]; //0x0040
	float SpawnObject; //0x0048 It's a function Pointer
	char pad_004C[8]; //0x004C
}; //Size: 0x0054

class IServerConsoleState
{
public:
	char pad_0000[20]; //0x0000
	CServerFunctions* pServerFunctions; //0x0014
	char pad_0018[44]; //0x0018
}; //Size: 0x0044

class ILTServer
{
public:
	char pad_0000[152]; //0x0000
	virtual LTRESULT GetObjectPos(HLOCALOBJ hObj, LTVector *pPos) = 0; //0x0098
	virtual LTRESULT GetObjectPos2(HLOCALOBJ hObj, LTVector *pPos) = 0; //0x009C
	char pad_00A0[68]; //0x00A0
	virtual LTRESULT GetWorldBox(LTVector &min, LTVector &max) = 0; //0x00E4
	void* FindObjectIntersections; //0x00E8
	char pad_00EC[8]; //0x00EC
	virtual LTRESULT FindNamedObjects(const char *pName, BaseObjArray<HOBJECT> &objArray, uint32 *nTotalFound = NULL) = 0; //0x00F4
	virtual LTRESULT SendToObject(ILTMessage_Read *pMsg, HOBJECT hSender, HOBJECT hSendTo, uint32 flags) = 0; //0x00F8
	virtual LTRESULT SendToServer(ILTMessage_Read *pMsg, HOBJECT hSender, uint32 flags) = 0; //0x00FC
	virtual LTRESULT SetObjectSFXMessage(HOBJECT hObject,ILTMessage_Read *pMsg) = 0; //0x0100
	virtual LTRESULT SendToClient(ILTMessage_Read *pMsg,HCLIENT hSendTo, uint32 flags) = 0; //0x0104
	virtual LTRESULT SendSFXMessage(ILTMessage_Read *pMsg, uint32 flags) = 0; //0x0108
	virtual LTRESULT GetClientPing(HCLIENT hClient, float &ping) = 0; //0x010C
	char pad_0110[8]; //0x0110
	virtual LTRESULT GetClientAddr(HCLIENT hClient, uint8 pAddr[4], uint16 *pPort) = 0; //0x0118
	char pad_011C[8]; //0x011C
	virtual LTRESULT GetObjectName(HOBJECT hObject, char *pName,uint32 nameBufSize) = 0; //0x0124
	void* GetNetFlags; //0x0128
	void* SetNetFlags; //0x012C
	char pad_0130[4]; //0x0130
	void* GetClassDef; //0x0134
	char pad_0138[4]; //0x0138
	void* GetClassName; //0x013C
	char pad_0140[4]; //0x0140
	void* ThreadLoadFile; //0x0144
	void* UnloadFile; //0x0148
	void* GetHPolyObject; //0x014C
	char pad_0150[1884]; //0x0150
}; //Size: 0x08AC
class ILTPhysics
{
public:
	ILTServer* pLTServer; //0x0000
	void* GetTcpIpAddress; //0x0004
	char pad_0008[60]; //0x0008
}; //Size: 0x0044

class ILTServerPhysics
{
public:
	char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CrossFire_Engine_Class
{
public:
	ILTCSBase* pLTCSBase; //0x0000
	ILTDrawPrim* pLTDrawPrim; //0x0004
	ILTClientPhysics* pLTClientPhysics; //0x0008
	ILTWidgetManager* pLTWidgetManager; //0x000C
	ILTRenderStyles* pLTRenderStyles; //0x0010
	IClientFileMgr* pClientFileMgr; //0x0014
	IClientShellStub* pClientShellStub; //0x0018
	ILTSound* pLTSound; //0x001C
	ILTCursor* pLTCursor; //0x0020
	ILTVideoMgr* pLTVideoMgr; //0x0024
	ILTTexInterface* pLTTexInterface; //0x0028
	IWorldClientBSP* pWorldClientBSP; //0x002C
	IWorldBlindObjectData* pWorldBlindObjectData; //0x0030
	ILTFontManager* pLTFontManager; //0x0034
	ILTRenderMgr* pLTRenderMgr; //0x0038
	IWorldParticleBlockerData* pWorldParticleBlockerData; //0x003C
	ILTModelClient* pLTModelClient; //0x0040
	ILTBenchMarkMgr* pLTBenchMarkMgr; //0x0044
	char pad_0048[4]; //0x0048
	IWorldShareBSP* pWorldShareBSP; //0x004C
	ILTTransform* pLTTransform; //0x0050
	char pad_0054[12]; //0x0054
	IClientDebugGraphMgr* pClientDebugGraphMgr; //0x0060
	char pad_0064[12]; //0x0064
	ICommandLineArgsCommonImp* pCommandLine; //0x0070
	char pad_0074[8]; //0x0074
	IServerFileMgr* pServerFileMgr; //0x007C
	char pad_0080[8]; //0x0080
	CNetHandler* pCNetHandler; //0x0088
	char pad_008C[76]; //0x008C
	CRezItm* pCRezItm; //0x00D8
	char pad_00DC[200]; //0x00DC
	ICompress* pCompress; //0x01A4
	char pad_01A8[2000]; //0x01A8
	ILTModelServer* pLTModelServer; //0x0978
	char pad_097C[20]; //0x097C
	CLTCommonShared* pCLTCommonShared; //0x0990
	char pad_0994[16]; //0x0994
	IServerConsoleState* pServerConsoleState; //0x09A4
	char pad_09A8[20]; //0x09A8
	ILTPhysics* pILTPhysics; //0x09BC
	char pad_09C0[1080]; //0x09C0
	ILTServerPhysics* pLTServerPhysics; //0x0DF8
	char pad_0DFC[68]; //0x0DFC
}; //Size: 0x0E40
CrossFire_Engine_Class  *pCrossFire_Engine_Class;

How get ADDR?

Code:

006B51E0  /. 55             PUSH EBP
006B51E1  |. 8BEC           MOV EBP,ESP
006B51E3  |. 68 94010000    PUSH 194                                 ; /Arg3 = 00000194
006B51E8  |. 68 E4011701    PUSH CROSSFIR.011701E4                   ; |Arg2 = 011701E4 // ADDR_ENGINE_CLASS
006B51ED  |. 68 BC806F00    PUSH CROSSFIR.006F80BC                   ; |Arg1 = 006F80BC ASCII "ILTClient.Default"
006B51F2  |. B9 44401701    MOV ECX,CROSSFIR.01174044                ; |
006B51F7  |. E8 0482D5FF    CALL CROSSFIR.0040D400                   ; \CROSSFIR.0040D400
006B51FC  |. 68 00306D00    PUSH CROSSFIR.006D3000
006B5201  |. E8 D9DCEFFF    CALL CROSSFIR.005B2EDF
006B5206  |. 83C4 04        ADD ESP,4
006B5209  |. 5D             POP EBP
006B520A  \. C3             RETN

How to use?

Code:

void CALL_FUNCTIONS(int NoRecoil, int NoReload, int WTW, int FlyHack)
{
	pCrossFire_Engine_Class = (CrossFire_Engine_Class *)(ADDR_CROSSFIRE_ENGINE_CLASS);
	if (pCrossFire_Engine_Class->pClientShellStub->InGame == 1)
	{
		//InGame
		if (NoRecoil)
		{
			pCrossFire_Engine_Class->pClientShellStub->pCPlayerClntBase->NoRecoil = 0;
		}
		if (NoReload)
		{
			pCrossFire_Engine_Class->pClientShellStub->pCPlayerClntBase->NoReload= 12;
		}
		if (WTW)
		{
			if (GetAsyncKeyState('T'))
			{
				pCrossFire_Engine_Class->pClientShellStub->pCPlayerClntBase->WalkThroughtWalls1 = -56.0f;
				pCrossFire_Engine_Class->pClientShellStub->pCPlayerClntBase->WalkThroughtWalls2 = -140.0f;
				pCrossFire_Engine_Class->pClientShellStub->pCPlayerClntBase->WalkThroughtWalls3 = -56.0f;
			}
		}
		if (FlyHack)
		{
			if (GetAsyncKeyState('F')) // FlyHack
			{
				pCrossFire_Engine_Class->pClientShellStub->pCPlayerClntBase->Gravity = -2.5f;
			}
			else
			{
				pCrossFire_Engine_Class->pClientShellStub->pCPlayerClntBase->Gravity = 1.0f;
			}
		}
	}
	else
	{
		//Lobby
	}
}

This class have more acess but i got lazy... try find

Code:

class CrossFire_Engine_Class
{
public:
	ILTCSBase* pLTCSBase; //0x0000
	ILTDrawPrim* pLTDrawPrim; //0x0004
	ILTClientPhysics* pLTClientPhysics; //0x0008
	ILTWidgetManager* pLTWidgetManager; //0x000C
	ILTRenderStyles* pLTRenderStyles; //0x0010
	IClientFileMgr* pClientFileMgr; //0x0014
	IClientShellStub* pClientShellStub; //0x0018
	ILTSound* pLTSound; //0x001C
	ILTCursor* pLTCursor; //0x0020
	ILTVideoMgr* pLTVideoMgr; //0x0024
	ILTTexInterface* pLTTexInterface; //0x0028
	IWorldClientBSP* pWorldClientBSP; //0x002C
	IWorldBlindObjectData* pWorldBlindObjectData; //0x0030
	ILTFontManager* pLTFontManager; //0x0034
	ILTRenderMgr* pLTRenderMgr; //0x0038
	IWorldParticleBlockerData* pWorldParticleBlockerData; //0x003C
	ILTModelClient* pLTModelClient; //0x0040
	ILTBenchMarkMgr* pLTBenchMarkMgr; //0x0044
	char pad_0048[4]; //0x0048
	IWorldShareBSP* pWorldShareBSP; //0x004C
	ILTTransform* pLTTransform; //0x0050
	char pad_0054[12]; //0x0054
	IClientDebugGraphMgr* pClientDebugGraphMgr; //0x0060
	char pad_0064[12]; //0x0064
	ICommandLineArgsCommonImp* pCommandLine; //0x0070
	char pad_0074[8]; //0x0074
	IServerFileMgr* pServerFileMgr; //0x007C
	char pad_0080[8]; //0x0080
	CNetHandler* pCNetHandler; //0x0088
	char pad_008C[76]; //0x008C
	CRezItm* pCRezItm; //0x00D8
	char pad_00DC[200]; //0x00DC
	ICompress* pCompress; //0x01A4
	char pad_01A8[2000]; //0x01A8
	ILTModelServer* pLTModelServer; //0x0978
	char pad_097C[20]; //0x097C
	CLTCommonShared* pCLTCommonShared; //0x0990
	char pad_0994[16]; //0x0994
	IServerConsoleState* pServerConsoleState; //0x09A4
	char pad_09A8[20]; //0x09A8
	ILTPhysics* pILTPhysics; //0x09BC
	char pad_09C0[1080]; //0x09C0
	ILTServerPhysics* pLTServerPhysics; //0x0DF8
	char pad_0DFC[68]; //0x0DFC
}; //Size: 0x0E40

My old reverse ILTCSBase

Code:

class ILTCSBase
{
public:
	void(*function01)(); //0x0000 Acess to ILTClient
	void(*function02)(); //0x0004 
	void(*function03)(); //0x0008 
	void(*function04)(); //0x000C 
	void(*function05)(); //0x0010 
	void(*function06)(); //0x0014 
	void(*function07)(); //0x0018 
	void(*function08)(); //0x001C 
	void(*function09)(); //0x0020 
	void(*function10)(); //0x0024 
	void(*function11)(); //0x0028 
	void(*function12)(); //0x002C 
	void(*function13)(); //0x0030 
	void(*function14)(); //0x0034 
	void(*function15)(); //0x0038 
	void(*function16)(); //0x003C 
	void(*function17)(); //0x0040 
	void(*function18)(); //0x0044 
	void(*function19)(); //0x0048 
	void(*function20)(); //0x004C 
	void(*function21)(); //0x0050 
	void(*function22)(); //0x0054 
	void(*function23)(); //0x0058 
	void(*function24)(); //0x005C 
	void(*function25)(); //0x0060 
	void(*function26)(); //0x0064 
	void(*function27)(); //0x0068 
	void(*function28)(); //0x006C 
	bool(WINAPIV *IntersectSegment)(IntersectQuery &iQuery, IntersectInfo *Info); //0x0070 
	void(*function30)(); //0x0074 
	void(*function31)(); //0x0078 
	void(*function32)(); //0x007C 
	void(*function33)(); //0x0080 
	void(*function34)(); //0x0084 
	LTRESULT(*GetGameMode)(int *mode); //0x0088 
	LTRESULT(*StartGame)(/*StartGameRequest * int pRequest); //0x008C 
	LTRESULT(*GetLocalClientID)(uint32 *pID); //0x0090 
	void(*IsConnected)(); //0x0094 
	bool(*DisconnectRoom)(); //0x0098 
	void(*Shutdown)(); //0x009C 
	void(*Shutdown2)(); //0x00A0 
	LTRESULT(*GetPointShade)(LTVector *pPoint, LTVector *pColor); //0x00A4 
	LTRESULT(*FlipScreen)(uint32 flags); //0x00A8 
	LTRESULT(*Start3D)(); //0x00AC 
	LTRESULT(*RenderCamera)(HLOCALOBJ hCamera, float fFrameTime); //0x00B0 
	LTRESULT(*RenderObjects)(HLOCALOBJ hCamera, HLOCALOBJ *pObjects, int nObjects, float fFrameTime); //0x00B4 
	LTRESULT(*ClearScreen)(LTRect *pClearRect, uint32 flags, LTRGB* pClearColor); //0x00B8 
	LTRESULT(*MakeCubicEnvMap)(HLOCALOBJ hCamera, uint32 nSize, const char* pszFilePrefix); //0x00BC 
	LTRESULT(*StartOptimized2D)(); //0x00C0 
	LTRESULT(*EndOptimized2D)(); //0x00C4 
	LTRESULT(*SetOptimized2DBlend)(LTSurfaceBlend blend); //0x00C8 
	LTRESULT(*GetOptimized2DBlend)(LTSurfaceBlend &blend); //0x00CC 
	void(*function53)(); //0x00D0 
	LTRESULT(*End3D)(uint32 flags); //0x00D4 
	void(*function55)(); //0x00D8 
	LTRESULT(*GetOptimized2DColor)(HLTCOLOR &hColor); //0x00DC 
	RMode *(*GetRenderModes)(); //0x00E0 
	void(*RelinquishRenderModes)(RMode *pModes); //0x00E4 
	LTRESULT(*GetRenderMode)(RMode *pMode); //0x00E8 
	LTRESULT(*SetRenderMode)(RMode *pMode); //0x00EC 
	LTRESULT(*ShutdownRender)(uint32 flags); //0x00F0 
	void(*function62)(); //0x00F4 
	void(*function63)(); //0x00F8 
	void(*function64)(); //0x00FC 
	void(*function65)(); //0x0100 
	void(*function66)(); //0x0104 
	void(*function67)(); //0x0108 
	void(*function68)(); //0x010C 
	void(*function69)(); //0x0110 
	void(*function70)(); //0x0114 
	void(*function71)(); //0x0118 
	void(*function72)(); //0x011C 
	void(*function73)(); //0x0120 
	LTRESULT(*GetBorderSize)(HSURFACE hSurface, HLTCOLOR hColor, LTRect *pRect); //0x0124 
	LTRESULT(*OptimizeSurface)(HSURFACE hSurface, HLTCOLOR hTransparentColor); //0x0128 
	LTRESULT(*UnoptimizeSurface)(HSURFACE hSurface); //0x012C 
	void(*function77)(); //0x0130 
	void(*function78)(); //0x0134 
	void(*function79)(); //0x0138 
	void(*function80)(); //0x013C 
	void(*function81)(); //0x0140 
	void(*function82)(); //0x0144 
	void(*function83)(); //0x0148 
	void(*function84)(); //0x014C 
	void(*function85)(); //0x0150 
	void(*function86)(); //0x0154 
	void(*function87)(); //0x0158 
	void(*function88)(); //0x015C 
	void(*function89)(); //0x0160 
	void(*function90)(); //0x0164 
	void(*function91)(); //0x0168 
	void(*function92)(); //0x016C 
	void(*function93)(); //0x0170 
	void(*function94)(); //0x0174 
	void(*function95)(); //0x0178 
	void(*function96)(); //0x017C 
	void(*function97)(); //0x0180 
	void(*function98)(); //0x0184 
	void(*function99)(); //0x0188 
	void(*function100)(); //0x018C 
	void(*function101)(); //0x0190 
	void(*function102)(); //0x0194 
	void(*function103)(); //0x0198 
	void(*function104)(); //0x019C 
	void(*function105)(); //0x01A0 
	void(*function106)(); //0x01A4 
	void(*function107)(); //0x01A8 
	void(*function108)(); //0x01AC 
	void(*function109)(); //0x01B0 
	void(*function110)(); //0x01B4 
	void(*function111)(); //0x01B8 
	void(*function112)(); //0x01BC 
	void(*function113)(); //0x01C0 
	void(*function114)(); //0x01C4 
	void(*function115)(); //0x01C8 
	void(*function116)(); //0x01CC 
	void(*function117)(); //0x01D0 
	void(*function118)(); //0x01D4 
	void(*function119)(); //0x01D8 
	void(*function120)(); //0x01DC 
	void(*function121)(); //0x01E0 
	void(*function122)(); //0x01E4 
	void(*function123)(); //0x01E8 
	void(*function124)(); //0x01EC 
	void(*function125)(); //0x01F0 
	void(*function126)(); //0x01F4 
	void(*function127)(); //0x01F8 
	float(*GetGameTime)(); //0x01FC 
	float(*GetGameFrameTime)(); //0x0200 
	void(*function130)(); //0x0204 
	void(*function131)(); //0x0208 
	void(*function132)(); //0x020C 
	void(WINAPIV *RunConsoleCommand)(CHAR *Command); //0x0210 
	void(*function134)(); //0x0214 
	void(*function135)(); //0x0218 
	void(*function136)(); //0x021C 
	void(*function137)(); //0x0220 
	void(*function138)(); //0x0224 
	void(*function139)(); //0x0228 
	void(*function140)(); //0x022C 
	void(*function141)(); //0x0230 
	void(*function142)(); //0x0234 
	void(*function143)(); //0x0238 
	LTRESULT SendToServer(/*ILTMessage_Read int *pMsg, uint32 flags); //0x023C 
	LTRESULT GetServerIPAddress(uint8 pAddr[4], uint16 *pPort); //0x0240 

};//Size=0x0244

Stuffs

Code:

struct RMode
{
	//!	Does this mode support hardware TnL?
	bool m_bHWTnL;

	//! This is what the DLLs use to identify a card.
	char m_InternalName[128];

	//! This is a 'friendly' string describing the card.
	char m_Description[128];

	//! The dimensions and bit depth of this mode
	uint32 m_Width, m_Height, m_BitDepth;

	//! The next mode in the list
	RMode *m_pNext;
};
enum LTSurfaceBlend {
	LTSURFACEBLEND_ALPHA, //! Alpha blend (lerp(src, dest, alpha))
	LTSURFACEBLEND_SOLID, //! Solid (src)
	LTSURFACEBLEND_ADD, //! Add (src + dest)
	LTSURFACEBLEND_MULTIPLY, //! Multiply (src * dest)
	LTSURFACEBLEND_MULTIPLY2, //! Multiply * 2 (src * dest * 2)
	LTSURFACEBLEND_MASK, //! Mask ((1 - src) * dest)
	LTSURFACEBLEND_MASKADD //! Mask & Add (src + (1 - src) * dest)
};

class LTRect {
public:

	/*!
	\param l x position of left side
	\param t y position of top side
	\param r x position of right side
	\param b y position of bottom side

	Used for: Misc.
	*/
	LTRect(int l = 0, int t = 0, int r = 0, int b = 0) : left(l), top(t), right(r), bottom(b) {}

	/*!
	\param inLeft x position of left side
	\param inTop y position of top side
	\param inRight x position of right side
	\param inBottom y position of bottom side

	Initialize the values.

	Used for:   2D Rendering.
	*/
	void Init(int inLeft, int inTop, int inRight, int inBottom) {
		left = inLeft;
		top = inTop;
		right = inRight;
		bottom = inBottom;
	}

	int left, top, right, bottom;
};

struct LTRGB { uint8 b, g, r, a; };

Hey bro, how you do this?
I used REClass

Credits: ReClass and dreek1

GoodBye MPGH : (

CPlayer,cLTCharacterFx,CCharacterHitBox,ILTFontMan ager Acessing Class

Post a Reply

Similar Threads

Tags for this Thread