RemoteKill/Aimbot/ESP

**~FALLEN~** · 11-11-2011

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

**ToxicFlames** · 11-11-2011

Very useful, thank you.

**Ryuesi** · 11-11-2011

Whyyyyyyyyy , Are You Crazy

**~FALLEN~** · 11-11-2011

Originally Posted by Takrai

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

**joered** · 11-12-2011

why posting this

**giniyat101** · 11-12-2011

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

**CrossRaiders** · 11-12-2011

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

But thanks for sharing!

**Brimir** · 11-12-2011

Very nice!
Thanks

**~FALLEN~** · 11-12-2011

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;
};

**Code[VB]** · 11-12-2011

xD nice nice

i like structs

**Brimir** · 11-12-2011

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
};

**giniyat101** · 11-12-2011

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

**~FALLEN~** · 11-12-2011

They still can't hook it

which is needed for it so w/e not worried haha

**badboy3** · 11-12-2011

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

**giniyat101** · 11-12-2011

Originally Posted by ~FALLEN~

They still can't hook it

which is needed for it so w/e not worried haha

hooking aint hard trust me noobs will start to make threads like [Help]Remote kill/Aimbot/ESP plz request delete this

Thread: RemoteKill/Aimbot/ESP

Thread Tools

Display

RemoteKill/Aimbot/ESP

The Following 27 Users Say Thank You to ~FALLEN~ For This Useful Post:

The Following 5 Users Say Thank You to ~FALLEN~ For This Useful Post:

The Following User Says Thank You to Brimir For This Useful Post:

The Following User Says Thank You to giniyat101 For This Useful Post:

The Following User Says Thank You to ~FALLEN~ For This Useful Post:

Similar Threads

[Release] Cod6 Multi Hack V1.066 by Wieter20 with aimbot esp UD

Build A Aimbot/Esp?

[Release] multi hack, aimbot/esp/norecoil

[Info] Combat arms Aimbot+esp

HL2 Hack With Aimbot|ESP| And much, Much more.