Welcome to Ramleague,

Ramleague - the best site for pinoy chat, games chat and mobiles chat,

Sign Up
  1. Hello guest Guest , Are you tired from Ads? to remove some ads you need to register and be active. :D

[Source Code] Latest CLTClient & ILTCSBase functions

Discussion in 'CrossFire Source Code & Tutorials' started by ACEOFEAGLE, Jun 18, 2020.

  1. ACEOFEAGLE RAML Expert
    Contributor Member Lvl2

    Joined:
    Dec 25, 2016
    Gender:
    Female
    Posts:
    1,310
    Reputation:
    743
    Thanks:
    994
    Bored

    Latest CLTClient & ILTCSBase functions

    Code:
    bool                ILTClient::IntersectSegment(IntersectQuery& iQuery, IntersectInfo* Info)
    {
        typedef bool(__thiscall* IntersectSegmentFn)(void*, IntersectQuery& iQuery, IntersectInfo* Info);
        return GetVFunc<IntersectSegmentFn>(this, 35)(this, iQuery, Info);
    }
    
    ILTVideoMgr*        ILTClient::VideoMgr()
    {
        typedef ILTVideoMgr* (__thiscall* Fn)(void*);
        return *reinterpret_cast<ILTVideoMgr**>(GetVFunc<Fn>(this, 2)(this));
    }
    ILTDrawPrim*        ILTClient::GetDrawPrim()
    {
        typedef ILTDrawPrim* (__thiscall* Fn)(void*);
        return *reinterpret_cast<ILTDrawPrim**>(GetVFunc<Fn>(this, 3)(this));
    }
    ILTTexInterface*    ILTClient::GetTexInterface()
    {
        typedef ILTTexInterface* (__thiscall* Fn)(void*);
        return *reinterpret_cast<ILTTexInterface**>(GetVFunc<Fn>(this, 4)(this));
    }
    ILTWidgetManager*   ILTClient::GetWidgetManager()
    {
        typedef ILTWidgetManager* (__thiscall* Fn)(void*);
        return *reinterpret_cast<ILTWidgetManager**>(GetVFunc<Fn>(this, 5)(this));
    }
    ILTFontManager*     ILTClient::GetFontManager()
    {
        typedef ILTFontManager* (__thiscall* Fn)(void*);
        return *reinterpret_cast<ILTFontManager**>(GetVFunc<Fn>(this, 6)(this));
    }
    ILTCursor*          ILTClient::Cursor()
    {
        typedef ILTCursor* (__thiscall* Fn)(void*);
        return *reinterpret_cast<ILTCursor**>(GetVFunc<Fn>(this, 7)(this));
    }
    ILTDirectMusicMgr*  ILTClient::GetDirectMusicMgr()
    {
        typedef ILTDirectMusicMgr* (__thiscall* Fn)(void*);
        return *reinterpret_cast<ILTDirectMusicMgr**>(GetVFunc<Fn>(this, 8)(this));
    }
    ILTBenchmarkMgr*    ILTClient::GetBenchmarkMgr()
    {
        typedef ILTBenchmarkMgr* (__thiscall* Fn)(void*);
        return *reinterpret_cast<ILTBenchmarkMgr**>(GetVFunc<Fn>(this, 9)(this));
    }
    
    int                    ILTClient::GetGameMode(int* mode)
    {
        typedef int(__thiscall* GetGameModeFn)(void*, int* mode);
        return GetVFunc<GetGameModeFn>(this, 42)(this, mode);
    }
    signed int            ILTClient::GetLocalClientID(uint32* pID)
    {
        typedef signed int(__thiscall* GetLocalClientIDFn)(void*, uint32* pID);
        return GetVFunc<GetLocalClientIDFn>(this, 44)(this, pID);
    }
    bool                ILTClient::IsConnected()
    {
        typedef bool(*IsConnectedFn)(void*);
        return GetVFunc<IsConnectedFn>(this, 47)(this);
    }
    void                ILTClient::ShutdownWithMessage(const char* pMsg, ...)
    {
        typedef void(__thiscall* ShutdownWithMessageFn)(void*, const char* pMsg);
        return GetVFunc<ShutdownWithMessageFn>(this, 48)(this, pMsg);
    }
    
    float                ILTClient::GetUnk()
    {
        typedef float(*GetGameTimeFn)(void*);
        return GetVFunc<GetGameTimeFn>(this, 136)(this);
    }
    float                ILTClient::GetGameTime()
    {
        typedef float(*GetGameFrameTimeFn)(void*);
        return GetVFunc<GetGameFrameTimeFn>(this, 137)(this);
    }
    float                ILTClient::GetGameFrameTime()
    {
        typedef float(*GetUnkFn)(void*);
        return GetVFunc<GetUnkFn>(this, 138)(this);
    }
    
    unsigned int        ILTClient::RunConsoleCommand(const char* Command, bool useVT)
    {
        typedef unsigned int(__thiscall* RunConsoleCommandFn)(void*, const char*);
        return GetVFunc<RunConsoleCommandFn>(this, 142)(this, Command);
    }
    HOBJECT             ILTClient::GetClientObject()
    {
        typedef HOBJECT(*GetClientObjectFn)(void*);
        return GetVFunc<GetClientObjectFn>(this, 143)(this);
    }
    
    void                ILTClient::GetObjectScale(HLOCALOBJ hObj, D3DXVECTOR3* pScale)
    {
        typedef void(__thiscall* GetObjectScaleFn)(void*, HLOCALOBJ hObj, D3DXVECTOR3* pScale);
        return GetVFunc<GetObjectScaleFn>(this, 149)(this, hObj, pScale);
    }
    void                ILTClient::SetObjectScale(HLOCALOBJ hObj, const D3DXVECTOR3* pScale)
    {
        typedef void(__thiscall* SetObjectScaleFn)(void*, HLOCALOBJ hObj, const D3DXVECTOR3* pScale);
        return GetVFunc<SetObjectScaleFn>(this, 150)(this, hObj, pScale);
    }
    void                ILTClient::SetObjectRotation(HLOCALOBJ hObj, const LTRotation* pRotation)
    {
        typedef void(__thiscall* SetObjectRotationFn)(void*, HLOCALOBJ hObj, const LTRotation* pRotation);
        return GetVFunc<SetObjectRotationFn>(this, 151)(this, hObj, pRotation);
    }
    void                ILTClient::GetObjectColor(HLOCALOBJ hObj, float* r, float* g, float* b, float* a)
    {
        typedef void(__thiscall* GetObjectColorFn)(void*, HLOCALOBJ hObj, float* r, float* g, float* b, float* a);
        return GetVFunc<GetObjectColorFn>(this, 152)(this, hObj, r, g, b, a);
    }
    void                ILTClient::SetObjectColor(HLOCALOBJ hObj, float r, float g, float b, float a)
    {
        typedef void(__thiscall* SetObjectColorFn)(void*, HLOCALOBJ hObj, float r, float g, float b, float a);
        return GetVFunc<SetObjectColorFn>(this, 153)(this, hObj, r, g, b, a);
    }
    CObjectType*        ILTClient::GetObjectUserData(HLOCALOBJ hObj)
    {
        typedef CObjectType* (__thiscall* GetObjectUserDataFn)(void*, HLOCALOBJ hObj);
        return GetVFunc<GetObjectUserDataFn>(this, 154)(this, hObj);
    }
    void                ILTClient::SetObjectUserData(HLOCALOBJ hObj, void* pData)
    {
        typedef void(__thiscall* SetObjectUserDataFn)(void*, HLOCALOBJ hObj, void* pData);
        return GetVFunc<SetObjectUserDataFn>(this, 155)(this, hObj, pData);
    }
    Code:
    ILTCommon*                ILTCSBase::Common()
    {
        typedef ILTCommon* (__thiscall* ILTCommonFn)(void*);
        return *reinterpret_cast<ILTCommon**>(GetVFunc<ILTCommonFn>(this, 1)(this));
    }
    ILTPhysics*                ILTCSBase::Physics()
    {
        typedef ILTPhysics* (__thiscall* ILTPhysicsFn)(void*);
        return *reinterpret_cast<ILTPhysics**>(GetVFunc<ILTPhysicsFn>(this, 2)(this));
    }
    ILTTransform*            ILTCSBase::GetTransformLT()
    {
        typedef ILTTransform* (__thiscall* PTransformFn)(void*);
        return *reinterpret_cast<ILTTransform**>(GetVFunc<PTransformFn>(this, 3)(this));
    }
    ILTModel*                ILTCSBase::GetModelLT()
    {
        typedef ILTModel* (__thiscall* ICLTModelFn)(void*);
        return *reinterpret_cast<ILTModel**>(GetVFunc<ICLTModelFn>(this, 4)(this));
    }
    ILTSoundMgr*            ILTCSBase::SoundMgr()
    {
        typedef ILTSoundMgr* (__thiscall* ILTSoundMgrFn)(void*);
        return *reinterpret_cast<ILTSoundMgr**>(GetVFunc<ILTSoundMgrFn>(this, 5)(this));
    }
    
    signed int                ILTCSBase::GetObjectRotation(HLOCALOBJ hObj, LTRotation* pRotation)
    {
        typedef signed int(__thiscall* GetObjectRotationFn)(void*, HLOCALOBJ hObj, LTRotation* pRotation);
        return GetVFunc<GetObjectRotationFn>(this, 39)(this, hObj, pRotation);
    }
    signed int                ILTCSBase::GetObjectPos(HLOCALOBJ hObj, D3DXVECTOR3* pPos)
    {
        typedef signed int(__thiscall* GetObjectPosFn)(void*, HLOCALOBJ hObj, D3DXVECTOR3* pPos);
        return GetVFunc<GetObjectPosFn>(this, 40)(this, hObj, pPos);
    }
    
    HMODELANIM                ILTCSBase::GetAnimIndex(HLOCALOBJ hObj, const char* pAnimName)
    {
        typedef int(__thiscall* GetAnimIndexFn)(void*, HLOCALOBJ, const char*);
        return GetVFunc<GetAnimIndexFn>(this, 41)(this, hObj, pAnimName);
    }
    void                    ILTCSBase::SetModelAnimation(HLOCALOBJ hObj, HMODELANIM hAnim)
    {
        typedef int(__thiscall* SetModelAnimationFn)(void*, HLOCALOBJ, HMODELANIM);
        /*return */GetVFunc<SetModelAnimationFn>(this, 42)(this, hObj, hAnim);
    }
    HMODELANIM                ILTCSBase::GetModelAnimation(HLOCALOBJ hObj)
    {
        //signed int __stdcall sub_5DC560(int a1)
        typedef int(__thiscall* GetModelAnimationFn)(void*, HLOCALOBJ);
        return GetVFunc<GetModelAnimationFn>(this, 43)(this, hObj);
    }
    void                    ILTCSBase::SetModelLooping(HLOCALOBJ hObj, bool bLoop)
    {
        typedef int(__thiscall* SetModelLoopingFn)(void*, HLOCALOBJ, bool);
        /*return*/GetVFunc<SetModelLoopingFn>(this, 44)(this, hObj, bLoop);
    }
    bool                    ILTCSBase::GetModelLooping(HLOCALOBJ hObj)
    {
        typedef int(__thiscall* GetModelLoopingFn)(void*, HLOCALOBJ);
        return GetVFunc<GetModelLoopingFn>(this, 45)(this, hObj);
    }
    LTRESULT                ILTCSBase::ResetModelAnimation(HLOCALOBJ hObj)
    {
        typedef int(__thiscall* ResetModelAnimationFn)(void*, HLOCALOBJ);
        return GetVFunc<ResetModelAnimationFn>(this, 46)(this, hObj);
    }
    
    HSTRING                    ILTCSBase::CreateString(const char* pString)
    {
        return NULL;
    }
    void                    ILTCSBase::FreeString(HSTRING hString)
    {
    
    }
    bool                    ILTCSBase::CompareStrings(HSTRING hString1, HSTRING hString2)
    {
        typedef bool(__thiscall* CompareStringsFn)(void*, HSTRING hString1, HSTRING hString2);
        return GetVFunc<CompareStringsFn>(this, 20)(this, hString1, hString2);
    }
    bool                    ILTCSBase::CompareStringsUpper(HSTRING hString1, HSTRING hString2)
    {
        typedef bool(__thiscall* CompareStringsUpperFn)(void*, HSTRING hString1, HSTRING hString2);
        return GetVFunc<CompareStringsUpperFn>(this, 21)(this, hString1, hString2);
    }
    const char*                ILTCSBase::GetStringData(HSTRING hString)
    {
        typedef const char* (__thiscall* GetStringDataFn)(void*, HSTRING hString);
        return GetVFunc<GetStringDataFn>(this, 22)(this, hString);
    }
    float                    ILTCSBase::GetVarValueFloat(HCONSOLEVAR hVar)
    {
        typedef float(__thiscall* GetVarValueFloatFn)(void*, HCONSOLEVAR hVar);
        return GetVFunc<GetVarValueFloatFn>(this, 23)(this, hVar);
    }
    const char*                ILTCSBase::GetVarValueString(HCONSOLEVAR hVar)
    {
        typedef const char* (__thiscall* GetVarValueStringFn)(void*, HCONSOLEVAR hVar);
        return GetVFunc<GetVarValueStringFn>(this, 24)(this, hVar);
    }
    
    LTFLOAT                    ILTCSBase::GetTime()
    {
        typedef LTFLOAT(*GetTimeFn)(void*);
        return GetVFunc<GetTimeFn>(this, 25)(this);
    }
    LTFLOAT                    ILTCSBase::GetFrameTime()
    {
        typedef LTFLOAT(__thiscall* GetFrameTimeFn)(void*);
        return GetVFunc<GetFrameTimeFn>(this, 26)(this);
    }
    LTRESULT                ILTCSBase::GetSourceWorldOffset(LTVector& vOffset)
    {
        typedef LTRESULT(__thiscall* GetSourceWorldOffsetFn)(void*, LTVector& vOffset);
        return GetVFunc<GetSourceWorldOffsetFn>(this, 27)(this, vOffset);
    }
    signed int                ILTCSBase::RemoveObject(HLOCALOBJ hObj)
    {
        typedef signed int(__thiscall* RemoveObjectFn)(void*, HLOCALOBJ hObj);
        return GetVFunc<RemoveObjectFn>(this, 29)(this, hObj);
    }
    
    signed int                ILTCSBase::SetObjectOutLine(HLOCALOBJ hObj, BYTE a1, BYTE r, BYTE g, BYTE b)
    {
        typedef signed int(__thiscall* SetObjectOutLineFn)(void*, HLOCALOBJ, BYTE, BYTE, BYTE, BYTE);
        return GetVFunc<SetObjectOutLineFn>(this, 67)(this, hObj, a1, r, g, b);
    }
    signed int                ILTCSBase::UpdateObjectOutLine(HLOCALOBJ hObj, HLOCALOBJ Replace)
    {
        typedef signed int(__thiscall* UpdateObjectOutLineFn)(void*, HLOCALOBJ, HLOCALOBJ);
        return GetVFunc<UpdateObjectOutLineFn>(this, 68)(this, hObj, Replace);
    }
    signed int                ILTCSBase::GetObjectBoxMin(HLOCALOBJ hObj, D3DXVECTOR3* Min)
    {
        typedef signed int(__thiscall* GetObjectBoxMinFn)(void*, HLOCALOBJ hObj, D3DXVECTOR3* Min);
        return GetVFunc<GetObjectBoxMinFn>(this, 141)(this, hObj, Min);
    }
    signed int                ILTCSBase::GetObjectBoxMax(HLOCALOBJ hObj, D3DXVECTOR3* Max)
    {
        typedef signed int(__thiscall* GetObjectBoxMaxFn)(void*, HLOCALOBJ hObj, D3DXVECTOR3* Max);
        return GetVFunc<GetObjectBoxMaxFn>(this, 142)(this, hObj, Max);
    }
    
    signed int                ILTCSBase::SetObjectPos(HLOCALOBJ hObj, const D3DXVECTOR3* pPos, bool bForce)
    {
        typedef signed int(__thiscall* SetObjectPosFn)(void*, HLOCALOBJ hObj, const D3DXVECTOR3* pPos, bool bForce);
        return GetVFunc<SetObjectPosFn>(this, 59)(this, hObj, pPos, bForce);
    }
    signed int                ILTCSBase::GetSConValueFloat(const char* pName, float& val)
    {
        typedef signed int(__stdcall* GetSConValueFloatFn)(void*, const char* pName, float& val);
        return GetVFunc<GetSConValueFloatFn>(this, 110)(this, pName, val);
    }
    signed int                ILTCSBase::GetSConValueString(const char* pName, char* valBuf, uint32 bufLen)
    {
        typedef signed int(__stdcall* GetSConValueStringFn)(void*, const char* pName, char* valBuf, uint32 bufLen);
        return GetVFunc<GetSConValueStringFn>(this, 109)(this, pName, valBuf, bufLen);
    }
    LTRESULT                ILTCSBase::SendToServer(ILTMessage_Read* msg, uint32 flags)
    {
        typedef LTRESULT(__thiscall* _SendToServer)(void*, ILTMessage_Read*, uint32);
        return GetVFunc<_SendToServer>(this, 120)(this, msg, flags);
    }
     
    1 person thanks this.
    • BE A GAMER - RAMLeague
Loading...

Advertisement

Similar Threads Forum Date
Reversed CLTClient [Latest] CrossFire Source Code & Tutorials Feb 26, 2019
'21 supplied. Latest CAD CAM CAE ftp down PC Apllications Feb 19, 2021
'21 supplied. Latest CAD CAM CAE ftp down PC Apllications Feb 19, 2021
CFPH | NO MENU HACKS LATEST UPDATE - 05/29/2020 | V3.5 CrossFire May 29, 2020
CFPH | NO MENU HACKS LATEST UPDATE - 05/28/2020 | V3.4 CrossFire May 28, 2020
CFPH | NO MENU HACKS LATEST UPDATE - 05/25/2020 | V3.3 CrossFire May 25, 2020

Tags for this Thread

:

Share This Page