css sdk

#ifndef SDK_H
#define SDK_H

#include "Math.h"
#include "Util.h"

#include "dt_recv.h"
#include "checksum_crc.h"
#include "checksum_md5.h"

// ================================
// C_BaseEntity::m_fFlags flags
// ================================
#define FL_ONGROUND         (1 << 0)
#define FL_DUCKING          (1 << 1)

// ================================
// CUserCmd::buttons flags
// ================================
#define IN_ATTACK           (1 << 0)
#define IN_JUMP             (1 << 1)
#define IN_DUCK             (1 << 2)

// ================================
// CUserCmd::m_pCommands size
// ================================
#define MULTIPLAYER_BACKUP  90

// ================================
// Max player name size
// Used in player_info_t
// ================================
#define MAX_PLAYER_NAME_LENGTH  32

#undef CreateFont

// ================================
// CreateInterface
// Used to get interface pointers
// ================================
typedef void* (*CreateInterfaceFn)( const char*, int* );

// ================================
// CreateMove
// Called each tick (hook for aim/triggerbot/bhop/etc.)
// ================================
typedef void (__thiscall* CreateMoveFn)( void*, int, float, bool );

// ================================
// FrameStageNotify
// Called several times each frame (hook it for no visual recoil)
// ================================
typedef void (__thiscall* FrameStageNotifyFn)( void*, unsigned int );

// ================================
// PaintTraverse
// Called several times each frame to render panels (hook it for 2d drawing)
// ================================
typedef void (__thiscall* PaintTraverseFn)( void*, unsigned int, bool, bool );

// ================================
// C_BaseEntity class
// ================================
class C_BaseEntity;

// ================================
// C_BaseWeapon class
// ================================
class C_BaseWeapon;

// ================================
// IMoveHelper class
// ================================
class IMoveHelper;

// ================================
// CUserCmd class
// ================================
class CUserCmd;

// ================================
// Weapon ID's enum
// ================================
enum WeaponID_t
{
    WEAPON_NONE = 0,
    WEAPON_P228,
    WEAPON_GLOCK18,
    WEAPON_SCOUT,
    WEAPON_HEGRENADE,
    WEAPON_XM1014,
    WEAPON_C4,
    WEAPON_MAC10,
    WEAPON_AUG,
    WEAPON_SMOKEGRENADE,
    WEAPON_ELITE,
    WEAPON_FIVESEVEN,
    WEAPON_UMP45,
    WEAPON_SG550,
    WEAPON_GALIL,
    WEAPON_FAMAS,
    WEAPON_USP45,
    WEAPON_AWP,
    WEAPON_MP5,
    WEAPON_M249,
    WEAPON_M3,
    WEAPON_M4A1,
    WEAPON_TMP,
    WEAPON_G3SG1,
    WEAPON_FLASHBANG,
    WEAPON_DEAGLE,
    WEAPON_SG552,
    WEAPON_AK47,
    WEAPON_KNIFE,
    WEAPON_P90,
    WEAPON_SHIELD,
    WEAPON_KEVLAR,
    WEAPON_ASSAULTSUIT,
    WEAPON_NIGHTVISION
};

struct model_t
{
    void*           fnHandle;
    char            szName[96];
    int             nLoadFlags;
    int             nServerCount;
    unsigned int    type;
    int             flags;
    Vector          mins, maxs;
    float           radius;
};

// ================================
// player_info_t struct
// Holds usefull information about player entities
// ================================
struct player_info_t
{
    char            name[MAX_PLAYER_NAME_LENGTH];
    int             userID;
    char            guid[MAX_PLAYER_NAME_LENGTH + 1];
    unsigned int    friendsID;
    char            friendsName[MAX_PLAYER_NAME_LENGTH];
    bool            fakeplayer;
    bool            ishltv;
    unsigned long   customFiles[4];
    unsigned char   filesDownloaded;
};

// ================================
// mstudiobbox_t struct
// Holds info about model hitboxes
// ================================
struct mstudiobbox_t
{
    int     bone;
    int     group;
    Vector  bbmin;
    Vector  bbmax;
    int     szhitboxnameindex;
    int     unused[8];

    char* GetHitboxName ( void )
    {
        if ( szhitboxnameindex == 0 )
            return "";

        return ((char*)this) + szhitboxnameindex;
    }
};

struct mstudiohitboxset_t
{
    int                     sznameindex;
    inline char* const      GetName ( void ) const { return ( ( char* )this ) + sznameindex; }
    int                     numhitboxes;
    int                     hitboxindex;
    inline mstudiobbox_t*   GetHitbox ( int i ) const { return ( mstudiobbox_t* )( ( ( byte* )this ) + hitboxindex ) + i; };
};

struct mstudiobone_t
{
    int                 sznameindex;
    inline char * const GetName( void ) const { return ((char *)this) + sznameindex; }
    int                 parent;
    int                 bonecontroller[6];

    Vector              pos;
    float               quat[4];
    Vector              rot;
    Vector              posscale;
    Vector              rotscale;

    matrix3x4_t         poseToBone;
    float               qAlignment[4];
    int                 flags;
    int                 proctype;
    int                 procindex;      // procedural rule
    mutable int         physicsbone;    // index into physically simulated bone
    inline void *       GetProcedure( ) const { if (procindex == 0) return NULL; else return  (void *)(((byte *)this) + procindex); };
    int                 surfacepropidx; // index into string tablefor property name
    inline char * const GetSurfaceProps( void ) const { return ((char *)this) + surfacepropidx; }
    int                 contents;       // See BSPFlags.h for the contents flags

    int                 unused[8];      // remove as appropriate
};

struct studiohdr_t
{
    int                 id;
    int                 version;

    int                 checksum;

    char                name[64];
    int                 length;


    Vector              eyeposition;

    Vector              illumposition;

    Vector              hull_min;
    Vector              hull_max;

    Vector              view_bbmin;
    Vector              view_bbmax;

    int                 flags;

    int                 numbones;
    int                 boneindex;

    inline mstudiobone_t *GetBone( int i ) const { return (mstudiobone_t *)(((byte *)this) + boneindex) + i; };

    int                 numbonecontrollers;
    int                 bonecontrollerindex;

    int                 numhitboxsets;
    int                 hitboxsetindex;

    mstudiohitboxset_t* GetHitboxSet( int i ) const
    {
        return ( mstudiohitboxset_t* )( ( ( byte* )this ) + hitboxsetindex ) + i;
    }

    inline mstudiobbox_t* GetHitbox( int i, int set ) const
    {
        mstudiohitboxset_t const* s = GetHitboxSet( set );

        if( !s )
            return NULL;

        return s->GetHitbox( i );
    }

    inline int GetHitboxCount( int set ) const
    {
        mstudiohitboxset_t const* s = GetHitboxSet( set );

        if( !s )
            return 0;

        return s->numhitboxes;
    }

    int                 numlocalanim;
    int                 localanimindex;

    int                 numlocalseq;
    int                 localseqindex;

    mutable int         activitylistversion;
    mutable int         eventsindexed;

    int                 numtextures;
    int                 textureindex;

    int                 numcdtextures;
    int                 cdtextureindex;

    int                 numskinref;
    int                 numskinfamilies;
    int                 skinindex;

    int                 numbodyparts;
    int                 bodypartindex;

    int                 numlocalattachments;
    int                 localattachmentindex;

    int                 numlocalnodes;
    int                 localnodeindex;
    int                 localnodenameindex;

    int                 numflexdesc;
    int                 flexdescindex;

    int                 numflexcontrollers;
    int                 flexcontrollerindex;

    int                 numflexrules;
    int                 flexruleindex;

    int                 numikchains;
    int                 ikchainindex;

    int                 nummouths;
    int                 mouthindex;

    int                 numlocalposeparameters;
    int                 localposeparamindex;

    int                 surfacepropindex;

    int                 keyvalueindex;
    int                 keyvaluesize;


    int                 numlocalikautoplaylocks;
    int                 localikautoplaylockindex;

    float               mass;
    int                 contents;

    int                 numincludemodels;
    int                 includemodelindex;

    mutable void        *virtualModel;

    int                 szanimblocknameindex;
    int                 numanimblocks;
    int                 animblockindex;

    mutable void        *animblockModel;

    int                 bonetablebynameindex;

    void                *pVertexBase;
    void                *pIndexBase;

    byte                constdirectionallightdot;

    byte                rootLOD;

    byte                numAllowedRootLODs;

    byte                unused[1];

    int                 unused4;

    int                 numflexcontrollerui;
    int                 flexcontrolleruiindex;
    float               flVertAnimFixedPointScale;
    int                 unused3[1];
    int                 studiohdr2index;
    int                 unused2[1];
};

class CUserCmd
{
public:
    CUserCmd ( void ) { Reset (); }

    virtual ~CUserCmd ( void );

    void Reset ( void )
    {
        command_number = 0;
        tick_count = 0;
        viewangles.Init ();
        forwardmove = 0.0f;
        sidemove = 0.0f;
        upmove = 0.0f;
        buttons = 0;
        impulse = 0;
        weaponselect = 0;
        weaponsubtype = 0;
        random_seed = 0;
        mousedx = 0;
        mousedy = 0;
        hasbeenpredicted = false;
    }

    CUserCmd& operator = ( const CUserCmd& src )
    {
        if ( this == &src )
            return *this;

        command_number      = src.command_number;
        tick_count          = src.tick_count;
        viewangles          = src.viewangles;
        forwardmove         = src.forwardmove;
        sidemove            = src.sidemove;
        upmove              = src.upmove;
        buttons             = src.buttons;
        impulse             = src.impulse;
        weaponselect        = src.weaponselect;
        weaponsubtype       = src.weaponsubtype;
        random_seed         = src.random_seed;
        mousedx             = src.mousedx;
        mousedy             = src.mousedy;
        hasbeenpredicted    = src.hasbeenpredicted;

        return *this;
    }

    CUserCmd ( const CUserCmd& src )
    {
        *this = src;
    }

    CRC32_t GetChecksum ( void )
    {
        CRC32_t crc;

        CRC32_Init ( &crc );
        CRC32_ProcessBuffer ( &crc, &command_number, sizeof(command_number) );
        CRC32_ProcessBuffer ( &crc, &tick_count, sizeof(tick_count) );
        CRC32_ProcessBuffer ( &crc, &viewangles, sizeof(viewangles) );
        CRC32_ProcessBuffer ( &crc, &forwardmove, sizeof(forwardmove) );
        CRC32_ProcessBuffer ( &crc, &sidemove, sizeof(sidemove) );
        CRC32_ProcessBuffer ( &crc, &upmove, sizeof(upmove) );
        CRC32_ProcessBuffer ( &crc, &buttons, sizeof(buttons) );
        CRC32_ProcessBuffer ( &crc, &impulse, sizeof(impulse) );
        CRC32_ProcessBuffer ( &crc, &weaponselect, sizeof(weaponselect) );
        CRC32_ProcessBuffer ( &crc, &weaponsubtype, sizeof(weaponsubtype) );
        CRC32_ProcessBuffer ( &crc, &random_seed, sizeof(random_seed) );
        CRC32_ProcessBuffer ( &crc, &mousedx, sizeof(mousedx) );
        CRC32_ProcessBuffer ( &crc, &mousedy, sizeof(mousedy) );
        CRC32_Final ( &crc );

        return crc;
    }

    int     command_number;
    int     tick_count;
    Vector  viewangles;
    float   forwardmove;
    float   sidemove;
    float   upmove;
    int     buttons;
    byte    impulse;
    int     weaponselect;
    int     weaponsubtype;
    int     random_seed;
    short   mousedx;
    short   mousedy;
    bool    hasbeenpredicted;
};

class CVerifiedUserCmd
{
public:
    CUserCmd    m_cmd;
    CRC32_t     m_crc;
};

class ClientClass
{
public:
    const char* GetNetworkName ( void )
    {
        return m_pNetworkName;
    }

    RecvTable* GetTable ( void )
    {
        return m_pRecvTable;
    }

    ClientClass* GetNext ( void )
    {
        return m_pNext;
    }

    int GetID ( void )
    {
        return m_iClassID;
    }

private:
    unsigned char   __pad0[0x8];

    const char*     m_pNetworkName;
    RecvTable*      m_pRecvTable;
    ClientClass*    m_pNext;
    int             m_iClassID;
};

class IBaseClientDLL
{
public:
    ClientClass* GetAllClasses ( void )
    {
        typedef ClientClass* (__thiscall* GetAllClassesFn)( void* );
        return GetMethod<GetAllClassesFn> ( this, 8 )( this );
    }
};

class IClientEntityList
{
public:
    C_BaseEntity* GetClientEntity ( int nIndex )
    {
        typedef C_BaseEntity* (__thiscall* GetClientEntityFn)( void*, int );
        return GetMethod<GetClientEntityFn> ( this, 3 )( this, nIndex );
    }

    C_BaseEntity* GetClientEntityFromHandle ( int nHandle )
    {
        typedef C_BaseEntity* (__thiscall* GetClientEntityFromHandleFn)( void*, int );
        return GetMethod<GetClientEntityFromHandleFn> ( this, 4 )( this, nHandle );
    }

    int GetHighestEntityIndex ( void )
    {
        typedef int (__thiscall* GetHighestEntityIndexFn)( void* );
        return GetMethod<GetHighestEntityIndexFn> ( this, 6 )( this );
    }
};

class IVEngineClient
{
public:
    void GetScreenSize ( int& width, int& height )
    {
        typedef void (__thiscall* GetScreenSizeFn)( void*, int&, int& );
        return GetMethod<GetScreenSizeFn> ( this, 5 )( this, width, height );
    }

    bool GetPlayerInfo ( int ent_num, player_info_t* info )
    {
        typedef bool (__thiscall* GetPlayerInfoFn)( void*, int, player_info_t* );
        return GetMethod<GetPlayerInfoFn> ( this, 8 )( this, ent_num, info );
    }

    bool Con_IsVisible ( void )
    {
        typedef bool (__thiscall* Con_IsVisibleFn)( void* );
        return GetMethod<Con_IsVisibleFn> ( this, 11 )( this );
    }

    int GetLocalPlayer ( void )
    {
        typedef int (__thiscall* GetLocalPlayerFn)( void* );
        return GetMethod<GetLocalPlayerFn> ( this, 12 )( this );
    }

    float Time ( void )
    {
        typedef float (__thiscall* TimeFn)( void* );
        return GetMethod<TimeFn> ( this, 14 )( this );
    }

    void GetViewAngles ( Vector& va )
    {
        typedef void (__thiscall* GetViewAnglesFn)( void*, Vector& );
        GetMethod<GetViewAnglesFn> ( this, 19 )( this, va );
    }

    void SetViewAngles ( const Vector& va )
    {
        typedef void (__thiscall* SetViewAnglesFn)( void*, const Vector& );
        GetMethod<SetViewAnglesFn> ( this, 20 )( this, va );
    }

    int GetMaxClients ( void )
    {
        typedef int (__thiscall* GetMaxClientsFn)( void* );
        return GetMethod<GetMaxClientsFn> ( this, 21 )( this );
    }

    const VMatrix& WorldToScreenMatrix ( void )
    {
        typedef const VMatrix& (__thiscall* WorldToScreenMatrixFn)( void* );
        return GetMethod<WorldToScreenMatrixFn> ( this, 36 )( this );
    }
};

enum TraceType_t
{
    TRACE_EVERYTHING = 0,
    TRACE_WORLD_ONLY,
    TRACE_ENTITIES_ONLY,
    TRACE_EVERYTHING_FILTER_PROPS
};

struct cplane_t
{
    Vector  normal;
    float   dist;
    byte    type;
    byte    signbits;
    byte    pad[2];
};

struct csurface_t
{
    const char*     name;
    short           surfaceProps;
    unsigned short  flags;
};

class CBaseTrace
{
public:
    Vector          startpos;
    Vector          endpos;
    cplane_t        plane;
    float           fraction;
    int             contents;
    unsigned short  dispFlags;
    bool            allsolid;
    bool            startsolid;
};

class CGameTrace : public CBaseTrace
{
public:
    float           fractionleftsolid;
    csurface_t      surface;
    int             hitgroup;
    short           physicsbone;
    C_BaseEntity*   ent;
    int             hitbox;
};

typedef CGameTrace trace_t;

struct Ray_t
{
    VectorAligned   m_Start;
    VectorAligned   m_Delta;
    VectorAligned   m_StartOffset;
    VectorAligned   m_Extents;

    bool            m_IsRay;
    bool            m_IsSwept;

    void Init ( const Vector& start, const Vector& end )
    {
        m_Delta = end - start;

        m_IsSwept = (m_Delta.LengthSqr () != 0);

        m_Extents.Init ();

        m_IsRay = true;

        m_StartOffset.Init ();

        m_Start = start;
    }
};

class ITraceFilter
{
public:
    virtual bool        ShouldHitEntity ( C_BaseEntity* pEntity, int contentsMask ) = 0;
    virtual TraceType_t GetTraceType ( void ) const = 0;
};

class CTraceFilter : public ITraceFilter
{
public:
    CTraceFilter ( C_BaseEntity* pEntity )
        :   m_pEntity ( pEntity )
    {

    }

    bool ShouldHitEntity ( C_BaseEntity* pEntity, int contentsMask )
    {
        return !(pEntity == m_pEntity);
    }

    virtual TraceType_t GetTraceType ( void ) const
    {
        return TRACE_EVERYTHING;
    }

private:
    C_BaseEntity* m_pEntity;
};

class IEngineTrace
{
public:
    int GetPointContents ( const Vector& vecAbsPosition, C_BaseEntity** ppEntity = 0 )
    {
        typedef int (__thiscall* GetPointContentsFn)( void*, const Vector&, C_BaseEntity** );
        return GetMethod<GetPointContentsFn> ( this, 0 )( this, vecAbsPosition, ppEntity );
    }

    void TraceRay ( const Ray_t& ray, unsigned int fMask, ITraceFilter* pTraceFilter, trace_t* pTrace )
    {
        typedef void (__thiscall* TraceRayFn)( void*, const Ray_t&, unsigned int, ITraceFilter*, trace_t* );
        GetMethod<TraceRayFn> ( this, 4 )( this, ray, fMask, pTraceFilter, pTrace );
    }
};

class IVModelInfo
{
public:
    const char* GetModelName ( const model_t* pModel )
    {
        typedef const char* (__thiscall* GetModelNameFn)( void*, const model_t* );
        return GetMethod<GetModelNameFn> ( this, 3 )( this, pModel );
    }

    studiohdr_t* GetStudioModel ( const model_t* pModel )
    {
        typedef studiohdr_t* (__thiscall* GetStudioModelFn)( void*, const model_t* );
        return GetMethod<GetStudioModelFn> ( this, 28 )( this, pModel );
    }
};

class IPanel
{
public:
    const char* GetName ( unsigned int vguiPanel )
    {
        typedef const char* (__thiscall* GetNameFn)( void*, unsigned int );
        return GetMethod<GetNameFn> ( this, 36 )( this, vguiPanel );
    }
};

class ISurface
{
public:
    void DrawSetColor ( int r, int g, int b, int a )
    {
        typedef void (__thiscall* DrawSetColorFn)( void*, int, int, int, int );
        GetMethod< DrawSetColorFn > ( this, 11 )( this, r, g, b, a );
    }

    void DrawFilledRect ( int x0, int y0, int x1, int y1 )
    {
        typedef void (__thiscall* DrawFilledRectFn)( void*, int, int, int, int );
        GetMethod< DrawFilledRectFn > ( this, 12 )( this, x0, y0, x1, y1 );
    }

    void DrawOutlinedRect ( int x0, int y0, int x1, int y1 )
    {
        typedef void (__thiscall* DrawOutlinedFn)( void*, int, int, int, int );
        GetMethod< DrawOutlinedFn > ( this, 14 )( this, x0, y0, x1, y1 );
    }

    void DrawLine ( int x0, int y0, int x1, int y1 )
    {
        typedef void (__thiscall* DrawLineFn)( void*, int, int, int, int );
        GetMethod< DrawLineFn > ( this, 15 )( this, x0, y0, x1, y1 );
    }

    void DrawSetTextFont ( unsigned long font )
    {
        typedef void (__thiscall* DrawSetTextFontFn)( void*, unsigned long );
        GetMethod< DrawSetTextFontFn > ( this, 17 )( this, font );
    }

    void DrawSetTextColor ( int r, int g, int b, int a )
    {
        typedef void (__thiscall* DrawSetTextColorFn)( void*, int, int, int, int );
        GetMethod< DrawSetTextColorFn > ( this, 19 )( this, r, g, b, a );
    }

    void DrawSetTextPos ( int x, int y )
    {
        typedef void (__thiscall* DrawSetTextPosFn)( void*, int, int );
        GetMethod< DrawSetTextPosFn > ( this, 20 )( this, x, y );
    }

    void DrawPrintText ( const wchar_t* text, int textLen )
    {
        typedef void (__thiscall* DrawPrintTextFn)( void*, const wchar_t*, int, int );
        return GetMethod< DrawPrintTextFn > ( this, 22 )( this, text, textLen, 0 );
    }

    unsigned long CreateFont ()
    {
        typedef unsigned int (__thiscall* CreateFontFn)( void* );
        return GetMethod< CreateFontFn > ( this, 66 )( this );
    }

    void SetFontGlyphSet ( unsigned long font, const char* windowsFontName, int tall, int weight, int blur, int scanlines, int flags )
    {
        typedef void (__thiscall* SetFontGlyphSetFn)( void*, unsigned long, const char*, int, int, int, int, int, int, int );
        GetMethod< SetFontGlyphSetFn > ( this, 67 )( this, font, windowsFontName, tall, weight, blur, scanlines, flags, 0, 0 );
    }

    void GetTextSize ( unsigned long font, const wchar_t* text, int& wide, int& tall )
    {
        typedef void (__thiscall* GetTextSizeFn)( void*, unsigned long, const wchar_t*, int&, int& );
        GetMethod< GetTextSizeFn > ( this, 75 )( this, font, text, wide, tall );
    }
};

class CGlobalVarsBase
{
public:
    float   realtime;
    int     framecount;
    float   absoluteframetime;
    float   curtime;
    float   frametime;
    int     maxClients;
    int     tickcount;
    float   interval_per_tick;
    float   interpolation_amount;
    int     simTicksThisFrame;
    int     network_protocol;
    void*   pSaveData;
    bool    m_bClient;
    int     nTimestampNetworkingBase;
    int     nTimestampRandomizeWindow;
};

class CInput
{
public:
    CUserCmd* GetUserCmd ( int sequence_number )
    {
        return &m_pCommands[sequence_number % MULTIPLAYER_BACKUP];
    }

    CVerifiedUserCmd* GetVerifiedUserCmd ( int sequence_number )
    {
        return &m_pVerified[sequence_number % MULTIPLAYER_BACKUP];
    }

    unsigned char       __pad0[0xC4];
    CUserCmd*           m_pCommands;
    CVerifiedUserCmd*   m_pVerified;
};

class CMoveData
{
public:
    bool    m_bFirstRunOfFunctions : 1;
    bool    m_bGameCodeMovedPlayer : 1;

    int     m_nPlayerHandle;

    int     m_nImpulseCommand;
    Vector  m_vecViewAngles;
    Vector  m_vecAbsViewAngles;
    int     m_nButtons;
    int     m_nOldButtons;
    float   m_flForwadrMove;
    float   m_flSideMove;
    float   m_flUpMove;

    float   m_flMaxSpeed;
    float   m_flClientMaxSpeed;

    Vector  m_vecVelocity;
    Vector  m_vecAngles;
    Vector  m_vecOldAngles;

    float   m_outStepHeight;
    Vector  m_outWishVel;
    Vector  m_outJumpVel;

    Vector  m_vecConstraintCenter;
    float   m_flConstraintRadius;
    float   m_flConstraintWidth;
    float   m_flConstraintSpeedFactor;

    void SetAbsOrigin ( const Vector& vec )
    {
        m_vecAbsOrigin = vec;
    }

    const Vector& GetAbsOrigin () const
    {
        return m_vecAbsOrigin;
    }

    Vector  m_vecAbsOrigin;
};

class CGameMovement
{
public:
    void ProcessMovement ( C_BaseEntity* pPlayer, CMoveData* pMove )
    {
        typedef void (__thiscall* ProcessMovementFn)( void*, C_BaseEntity*, CMoveData* );
        GetMethod<ProcessMovementFn> ( this, 1 )( this, pPlayer, pMove );
    }

    void StartTrackPredictionErrors ( C_BaseEntity* pPlayer )
    {
        typedef void (__thiscall* StartTrackPredictionErrorsFn)( void*, C_BaseEntity* );
        GetMethod<StartTrackPredictionErrorsFn> ( this, 2 )( this, pPlayer );
    }

    void FinishTrackPredictionErrors ( C_BaseEntity* pPlayer )
    {
        typedef void (__thiscall* FinishTrackPredictionErrorsFn)( void*, C_BaseEntity* );
        GetMethod<FinishTrackPredictionErrorsFn> ( this, 3 )( this, pPlayer );
    }

    void DecayPunchAngle ( void )
    {
        typedef void (__thiscall* DecayPunchAngleFn)( void* );
        GetMethod<DecayPunchAngleFn> ( this, 13 )( this );
    }
};

class CPrediction
{
public:
    void SetupMove ( C_BaseEntity* player, CUserCmd* ucmd, IMoveHelper* pHelper, CMoveData* move )
    {
        typedef void (__thiscall* SetupMoveFn)( void*, C_BaseEntity*, CUserCmd*, IMoveHelper*, CMoveData* );
        GetMethod<SetupMoveFn> ( this, 18 )( this, player, ucmd, pHelper, move );
    }

    void FinishMove ( C_BaseEntity* player, CUserCmd* ucmd, CMoveData* move )
    {
        typedef void (__thiscall* FinishMoveFn)( void*, C_BaseEntity*, CUserCmd*, CMoveData* );
        GetMethod<FinishMoveFn> ( this, 19 )( this, player, ucmd, move );
    }
};

#endif // SDK_H