RemoteKill/Aimbot/ESP

Posts 1–15 of 24 · Page 1 of 2

Code:

typedef unsigned int(__cdecl *GetMyIdx)(unsigned long L***);
GetMyIdx MyIndex;
struct _Transform
{
	D3DXVECTOR3 Pos;
	unsigned char spacer00[0x100];
};
void GetNodeTransform(cObject* obj,UINT Bone,_Transform* Trans)
{
	if(!CShellBase)
	 return;
       unsigned long LTModel = *(unsigned long*)(CShellBase+0x341758);
	__asm
	{
		mov ecx,LTModel;
		mov edx,dword ptr ds:[ecx];
		mov edx,dword ptr ds:[edx+0x34];
		push 1;
		push Trans;
		push Bone;
		push obj;
		call edx;
	}
}
D3DXVECTOR3 GetBonePosition(cObject* obj,UINT Bone)
{
	_Transform Trans;
	GetNodeTransform(obj,Bone,&Trans);
	return Trans.Pos;
}
enum
{
	INTERSECTOBJECTS				        = (1<<0),
	IGNORE_NONSOLID					= (1<<1),
	INTERSECT_HPOLY					= (1<<2)
};

struct HPOLY
{
	HPOLY() : m_nWorldIndex(0xFFFFFFFF), m_nPolyIndex(0xFFFFFFFF) {}
	HPOLY(__int32 nWorldIndex, __int32 nPolyIndex) : m_nWorldIndex(nWorldIndex), m_nPolyIndex(nPolyIndex) {}
	HPOLY(const HPOLY& hPoly) : m_nWorldIndex(hPoly.m_nWorldIndex), m_nPolyIndex(hPoly.m_nPolyIndex) {}
	
	HPOLY &operator=(const HPOLY &hOther)
	{
		m_nWorldIndex = hOther.m_nWorldIndex;
		m_nPolyIndex = hOther.m_nPolyIndex;
		return *this;
	}

	bool operator==(const HPOLY &hOther) const
	{
		return (m_nWorldIndex == hOther.m_nWorldIndex) && (m_nPolyIndex == hOther.m_nPolyIndex);
	}
	bool operator!=(const HPOLY &hOther) const
	{
		return (m_nWorldIndex != hOther.m_nWorldIndex) || (m_nPolyIndex != hOther.m_nPolyIndex);
	}
	__int32 m_nPolyIndex, m_nWorldIndex;
};

typedef bool (*ObjectFilterFn)(cObject* hObj, void *pUserData);
typedef bool (*PolyFilterFn)(HPOLY hPoly, void *pUserData, const D3DXVECTOR3& vIntersectPoint);

struct LTPlane
{
    D3DXVECTOR3 m_Normal;
    float m_Dist;
    LTPlane() {}
    LTPlane
    (
        const D3DXVECTOR3& n,  //unit normal
        const D3DXVECTOR3& P   //any point on plane
    )
    {
        m_Normal = n;
    }
    void Init(const D3DXVECTOR3& n, const D3DXVECTOR3& P) {
        m_Normal = n;
    }
    LTPlane(float x, float y, float z, float d) {
        m_Dist = d;
    }
    LTPlane(const D3DXVECTOR3& n, float d) {
        m_Normal = n;
        m_Dist = d;
    }
    void Init(const D3DXVECTOR3& n, float d) {
        m_Normal = n;
        m_Dist = d;
    }
    const D3DXVECTOR3& Normal() const {
        return m_Normal;
    }
    float Dist() const {
        return m_Dist;
    }
    LTPlane operator-() const {
        return LTPlane(-m_Normal, -m_Dist);
    }
};

class IntersectQuery {
public:
	IntersectQuery() {
		m_Flags = 0;
		m_FilterFn = 0;
		m_PolyFilterFn = 0;
		m_FilterActualIntersectFn = 0;
		m_pActualIntersectUserData = NULL;
		m_pUserData = NULL;
	}
		D3DXVECTOR3 m_From;
		D3DXVECTOR3 m_To;
		__int32 m_Flags;
		ObjectFilterFn m_FilterFn;
		ObjectFilterFn m_FilterActualIntersectFn;
		PolyFilterFn m_PolyFilterFn;
		void *m_pUserData;
		void *m_pActualIntersectUserData;
};
struct IntersectInfo
{
		D3DXVECTOR3 vImpactPos;	
	        char spacer00[16];			
		cObject*  hObjImpact;
		unsigned long unk1;
		unsigned long unk2;
		unsigned long unk3;
};
typedef bool( WINAPIV *IntersectSegment )( IntersectQuery& Query, IntersectInfo *pInfo );
IntersectSegment pIntersectSegment;
struct CPlayer;
CPlayer* GetPlayerLoop(int index)
{
	if(!CShellBase)
		return 0;
        unsigned long LTClientShell = *(unsigned long*)( CShellBase+0x344200 );
	return (CPlayer*)(LTClientShell+(index*0x1C0)+0x1005C);
}
struct cObject
{
                char pad0[4];
		D3DXVECTOR3 Origin;
		D3DXVECTOR3 Head;
};
struct UnkStruct
{
		float Pitch;
		float Yaw;
		char spacer02[408];
		bool IsDead;
		char spacer03[5703];
		unsigned char CurrentGun;
		char Spacer04[3];
		bool IsMutant;
};
struct CPlayer
{ 
			char Spacer00[4];
			cObject* Object;
			char ClientID;
			char Team;     
			char Name[12];
			char Spacer01[2];
			UnkStruct *unk;
			int PlayerSlotTeam;
			int unkstruct1; 
			bool Has_C4; 
			int State;
			int Rank;
			int unkstruct2; 
			int unkstruct3;
	                short Health;
			short Kills;
};

bool FilterObjs(_Object* obj, void *pUser)
{
	for(int i = 0; i < 16; i++)
	{
	CPlayer *Target = GetPlayerLoop(i);
		if(obj == Target->Object)
			return true;
	}
	return false;
}
bool ModifiedIntersectSegment(IntersectQuery* Query, IntersectInfo* Info)
{
	if(/*RemoteKill On*/)
	{
		MyIndex = (GetMyIdx)(CShellBase+0x7770);
		for(int i = 0; i < 16; i++)
		{
		CPlayer* Target = GetPlayerLoop(i);
		CPlayer* MyPlayer = GetPlayerLoop(MyIndex(LTClientShell));
		if( MyPlayer && MyPlayer->Object && Target->Object && Target->unk && !Target->unk->IsDead )
		{
				if(Target->Team != MyPlayer->Team)
				{
					D3DXVECTOR3 Pos = GetBonePosition(Target->Object,AimBone);
					Query->m_From = Pos + D3DXVECTOR3( 0.0f, 50.0f, 0.0f );
					Query->m_To = Pos - D3DXVECTOR3( 0.0f, 50.0f, 0.0f );
					Query->m_Flags = ::INTERSECT_OBJECTS|::INTERSECT_HPOLY|::IGNORE_NONSOLID;
					Query->m_FilterFn = FilterObjs;
					bool Result = pIntersectSegment(*Query,Info);
					if(Result)
					{
					Info->hObjImpact = Target->Object;
					Info->vImpactPos = Pos;
					}
					return pIntersectSegment(*Query,Info);
				}
			}
		}
	}
	return pIntersectSegment(*Query,Info);
}

LTPlayerClient = LTClientShell + 0x50
Writable Yaw/Pitch @ LTPlayerClient+0x10C/0x110

should be everything yall need for aimbot esp remote kill w/e really ill be posting more throughout the next couple days, have fun !

Credits:
~FALLEN~ / Cody <- Me
MINT <- My bro

Gellin <- great friend

^ Credit those people if you're going to use thanks

Very useful, thank you.

Whyyyyyyyyy , Are You Crazy

Originally Posted by Ryuesi

Whyyyyyyyyy , Are You Crazy

@Takrai nah i'm just done with the game haha anyways it's not copy past-able you still need to hook intersectsegment...gl

Originally Posted by ~FALLEN~

@Takrai nah i'm just done with the game haha anyways it's not copy past-able you still need to hook intersectsegment...gl

let me have your CF acc

why posting this

Remove it plz

remember when you posted STW source?
now all noobs and leechers can make this VIP feature

and now this ??

~EDIT~
just checked this

Code:

ModifiedIntersectSegment

seems like you didnt post how to hook

Why don't we all just post all VIP features? LOL! (joke)

But thanks for sharing!

Very nice!
Thanks

More classes and junk :

Code:

class cLTBase
{
public:
	cLTClient* LTClient;
	char spacer00[96];
	bool (__cdecl *IntersectSegment)( IntersectQuery &iQuery, IntersectInfo* Info );
	char spacer01[404];
	void (__cdecl *RunConsoleCommand)( char* Command );
};

class cLTClient
{
public:
	char spacer00[148];
	unsigned int(__stdcall *GetObjectRotation)( cObject* pObject, D3DXMATRIX *Rotation );
	unsigned int(__stdcall *GetObjectPos)( cObject* pObject, D3DXVECTOR3 *Pos );
	char spacer01[44];
	unsigned int(__stdcall *SetObjectPos)( cObject* pObject, D3DXVECTOR3 *Pos);
	char spacer02[112];
	unsigned int(__cdecl *GetSConValueFloat)( char *Command, float *Out );
	unsigned int(__cdecl *GetSConValueString)( char *Command, char* Out, unsigned int Len );
	char spacer03[32];
	unsigned int(__stdcall *SendToServer)( int Message, unsigned int Flags );
};
struct cLTPlayerClient
{
	char spacer00[84];
	int Defuse;
	char spacer01[168];
	cLTPlayerClientInfo* LTPlayerClientInfo;
	char spacer02[12];
	float Yaw;
	float Pitch;
	char spacer03[168];
	int WalkthroughAxis[3];
	char spacer04[176];
	int SuperJump;
	char spacer05 [272];
	int Fly;
};

struct cLTPlayerClientInfo
{
	char spacer00[220];
	D3DXVECTOR3 LocalPos;
};

class cLTClientShell
{
public:
	char spacer00[80];
	cLTPlayerClient* LTPlayerClient;
	char spacer01[65544];
	cPlayer Players[16];
public:
	cPlayer *GetPlayerByInedx( int index )
	{
		return &Players[index];
	}
};

struct sBasicPlayerInfo
{
	char Spacer[4];
	float MovementSpeed;
	float MovementWalkRate;
	float MovementDuckWalkRate;
	float MovementSideMoveRate;
	float MovementFrontBackRunAnimationRate;
	float MovementLeftRightRunAnimationRate;
	float MovementFrontBackWalkAnimationRate;
	float MovementLeftRightWalkAnimationRate;
	float MovementAcceleration;
	float MovementFriction;
	float JumpTime;
	float JumpVelocity;
	float JumpLandedWaitTime;
	float JumpLandedNoJumpTimeRate;
	float JumpRepeatPenaltyMoveRate;
	float JumpRepeatPenaltyHeightRate;
	float JumpLandedMovePenaltyTimeRate;
	float JumpLandedMovePenaltyMoveRate;
	char Spacer1[44];
	float DamagePenaltyTime;
	float DamagePenaltyMoveRate;
	float C4PlantTime;
	float C4DefuseTime;
	float MaxCanDefuseDistance;
	float CharacterHiddenAlpha;
	float CharacterHiddenWalkAlpha;
	float CharacterHiddenRunAlpha;
	float MovementHiddenRate;
	unsigned long CrossHairColor;
	float CrossHairRedChangeRate;
	float CrossHairGreenChangeRate;
	float CrossHairBlueChangeRate;
};

struct sObjectList
{
	char spacer00[1256];
	bool EdgeshotEnabled;
	char spacer01[3];
	bool WallshotEnabled;
	char spacer02[3];
	bool PerfectWallshotEnabled;
};

xD nice nice

i like structs

There is also this class:

Code:

class _WeaponClass {
public:
	char Unknown0[3052];

	float SmokeAlpha; //BEC
	char Unknown1[3392];

	DWORD ShotReactYaw1; //1930
	float ShotReactYaw2; //1934
	float ShotReactYaw3; //1938
	char Unknown2[456];

	DWORD ShotReactPitch1; //1B04
	float ShotReactPitch2; //1B08
	float ShotReactPitch3; //1B0C
	char Unknown3[1152];

	float DetailPerturbShot; //1F90
	char Unknown31[716];

	float SubWeaponIndex; //2260
	float DamageCameraPenalty; //2414
	char Unknown32[48];

	char test[0x2448];
	float ZoomAction; //2448;
	float ZoomStatusLockFire; //244C
	float MoveSpeedPenalty; //2450		
	float ZoomInMoveSpeedPenalty; //2454
	float MovePenaltyForDelayFire; //2458
	DWORD ZoomTargetType; //245C
	float FireAnimMultiplier; //2460
	float PrefireAnimMultiplier; //2464
	float ZoomInFireAnimMultiplier1; //2468
	float ZoomInFireAnimMultiplier2; //246C
	char Unknown4[160];

	DWORD DelayOneShootTime1; //2510
	DWORD DelayOneShootTime2; //2514
	DWORD DelayOneShootTime3; //2518
	float LowerAnimRate1; //251C
	char Unknown5[24];
 
	DWORD ShootThroughCharacter; //2538
	DWORD ShootThroughWall; //253C
	DWORD ShootThroughCharacterInNanoMode;// 2540
	DWORD FlipEffect; //2544
	DWORD AllowedWeaponSoldierRank; //2548
	char Unknown6[12];
	
	float PVPosAndRotAndFovDefault1; //2558
	float PVPosAndRotAndFovDefault2; //255C
	char Unknown7[4];

	float PVPosAndRotAndFovDefault3; //2564
	char Unknown8[32];

	DWORD LowerAnimRate2; //2588 //Also CameraYawAndPitch1
	float LowerAnimRate3; //258C //Also CameraYawAndPitch2
	float LowerAnimRate4; //2590 //Also CameraYawAndPitch3
	char Unknown9[148];

	DWORD MaxOneShotAndSizeD; //2628
	float MaxOneShotAndSizeF; //262C;
	float ThrowVelAngleGravityAirResTime1; //2630
	float ThrowVelAngleGravityAirResTime2; //2634
	float ThrowVelAngleGravityAirResTime3; //2638
	float ThrowVelAngleGravityAirResTime4; //263C
	float ThrowVelAngleGravityAirResTime5; //2640
	BYTE BoomType; //2644
	BYTE BoomDurationDamage[3]; //2645
	float BoomDamageCheckInterval; //2648
	float SideEffectDamage; //264C
	float SideEffectTimeGap; //2650
	float DamagePenaltyTimeAndMoveRate1; //2654
	float DamagePenaltyTimeAndMoveRate2; //2658
	float NanoGhostDamagePenaltyTimeAndMoveRate1; //265C
	float NanoGhostDamagePenaltyTimeAndMoveRate2; //2660
	float WallShotDamageRatio1; //2664
	char Unknown11[48];

	float ReloadAnimRatio; //2698
	float ChangeWeaponAnimRatio;//269C
	
};

And

Code:

class _PlayerClass { //10A65ECC
public:
	float DistFallDamageStartFrom; //0
	float DamagePerMeter; //4
	DWORD PercentageBuyShotgun; //8
	DWORD PercentageBuySubMachineGun; //c
	DWORD PercentageBuyRifle; //10
	DWORD PercentageBuySniperRifle; //14
	DWORD PercentageBuyMachineGun; //18
	float AIReachPosAcceptableDist; //1c
	float AIReachPosAcceptableYDist; //20                                                                 
	DWORD AICheckStuckInterval; //24
	float AICheckStuckDist; //28
	float CheckEnemyIntervalLower; //2c
	DWORD CheckEnemyIntervalUpper; //30
	DWORD DecideActionIntervalLower; //34
	DWORD DecideActionIntervalUpper; //38
	float PerturbLimitLowerLower; //3c
	float PerturbLimitLowerUpper; //40
	float PerturbLimitUpperLower; //44
	float PerturbLimitUpperUpper; //48
	float PerturbLimitLowerMultiplierNormal; //4c
	float PerturbLimitUpperMultiplierNormal; //50
	float CheckEnemyIntervalMultiplierNormal; //54
	float DecideActionIntervalMultiplierNormal; //58
	float PerturbLimitLowerMultiplierHigh; //5c
	float PerturbLimitUpperMultiplierHigh; //60
	float CheckEnemyIntervalMultiplierHigh; //64
	float DecideActionIntervalMultiplierHigh; //68
	DWORD ReactionTimeLimitOnDamaged; //6c
	float LookAtAddAmountWhenDamagedX; //70
	float LookAtAddAmountWhenDamagedY; //74
	float LookAtAddAmountWhenDamagedZ; //78
	DWORD ReloadTime; //7c
	DWORD TimeChangeRandomShootPointWhenBlinded; //80
	DWORD AddAmountRandomShootPointWhenBlinedX; //84
	DWORD AddAmountRandomShootPointWhenBlinedY; //88
	DWORD AddAmountRandomShootPointWhenBlinedZ; //8c
	DWORD TimeChangeRandomGotoPointWhenBlinded; //90
	DWORD AddAmountRandomGotoPointWhenBlinedX; //94
	DWORD AddAmountRandomGotoPointWhenBlinedY; //98
	DWORD AddAmountRandomGotoPointWhenBlinedZ; //9c
	DWORD PercentageLookOutWhenAttackTargetDisappeared; //a0
	DWORD PercentageGotoPosWhenAttackTargetDisappeared; //a4
	DWORD PercentageBuyWeaponWhenAlreadyHasOne; //a8
	DWORD TimeToResetGunDirRotWhenMoving; //ac
	DWORD TimeToResetGunDirRotWhenAttacking; //b0
	float MoveXZSpeedLimitNormal; //b4
	float MoveXZSpeedLimitLadder; //b8
	DWORD RepeatedJumpTimeLimit; //bc
	float CheckEnemyInTheBackDotLimit; //c0
	float CheckEnemyInTheBackDotLimitNormal; //c4
	float CheckEnemyInTheBackDotLimitHigh; //c8
	DWORD KillNumMultiplierWhenCheckingEnemyThreatened; //cc
	float VeryCloseDistWhenAttacking; //d0
	float VeryFarDistWhenAttacking; //d4
	float PercentageJumpWhenAttack; //d8
	DWORD PercentageJumpWhenMoving; //dc
	DWORD AttackShootingSniperVariationTimeLower; //e0
	DWORD AttackShootingSniperVariationTimeUpper; //e4
	DWORD AttackShootingOtherVariationTimeLower; //e8
	DWORD AttackShootingOtherVariationTimeUpper; //ec
	DWORD AttackAimingSniperVariationTimeLower; //f0
	DWORD AttackAimingSniperVariationTimeUpper; //f4
	DWORD AttackAimingOtherVariationTimeLower; //f8
	DWORD AttackAimingOtherVariationTimeUpper; //fc
	DWORD AttackAimingOtherVariationTimeLowerVeryClose; //100
	DWORD AttackAimingOtherVariationTimeUpperVeryClose; //104
	DWORD PercentageRunningWhenMoving; //108
	DWORD PercentageRunningBackwardWhenMoving; //10c
	DWORD PercentageWalkingWhenMoving; //110
	DWORD MaxMovingDurationLower; //114
	DWORD MaxMovingDurationUpper; //118
	DWORD MovingVariationTimeWhenRunningLower; //11c
	DWORD MovingVariationTimeWhenRunningUpper; //120
	DWORD MovingVariationTimeWhenRunningBackwardLower; //124
	DWORD MovingVariationTimeWhenRunningBackwardUpper; //128
	DWORD MovingVariationTimeWhenWalkingLower; //12c
	DWORD MovingVariationTimeWhenWalkingUpper; //130
	DWORD PercentageStandingWhenLookout; //134
	DWORD PercentageDuckingWhenLookout; //138
	DWORD MaxLookoutDurationAfterAttackDuckingLower; //13c
	DWORD MaxLookoutDurationAfterAttackDuckingUpper; //140
	DWORD MaxLookoutDurationAfterAttackStandingLower; //144
	DWORD MaxLookoutDurationAfterAttackStandingUpper; //148
	DWORD MaxLookoutDurationDuckingLower; //14c
	DWORD MaxLookoutDurationDuckingUpper; //150
	DWORD MaxLookoutDurationStandingLower; //154
	DWORD MaxLookoutDurationStandingUpper; //158
	DWORD LookoutVariationTimeLower; //15c
	DWORD LookoutVariationTimeUpper; //160
	DWORD AttackMoveTypeRunningPercentageWithKnife; //164
	DWORD AttackMoveTypeRunningLSidePercentageWithKnife; //168
	DWORD AttackMoveTypeRunningRSidePercentageWithKnife; //16c
	DWORD AttackMoveTypeRunningBackwardPercentageWithKnife; //170
	DWORD AttackMoveTypeNonePercentageWhenVeryFar; //174
	DWORD AttackMoveTypeRunningPercentageWhenVeryFar; //178
	DWORD AttackMoveTypeRunningBackwardPercentageWhenVeryFar; //17c
	DWORD AttackMoveTypeWalkingPercentageWhenVeryFar; //180
	DWORD AttackMoveTypeDuckingPercentageWhenVeryFar; //184
	DWORD AttackMoveTypeDuckWalkingPercentageWhenVeryFar; //188
	DWORD AttackMoveTypeRunningLSidePercentageWhenVeryFar; //18c
	DWORD AttackMoveTypeRunningRSidePercentageWhenVeryFar; //190
	DWORD AttackMoveTypeWalkingLSidePercentageWhenVeryFar; //194
	DWORD AttackMoveTypeWalkingRSidePercentageWhenVeryFar; //198
	DWORD AttackMoveTypeDuckWalkingLSidePercentageWhenVeryFar; //19c
	DWORD AttackMoveTypeDuckWalkingRSidePercentageWhenVeryFar; //1a0
	DWORD AttackMoveTypeNonePercentage; //1a4
	DWORD AttackMoveTypeRunningPercentage; //1a8
	DWORD AttackMoveTypeRunningBackwardPercentage; //1ac
	DWORD AttackMoveTypeWalkingPercentage; //1b0
	DWORD AttackMoveTypeDuckingPercentage; //1b4
	DWORD AttackMoveTypeDuckWalkingPercentage; //1b8
	DWORD AttackMoveTypeRunningLSidePercentage; //1bc
	DWORD AttackMoveTypeRunningRSidePercentage; //1c0
	DWORD AttackMoveTypeWalkingLSidePercentage; //1c4
	DWORD AttackMoveTypeWalkingRSidePercentage; //1c8
	DWORD AttackMoveTypeDuckWalkingLSidePercentage; //1cc
	DWORD AttackMoveTypeDuckWalkingRSidePercentage; //1d0
	float MinPerturbMultiplierWithSniperWhenNotMoving; //1d4
	float MaxPerturbMultiplierWithSniperWhenNotMoving; //1d8
	float MinPerturbMultiplierWithSniperWhenMovingSlowly; //1dc
	float MaxPerturbMultiplierWithSniperWhenMovingSlowly; //1e0
	float MinPerturbMultiplierWithSniper; //1e4
	float MaxPerturbMultiplierWithSniper; //1e8
	float MinPerturbMultiplierWhenNotMoving; //1ec
	float MaxPerturbMultiplierWhenNotMoving; //1f0
	float MinPerturbMultiplierWhenMovingSlowly; //1f4
	float MaxPerturbMultiplierWhenMovingSlowly; //1f8
};

Originally Posted by ~FALLEN~

More classes and junk :

Code:

class cLTBase
{
public:
	cLTClient* LTClient;
	char spacer00[96];
	bool (__cdecl *IntersectSegment)( IntersectQuery &iQuery, IntersectInfo* Info );
	char spacer01[404];
	void (__cdecl *RunConsoleCommand)( char* Command );
};

class cLTClient
{
public:
	char spacer00[148];
	unsigned int(__stdcall *GetObjectRotation)( cObject* pObject, D3DXMATRIX *Rotation );
	unsigned int(__stdcall *GetObjectPos)( cObject* pObject, D3DXVECTOR3 *Pos );
	char spacer01[44];
	unsigned int(__stdcall *SetObjectPos)( cObject* pObject, D3DXVECTOR3 *Pos);
	char spacer02[112];
	unsigned int(__cdecl *GetSConValueFloat)( char *Command, float *Out );
	unsigned int(__cdecl *GetSConValueString)( char *Command, char* Out, unsigned int Len );
	char spacer03[32];
	unsigned int(__stdcall *SendToServer)( int Message, unsigned int Flags );
};
struct cLTPlayerClient
{
	char spacer00[84];
	int Defuse;
	char spacer01[168];
	cLTPlayerClientInfo* LTPlayerClientInfo;
	char spacer02[12];
	float Yaw;
	float Pitch;
	char spacer03[168];
	int WalkthroughAxis[3];
	char spacer04[176];
	int SuperJump;
	char spacer05 [272];
	int Fly;
};

struct cLTPlayerClientInfo
{
	char spacer00[220];
	D3DXVECTOR3 LocalPos;
};

class cLTClientShell
{
public:
	char spacer00[80];
	cLTPlayerClient* LTPlayerClient;
	char spacer01[65544];
	cPlayer Players[16];
public:
	cPlayer *GetPlayerByInedx( int index )
	{
		return &Players[index];
	}
};

struct sBasicPlayerInfo
{
	char Spacer[4];
	float MovementSpeed;
	float MovementWalkRate;
	float MovementDuckWalkRate;
	float MovementSideMoveRate;
	float MovementFrontBackRunAnimationRate;
	float MovementLeftRightRunAnimationRate;
	float MovementFrontBackWalkAnimationRate;
	float MovementLeftRightWalkAnimationRate;
	float MovementAcceleration;
	float MovementFriction;
	float JumpTime;
	float JumpVelocity;
	float JumpLandedWaitTime;
	float JumpLandedNoJumpTimeRate;
	float JumpRepeatPenaltyMoveRate;
	float JumpRepeatPenaltyHeightRate;
	float JumpLandedMovePenaltyTimeRate;
	float JumpLandedMovePenaltyMoveRate;
	char Spacer1[44];
	float DamagePenaltyTime;
	float DamagePenaltyMoveRate;
	float C4PlantTime;
	float C4DefuseTime;
	float MaxCanDefuseDistance;
	float CharacterHiddenAlpha;
	float CharacterHiddenWalkAlpha;
	float CharacterHiddenRunAlpha;
	float MovementHiddenRate;
	unsigned long CrossHairColor;
	float CrossHairRedChangeRate;
	float CrossHairGreenChangeRate;
	float CrossHairBlueChangeRate;
};

struct sObjectList
{
	char spacer00[1256];
	bool EdgeshotEnabled;
	char spacer01[3];
	bool WallshotEnabled;
	char spacer02[3];
	bool PerfectWallshotEnabled;
};

bool (__cdecl *IntersectSegment)( IntersectQuery &iQuery, IntersectInfo* Info );

Now iam really mad