[I2-Dev] AutoUpdate/Dip/Memory/NewFeatures Base || Full Crossfire Data Logger

void MakeCall(BYTE* paddress, DWORD yourfunction, DWORD dwlen)
{
    DWORD dwOldProtect, dwBkup, dwRelAddr;
    VirtualProtect(paddress, dwlen, PAGE_EXECUTE_READWRITE, &dwOldProtect);
    dwRelAddr = (DWORD) (yourfunction - (DWORD) paddress) - 5;
    *paddress = 0xE8;
        *((DWORD*) (paddress + 0x1)) = dwRelAddr;
    for(DWORD x = 0x5; x < dwlen; x++) *(paddress + x) = 0x90;
    VirtualProtect(paddress, dwlen, dwOldProtect, &dwBkup);
    return;
}
class CFMap
{
public:
	WORD MapIndex;
	char MapName[0x20];
	char MapFileName[0x51];
	char spacer000[0x2A9];
	DWORD MapRuleType;
	char spacer00[0xA];
	bool RandomRespawnTeamDeathMatch;
	char spacer01;
	char spacer02[0x2DC];
	float HellPosY;
	char spacer03[0xC8];
	BYTE SpotWeaponType;
	BYTE Environment;//CMP BYTE PTR DS:[EDX+EBP+6D5],0
	char spacer04[0x102];
	float EmissionInterval;
	float ParticlesPerEmission;
	float GravityAccel;
	DWORD EmissionMaxSize;
	float LimitY;
	float SightDist;
	float StartOffsetY;
	char spaxer05;
	BYTE UseWeapons[4];
	char spacer06[8];
	BYTE UsableBag;//MOV BYTE PTR DS:[EDX+EBP+801],1 
	char spacer07[0xE];
	float MapRuleSubType;
};
class cMap
{
public:
	__int16 MapIndex; //0x0000 
	char MapName[32]; //0x0002 
	char MapFileName[81]; //0x0022 
	char MapLoobyIcon[81]; //0x0073 
	char MapRoomIcon[81]; //0x00C4 
	char LoadingTexFileNameGR[81]; //0x0115 
	char LoadingTexFileNameBL[1]; //0x0166 
char _0x0167[193];
	char MinimapFileNameBL[28]; //0x0228 
char _0x0244[53];
	char MusicName[28]; //0x0279 
char _0x0295[53];
	char N0A1A8D8B[60]; //0x02CA 
char _0x0306[21];
	BYTE TeamToGiveExplosive; //0x031B 
	DWORD MapRuleType; //0x031C 
char _0x0320[4];
	float MapTurns; //0x0324 
	BYTE RevitalizeMap; //0x0328 
	BYTE NewMap; //0x0329 
	bool RandomRespawnTeamDeathMatch; //0x032A 
	float DefaultCameraPositionAndRotation[6]; //0x032C 
char _0x0344[16];
	float C4CameraPosAndRotB[2]; //0x0354 
char _0x0360[32];
	char MiniMapWidth[2]; //0x0380 
char _0x0382[2];
	char MiniMapHeight[2]; //0x0384 
char _0x0386[2];
	float C4CameraPosAndRotA; //0x0388 
	float C4CameraPosAndRotA_2; //0x038C 
	float C4CameraPosAndRotA_3; //0x0390 
char _0x0394[268];
	float OrthoCameraPosAndRot[5]; //0x04A0 
	__int16 OrthoWidth; //0x04B8 
	__int16 OrthoHeight; //0x04BA 
	char AdditionalConsoleString[28]; //0x04BC 
char _0x04D8[304];
	float HellPosY; //0x0608 
	char WaterEnvSound[200]; //0x060C 
	BYTE SpotWeaponType; //0x06D4 
	BYTE Environment; //0x06D5 
	char FxName[258]; //0x06D6 
	float EmissionInterval; //0x07D8 
	float PraticlesPerEmission; //0x07DC 
	float GravityAccel; //0x07E0 
	DWORD EmmissionMaxSize; //0x07E4 
	float LimitY; //0x07E8 
	float SightDist; //0x07EC 
	float StartOffsetY; //0x07F0 
	BYTE NewObserverCameraMode; //0x07F4 
	BYTE UseWeapons[5]; //0x07F5 
char _0x07FB[7];
	BYTE UsableBag; //0x0802 
char _0x0803[13];
	float MapRuleSubType; //0x0810 
char _0x0814[95];

};//Size=0x0873
class Character
{
public:
	WORD CharacterIndex; //0x0000 0x0
	char CharName[30]; //0x0002 
	char ModelFileName[81]; //0x0002 
	char ChildModelFileName[81]; //0x0002 
	char SkinFileName[81]; //0x0002 
	char SkinFileName2[81]; //0x0002 
	char SkinFileName3[81]; //0x0002 
	char SkinFileName4[81]; //0x0002 
	char SkinFileName5[81]; //0x0002 
	char SkinFileName6[81]; //0x0002 
	char SkinFileName7[81]; //0x0002 
	char SkinFileName8[81]; //0x0002 
	char SkinFileName9[81]; //0x0002 
	char SkinFileName10[81]; //0x0002 
	signed short HeadType; //0x03EC 
	signed short UniformItemType ; //0x03EE 
	signed short SpecialItemType ; //0x03F0 
	signed short TargetTeamIndex ; //0x03F2 

};//Size=0x03F4
class cCharacter
{
public:
	signed short CharacterType;
	signed short RealCharacterType;
	char GRModelName[81]; 
	char BLModelName[81]; 
	char GRModelName2[81];
	char BLModelName2[81];
	char GRTextureFile[81];
	char BLTextureFile[81];
	char ChildModelFile[81];
	char RenderStyle[648];
	
	char GRPvArmTxtFile[81];
	char BLPvArmTxtFile[81]; 
	char GRPvHandTxtFile[81];
	char BLPvHandTxtFile[81]; 
	char ItemName[20];
	char ItemID[11]; 
	char ItemCode[6];
	char ButeType[4]; 
	char ButePath[256]; 

	char XLSMsgIndex[4]; 
	BYTE IsWoman;  
	char HUDEffectPath[256];
	
	char HUDLinePath[256];  
	char ResourceName[23];
	char CPBIBUTE[4];  
	char WearStateDress[8]; 

};//Size=0x958
class NanoCharacter
{
public:
	__int32 NanoType; //0x0000 
	__int32 NanoAbility; //0x0004 
	__int32 NanoSkill; //0x0008 
	__int32 NanoAddHp; //0x000C 
	__int32 NanoDefaultWepIndex; //0x0010 
	__int32 NanoDefaultWepInvisible; //0x0014 
	__int32 NanoSpecialWepIndex; //0x0018 
	__int32 NanoSpecialWepInvisible; //0x001C 
	__int32 NanoSkillWepIndex; //0x0020 
	__int32 NextLevelNanoType; //0x0024 
	char ModelFileName[81]; //0x0028 
	char ChildModelFile[81]; //0x0079 
	char RenderStyleFile[81]; //0x00CA 
	char RenderStyleFile_1[81]; //0x011B 
	char RenderStyleFile_2[81]; //0x016C 
	char RenderStyleFile_3[81]; //0x01BD 
	char RenderStyleFile_4[81]; //0x020E 
	char SkinFileName[81]; //0x025F 
	char SkinFileName1[81]; //0x02B0 
	char SkinFileName2[81]; //0x0301 
	char SocketModelFile1[81]; //0x0352 
	char SocketModelFile2[81]; //0x03A3 
	char SocketSkinFile1[81]; //0x03F4 
	char SocketSkinFile2[81]; //0x0445 
	char PvHandSkinFile[81]; //0x0496 
	char PvArmSkinFile[81]; //0x04E7 
	char AtkEffectName[84]; //0x0538 
	float ModelScale; //0x058C 
	float NormalDmg; //0x0590 
	float BigShotDmg; //0x0594 

};//Size=0x0598
class cWeapon
{
public:
char _0x0000[2];
	__int16 Class; //0x0002 
char _0x0004[5];
	char Name[64]; //0x0009 
	char ModelFileName[162]; //0x0049 
	char SkinFileName[81]; //0x00EB 
	char SkinFileName2[81]; //0x013C 
	char SkinFileName3[81]; //0x018D 
	char SkinFileName4[81]; //0x01DE 
	char SkinFileName5[81]; //0x022F 
	char RenderStyleFileName[81]; //0x0280 
	char RenderStyleFileName2[81]; //0x02D1 
	char RenderStyleFileName3[81]; //0x0322 
	char RenderStyleFileName4[81]; //0x0373 
	char RenderStyleFileName5[81]; //0x03C4 
	char GViewAnimName[83]; //0x0415 
	float GVModelScale; //0x0468 
	char ReloadSoundName[32]; //0x046C 
	char SubExplosionSoundName[81]; //0x048C 
	char SubBounceSoundName[81]; //0x04DD 
char _0x052E[734];
	float Range; //0x080C 
	float AIModeRange; //0x0810 
	__int16 MaxAmmo; //0x0814 
	__int16 AmmoPerMagazine; //0x0816 
	__int16 NanoMaxAmmo; //0x0818 
	__int16 NanoAmmoPerMagazine; //0x081A 
	float AmmoDmg; //0x081C 
	float AIModeDmg; //0x0820 
	float UnlimitedAmmo; //0x0824 
	BYTE TargetSlot; //0x0828 
char _0x0829[4];
	__int8 SubType; //0x082D 
	__int16 UseAISheelMode; //0x082E 
	float DmgFactorByDistance; //0x0830 
	float AIDmgFactorByDistance; //0x0834 
	float DmgVariantionFactor; //0x0838 
char _0x083C[48];
	__int16 ShotsPerAmmo; //0x086C 
	__int16 WeaponPrice; //0x086E 
	__int32 AmmoPrice; //0x0870 
	float ReloadSingleAmmo; //0x0874 
	float BoomDuration; //0x0878 
char _0x087C[364];
	char KnifeHitSoundName[4]; //0x09E8 
char _0x09EC[28];
	char N0775F137[81]; //0x0A08 
char _0x0A59[11];
	float KnifeNormalAngle; //0x0A64 
char _0x0A68[8];
	float KnifeNormalAniRate; //0x0A70 
	float KnifeNormalAniRate2; //0x0A74 
	float KnifeNormalAniRate3; //0x0A78 
	float KnifeBigShotRange; //0x0A7C 
char _0x0A80[8];
	float KnifeBigShotAngle; //0x0A88 
char _0x0A8C[8];
	float KnifeBigShotAniRate; //0x0A94 
	float KnifeBigShotAniRate2;
	float KnifeNormalRange2; //0x0A9C 
char _0x0AA0[12];
	float KnifeNormalAngle2; //0x0AAC 
char _0x0AB0[8];
	float KnifeNormalRange2_; //0x0AB8 
char _0x0ABC[4];
	float KnifeBigShotRange2; //0x0AC0 
char _0x0AC4[12];
	float KnifeBigShotAngle2; //0x0AD0 
char _0x0AD4[8];
	float KnifeBigShotAniRate3; //0x0ADC 
char _0x0AE0[12];
	__int32 LeftClickAttribute; //0x0AEC 
	__int32 RightClickAttribute; //0x0AF0 
	__int32 ZoomAttribute; //0x0AF4 
	__int32 ReloadAttributes; //0x0AF8 
	__int32 KnifeLeftClickAttribute; //0x0AFC 
	__int32 KnifeRightClickAttribute; //0x0B00 
	float IsDroopedWhenDie; //0x0B04 
	float DependentRoundType; //0x0B08 
	float StunTime; //0x0B0C 
	__int16 SubWeaponIndex; //0x0B10 
char _0x0B12[2];
	float MoveSpeedPenalty; //0x0B14 
char _0x0B18[288];
	float SmokeAlpha; //0x0C38 
	float ReloadAnimRatio; //0x0C3C 
	float ChangeWeaponAnimRatio; //0x0C40 
char _0x0C44[1808];
	char PViewSkinFileName[81]; //0x1354 
	char PViewSkinFileName2[81]; //0x13A5 
	char PViewSkinFileName3[81]; //0x13F6 
	char PViewSkinFileName4[81]; //0x1447 
	char PViewSkinFileName5[81]; //0x1498 
char _0x14E9[15];
	char LeftHandModeFileName[81]; //0x14F8 
	char WLeftHandModeFileName[81]; //0x1549 
	char PViewModelFileName[81]; //0x159A 
	char PViewRenderStyleFileName[81]; //0x15EB 
	char PViewRenderStyleFileName2[81]; //0x163C 
	char PViewRenderStyleFileName3[81]; //0x168D 
	char PViewRenderStyleFileName4[81]; //0x16DE 
	char PViewRenderStyleFileName5[81]; //0x172F 
	char TempPVModel1[81]; //0x1780 
	char TempPVModel2[81]; //0x17D1 
	char TempPVModel3[81]; //0x1822 
	char TempPVModel4[81]; //0x1873 
	char TempPVModel5[81]; //0x18C4 
char _0x1915[2187];
	char TempPVSkin1[81]; //0x21A0 
	char TempPVSkin2[81]; //0x21F1 
	char TempPVSkin3[81]; //0x2242 
	char TempPVSkin4[81]; //0x2293 
	char TempPVSkin5[81]; //0x22E4 
	char TempPVSkin6[81]; //0x2335 
	char TempPVSkin7[81]; //0x2386 
char _0x23D7[2025];
	char ShotSoundName[64]; //0x2BC0 
	char MagazineClipInSoundName[44]; //0x2C00 
	char BlowBackSoundName[20]; //0x2C2C 
	char DelBlowSoundName[32]; //0x2C40 
	char Extra01SoundName[32]; //0x2C60 
	char Extra02SoundName[32]; //0x2C80 
	char Extra03SoundName[32]; //0x2CA0 
	char Extra04SoundName[32]; //0x2CC0 
	char Extra05SoundName[32]; //0x2CE0 
	char ShotSoundStartName[32]; //0x2D00 
	char BigIconName[81]; //0x2D20 
	char SmallIconName[32]; //0x2D71 
	char EffectSubName[32]; //0x2D91 
char _0x2DB1[1574];
	char SpecularMapName1[81]; //0x33D7 
	char SpecularMapName2[81]; //0x3428 
	char SpecularMapName3[81]; //0x3479 
char _0x34CA[2];
	float SpecularPower; //0x34CC 
	char ReflectionName[81]; //0x34D0 
char _0x3521[3];
	float ReflectionValue; //0x3524 
	float FakeSpecularFalloff; //0x3528 
	float LightCorrectionLegacyShader; //0x352C 
	float ForceNoLegacyShaderAlpha; //0x3530 
char _0x3534[1536];
	float GrenadeBelowTime; //0x3B34 
	BYTE BoomType; //0x3B38 
	float BoomDurationDmg; //0x3B39 
char _0x3B3D[19];
	float NanoGhostDmgPenalty; //0x3B50 
	float NanoGhostDmgTime; //0x3B54 
	float WallShotDmgRatio[14]; //0x3B58 
char _0x3B90[16];
	float ContinuousShotKeyInterval; //0x3BA0 
	char KnifeMetalSound[32]; //0x3BA4 
	char KnifeStoneSound[32]; //0x3BC4 
	char KnifeWoodSound[32]; //0x3BE4 
	char KnifeBrokenGlassSiund[32]; //0x3C04 
	char KnifeCarpetSound[32]; //0x3C24 
	char KnifeSnowSound[32]; //0x3C44 
char _0x3C64[64];
	BYTE HaveKnife; //0x3CA4 
	char KnifeAnim[101]; //0x3CA5 
	char KnfeAtkSoundName[34]; //0x3D0A 
	float GunKnifeRange; //0x3D2C 
	float GunKnifeAmmoDmg; //0x3D30 
	float KnockBack[2]; //0x3D34 
char _0x3D40[32];
	char PVEffectName[30]; //0x3D60 
	char PVEffectName2[30]; //0x3D7E 
char _0x3D9C[500];
	BYTE IsGunKnifeJitter; //0x3F90 
char _0x3F91[87];
	float CrosshairRadius; //0x3FE8 
	__int16 LeverAction; //0x3FEC 
char _0x3FEE[22];

};//Size=0x4004
class CfexeNano
{
public:
	float N0C34A061; //0x0000 
	__int32 ModeIndex; //0x0004 
	__int32 ModeIndex2; //0x0008 
	__int32 HeroWeaponIndex; //0x000C 
	__int32 HeroCharacterType; //0x0010 
	float DamagePerPoint; //0x0014 
	float KillPointOfInfectHero; //0x0018 
	float NanoPointOfInfectHuman; //0x001C 
	float NanoPointOfInfectHumanByHook; //0x0020 
	float NanoPointOfAbsorbName; //0x0024 
	float TimeOfStartNanoRecovery; //0x0028 
	float TimeIntervalOfNanoRecovery; //0x002C 
	float HpOfNanoRecovery; //0x0030 
	float NanoRespawnTime; //0x0034 
	float PlayerPowerUpMaxStep; //0x0038 
	float PlayerPowerUpPoint; //0x003C 
	float N0C345CAD; //0x0040 
	float NumOfNanoRespawn; //0x0044 
	float NanoRespawnHpRate; //0x0048 
	float TypeChangeWhenRespawn; //0x004C 
	float RespawnRateAcc; //0x0050 

};//Size=0x0054
class cMisc
{
public:
	float DistFallDamageStartFrom; //0x0000
	float DamagePerMeter; //0x0004
	DWORD PercentageBuyShotgun; //0x0008
	DWORD PercentageBuySubMachineGun; //0x000C
	DWORD PercentageBuyRifle; //0x0010
	DWORD PercentageBuySniperRifle; //0x0014
	DWORD PercentageBuyMachineGun; //0x0018
	float AIReachPosAcceptableDist; //0x001C
	float AIReachPosAcceptableYDist; //0x0020
	float AICheckStruckInterval; //0x0024
	float AICheckStruckDist; //0x0028
	DWORD CheckEnemyIntervalLower; //0x002C
	DWORD CheckEnemyIntervalUpper; //0x0030
	DWORD DecideActionIntervalLower; //0x0034
	DWORD DecideActionIntervalUpper; //0x0038
	float PerturbLimitLowerLower; //0x003C
	float PerturbLimitLowerUpper; //0x0040
	float PerturbLimitUpperLower; //0x0044
	float PerturbLimitUpperUpper; //0x0048
	float PerturbLimitLowerMultiplierNormal; //0x004C
	float PerturbLimitUpperMultiplierNormal; //0x0050
	float CheckEnemyIntervalMultiplierNormal; //0x0054
	float DecideActionIntervalMultiplierNormal; //0x0058
	float PerturbLimitLowerMultiplierHigher; //0x005C
	float PerturbLimitUpperMultilpierHigher; //0x0060
	float CheckEnemyIntervalMultiplierHigh; //0x0064
	float DecideActionIntervalMultiplierHigh; //0x0068
	DWORD ReactionTimeLimitOnDamaged; //0x006C
	float LookAtAddAmountWhenDamagedX; //0x0070
	float LookAtAddAmountWhenDamagedY; //0x0074
	float LookAtAddAmountWhenDamagedZ; //0x0078
	DWORD ReloadTime; //0x007C
	DWORD TimeChangeRandomShootPointWhenBlinded; //0x0080
	DWORD AddAmountRandomShootPointWhenBlinedX; //0x0084
	DWORD AddAmountRandomShootPointWhenBlinedY; //0x0088
	DWORD AddAmountRandomShootPointWhenBlinedZ; //0x008C
	DWORD TimeChangeRandomGotoPointWhenBlinded; //0x0090
	DWORD AddAmountRandomGotoPointWhenBlinedX; //0x0094
	DWORD AddAmountRandomGotoPointWhenBlinedY; //0x0098
	DWORD AddAmountRandomGotoPointWhenBlinedZ; //0x009C
	DWORD PercentageLookOutWhenAttackTargetDisappeared; //0x00A0
	DWORD PercentageGotoPosWhenAttackTargetDisappeared; //0x00A4
	DWORD PercentageBuyWeaponWhenAlreadyHasOne; //0x00A8
	DWORD TimeToResetGunDirRotWhenMoving; //0x00AC
	DWORD TimeToResetGunDirRotWhenAttacking; //0x00B0
	DWORD MoveXZSpeedLimitNormal; //0x00B4
	DWORD MoveXZSpeedLimitLadder; //0x00B8
	DWORD RepeatJumpTimeLimit; //0x00BC
	float CheckEnemyInTheBackDotLimit; //0x00C0
	float CheckEnemyInTheBackDotLimitNormal; //0x00C4
	float CheckEnemyInTheBackDotLimitHigh; //0x00C8
	DWORD KillNumMultiplierWhenCheckingEnemyThreatened; //0xCC
	float VeryCloseDistWhenAttacking; //0x00D0
	float VeryFarDistWhenAttacking; //0x00D4
	DWORD PercentageJumpWhenAttack; //0x00D8
	DWORD PercentageJumpWhenMoving; //0x00DC
	DWORD AttackShootingSniperVariationTimeLower; //0x00E0
	DWORD AttackShootingSniperVariationTimeUpper; //0x00E4
	DWORD AttackShootingOtherVariationTimeLower; //0x00E8
	DWORD AttackShootingOtherVariationTimeUpper; //0x00EC
	DWORD AttackAimingSniperVariationTimeLower; //0x00F0
	DWORD AttackAimingSniperVariationTimeUpper; //0x00F4
	DWORD AttackAimingOtherVariationTimeLower; //0x00F8
	DWORD AttackAimingOtherVariationTimeUpper; //0x00FC
	DWORD AttackAimingOtherVariationTimeLowerVeryClose; //0x0100
	DWORD AttackAimingOtherVariationTimeUpperVeryClose; //0x0104
	DWORD PercentageRunningWhenMoving; //0x0108
	DWORD PercentageRunningBackwardWhenMoving; //0x010C
	DWORD PercentageWalkingWhenMoving; //0x0110
	DWORD MaxMoveDurationLower; //0x0114
	DWORD MaxMoveDurationUpper; //0x0118
	//Incomplete
};
class sBasicPlayerInfo
{
public:
	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 CharacterHiddenaAlpha;
	float CharacterHiddenWalkAlpha;
	float CharacterHiddenRunAlpha;
	float MovementHiddenRate;
	unsigned long CrossHairColor;
	float CrossHairRedChangeRate;
	float CrossHairGreenChangeRate;
	float CrossHairBlueChangeRate;
};
class cWallHack
			{
				public:
				float WallHack; 
				char _0x0004[60];
			};

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

struct UnkStruct
{
		float Pitch;
		float Yaw;
		char spacer02[408];
		bool IsDead;
		char spacer03[5703];
		unsigned int CurrentGun;
		//char Spacer04[3];
		bool IsMutant;
};
struct cObject
{
public:
	char Spacer[4];
	LTVector Body;
	LTVector Foot;
	LTVector Head;
};
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;
	__int32 Deaths;
	__int32 HeadShots;
	__int32 TeamID;
	__int32 Ping;

};

Do It Yourself !

#include "stdafx.h"
DWORD dwSize;
DWORD dwStartAddress;

BOOL bCompare(const BYTE* pData, const BYTE* bMask, const char* szMask)
{
for(;*szMask;++szMask,++pData,++bMask)
{
if(*szMask == 'x' && *pData != *bMask)
return 0;
}
return (*szMask)==NULL;
}

DWORD FindPattern(DWORD dwAddress,DWORD dwLen,BYTE *bMask,char * szMask)
{
for(DWORD i=0; i < dwLen; i++)
if( bCompare( (BYTE*)( dwAddress+i ),bMask,szMask) )
return (DWORD)(dwAddress+i);
return 0;
}

DWORD FindPatternOffset(DWORD dwAddress,DWORD dwLen,BYTE *bMask,char * szMask, int posoffset)
{
	for(int x=0; x<100;){
	for(DWORD i=0; i < dwLen; i++){
  if( bCompare( (BYTE*)( dwAddress+i ),bMask,szMask) )
  {
	  if(x==posoffset){
	return (DWORD)(dwAddress+i);
	  }
	  else{ x++;}
	}
	}
return 0;
}
}

#include <Windows.h>
#include "Colors.h"
#include <d3d9.h>
#include <d3dx9.h>
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
#define DPD3D /*d3d9.dll*/XorStr<0xD6,9,0x090226CA>("\xB2\xE4\xBC\xE0\xF4\xBF\xB0\xB1"+0x090226CA).s
DWORD WINAPI D3D9VTable()
{
	DWORD hD3D = (DWORD)LoadLibraryA(DPD3D);
	DWORD adr = FindPattern(hD3D, 0x128000, (PBYTE)"\xC7\x06\x00\x00\x00\x00\x89\x86\x00\x00\x00\x00\x89\x86", "xx????xx????xx");
	return(adr + 2);
}
VOID WINAPI WriteMemory(LPVOID lpAddress,LPBYTE lpBuffer,DWORD dwLengh)
{
	LPBYTE pAddress = (LPBYTE)lpAddress;
	LPBYTE pBuffer = (LPBYTE)lpBuffer;
	MEMORY_BASIC_INFORMATION MBI; 
	VirtualQuery(lpAddress,&MBI,sizeof(MBI));
    VirtualProtect(MBI.BaseAddress,MBI.RegionSize,PAGE_EXECUTE_READWRITE,&MBI.Protect); 
   	while ( dwLengh-- > 0 ) 
	{
		*pAddress++ = *pBuffer++;
	}
	VirtualProtect(MBI.BaseAddress,MBI.RegionSize,MBI.Protect,&MBI.Protect);
    FlushInstructionCache(GetCurrentProcess(),lpAddress,dwLengh); 
}
DWORD FindDevice;
VOID WINAPI WriteJump(DWORD dwFunction,DWORD dwAddress)
{
	BYTE DetourBytes[5] = {0xE9,0x00,0x00,0x00,0x00};
	*(DWORD*)(&DetourBytes[1]) = ( dwFunction - dwAddress ) - 0x5;
	WriteMemory((LPVOID)dwAddress,(LPBYTE)DetourBytes,5);
}
BOOL WINAPI CheckWindowsVersion(DWORD dwMajorVersion,DWORD dwMinorVersion,DWORD dwProductType)
{
    OSVERSIONINFOEX VersionInfo;
    ZeroMemory(&VersionInfo,sizeof(OSVERSIONINFOEX));
    VersionInfo.dwOSVersionInfoSize = sizeof(VersionInfo);
    GetVersionEx((OSVERSIONINFO*)&VersionInfo);
	if ( VersionInfo.dwMajorVersion	== dwMajorVersion )
	{
		if ( VersionInfo.dwMinorVersion == dwMinorVersion )
		{
			if ( VersionInfo.wProductType == dwProductType )
			{
				return ( TRUE );
			}
		}
	}
	return ( FALSE );
}
VOID WINAPI HideModule(HMODULE hModule)
{
	DWORD dwPEB_LDR_DATA = 0;
	__asm
	{
        MOV EAX,FS:[0x30]
        MOV EAX,[EAX+0xC]
        MOV EAX,[EAX+0xC]
        MOV DWORD PTR [EAX+0x20],0xFFFFFFFF
	}
	__asm
	{
		PUSHAD
		PUSHFD
		MOV EAX, FS:[30h]             
		MOV EAX, [EAX+0Ch]               
		MOV dwPEB_LDR_DATA, EAX	
		InLoadOrderModuleList:
			MOV ESI, [EAX+0Ch]	     
			MOV EDX, [EAX+10h]	     
		LoopInLoadOrderModuleList: 
		    LODSD		         
			MOV ESI, EAX	
			MOV ECX, [EAX+18h]  
			CMP ECX, hModule	
			JNE SkipA		 
		    MOV EBX, [EAX]	  
		    MOV ECX, [EAX+4]  
		    MOV [ECX], EBX    
		    MOV [EBX+4], ECX	  
			JMP InMemoryOrderModuleList 
		SkipA:
			CMP EDX, ESI     
			JNE LoopInLoadOrderModuleList
		InMemoryOrderModuleList:
			MOV EAX, dwPEB_LDR_DATA
			MOV ESI, [EAX+14h]
			MOV EDX, [EAX+18h]
		LoopInMemoryOrderModuleList: 
			LODSD
			MOV ESI, EAX
			MOV ECX, [EAX+10h]
			CMP ECX, hModule
			JNE SkipB
			MOV EBX, [EAX] 
			MOV ECX, [EAX+4]
			MOV [ECX], EBX
			MOV [EBX+4], ECX
			JMP InInitializationOrderModuleList
		SkipB:
			CMP EDX, ESI
			JNE LoopInMemoryOrderModuleList
		InInitializationOrderModuleList:
			MOV EAX, dwPEB_LDR_DATA
			MOV ESI, [EAX+1Ch]	  
			MOV EDX, [EAX+20h]	  
		LoopInInitializationOrderModuleList: 
			LODSD
			MOV ESI, EAX		
			MOV ECX, [EAX+08h]
			CMP ECX, hModule		
			JNE SkipC
			MOV EBX, [EAX] 
			MOV ECX, [EAX+4]
			MOV [ECX], EBX
			MOV [EBX+4], ECX
			JMP Finished
		SkipC:
			CMP EDX, ESI
			JNE LoopInInitializationOrderModuleList
		Finished:
			POPFD;
			POPAD;
	}
}

BYTE DrawIndexedPrimitive_Bytes[5];
BOOL DrawIndexedPrimitive_Check = TRUE;
DWORD DrawIndexedPrimitive_Hook = 0x00;
DWORD DrawIndexedPrimitive_Jump = 0x00;
BOOL DrawIndexedPrimitive_CheckPtr = FALSE;
VOID WINAPI DrawIndexedPrimitive_Breakpoint();
LONG WINAPI DrawIndexedPrimitive_Exception(EXCEPTION_POINTERS* ExceptionInfo);
HRESULT (WINAPI* DrawIndexedPrimitive_Pointer)(LPDIRECT3DDEVICE9,D3DPRIMITIVETYPE,INT,UINT,UINT,UINT,UINT);

/*BYTE EndS_Bytes[5];
BOOL EndS_Check = TRUE;
DWORD EndS_Hook = 0x00;
DWORD EndS_Jump = 0x00;
BOOL EndS_CheckPtr = FALSE;
VOID WINAPI EndS_Breakpoint();
LONG WINAPI EndS_Exception(EXCEPTION_POINTERS* ExceptionInfo);
HRESULT (WINAPI* EndS_Pointer)(LPDIRECT3DDEVICE9 pDevice);
HRESULT (APIENTRY *oEndScene)(LPDIRECT3DDEVICE9 pDevice);*/

#define sWeapon 36
#define sMap 24
#define sSkyWalls 28
#define sBody 44
#define sHead 40
//
void DrawCrosshair(LPDIRECT3DDEVICE9 pDevice, int size, int strong,  D3DCOLOR xcolor)
{
	int iCenterX = GetSystemMetrics( 0 ) / 2;
	int iCenterY = GetSystemMetrics( 1 ) / 2;
	if( iCenterX < 20 && iCenterY < 20 )
	{
		iCenterX = ( GetSystemMetrics( 0 ) / 2 );
		iCenterY = ( GetSystemMetrics( 1 ) / 2 );
	}
	D3DRECT rec2 = { iCenterX- size, iCenterY, iCenterX+ size, iCenterY+ strong};
	D3DRECT rec3 = { iCenterX, iCenterY- size, iCenterX+ strong,iCenterY+ size};
	pDevice->Clear(1, &rec2, D3DCLEAR_TARGET, xcolor, 1000,  0);
	pDevice->Clear(1, &rec3, D3DCLEAR_TARGET, xcolor, 100,  0);
}
//
VOID DrawRect( INT x, INT y, INT h, INT w, DWORD Color, LPDIRECT3DDEVICE9 pDevice)
{
	D3DRECT rec;
	rec.x1 = x;
	rec.x2 = x + w;
	rec.y1 = y;
	rec.y2 = y + h;
	pDevice->Clear(1, &rec, D3DCLEAR_TARGET, Color, 0, 0);
}
void DrawMouse(DWORD color,LPDIRECT3DDEVICE9 pDevice)
{
	POINT myCursor; 
	GetCursorPos(&myCursor);
	DrawRect(myCursor.x,myCursor.y,11,1,color,pDevice);
	DrawRect(myCursor.x+1,myCursor.y+1,9,1,color,pDevice);
	DrawRect(myCursor.x+2,myCursor.y+2,7,1,color,pDevice);
	DrawRect(myCursor.x+3,myCursor.y+3,7,1,color,pDevice);
	DrawRect(myCursor.x+4,myCursor.y+4,8,1,color,pDevice);
	DrawRect(myCursor.x+5,myCursor.y+5,3,1,color,pDevice);
	DrawRect(myCursor.x+6,myCursor.y+6,2,1,color,pDevice);
	DrawRect(myCursor.x+7,myCursor.y+6,1,1,color,pDevice);
	DrawRect(myCursor.x+5,myCursor.y+10,4,1,color,pDevice);
	DrawRect(myCursor.x+6,myCursor.y+12,2,1,color,pDevice);
}
//
LPDIRECT3DTEXTURE9    texYellow, texBlue;
HRESULT GenerateTexture(IDirect3DDevice9 *pD3Ddev, IDirect3DTexture9 **ppD3Dtex, DWORD colour32)
{
	if( FAILED(pD3Ddev->CreateTexture(8, 8, 1, 0, D3DFMT_A4R4G4B4, D3DPOOL_MANAGED, ppD3Dtex,NULL)) )
		return E_FAIL;
	
	WORD colour16 =	((WORD)((colour32>>28)&0xF)<<12)
			|(WORD)(((colour32>>20)&0xF)<<8)
			|(WORD)(((colour32>>12)&0xF)<<4)
			|(WORD)(((colour32>>4)&0xF)<<0);

	D3DLOCKED_RECT d3dlr;    
	(*ppD3Dtex)->LockRect(0, &d3dlr, 0, 0);
	WORD *pDst16 = (WORD*)d3dlr.pBits;

	for(int xy=0; xy < 8*8; xy++)
		*pDst16++ = colour16;

	(*ppD3Dtex)->UnlockRect(0);

	return S_OK;
}
VOID WINAPI DrawIndexedPrimitive_Main(LPDIRECT3DDEVICE9 pDevice,D3DPRIMITIVETYPE Type,INT BaseVertexIndex,UINT MinIndex,UINT NumVertices,UINT StartIndex,UINT PrimitiveCount)
{
	LPDIRECT3DVERTEXBUFFER9 Stream;
	UINT Stride;
	UINT Offset;
	if ( pDevice->GetStreamSource(0,&Stream,&Offset,&Stride) == D3D_OK )
	{
		Stream->Release();
	}
	if(!OnceTxture){
	GenerateTexture(pDevice, &texBlue,D3DCOLOR_ARGB(255,0,0,255));
	GenerateTexture(pDevice, &texYellow,D3DCOLOR_ARGB(255,255,255,0));
	OnceTxture = true;
	}
	DrawIndexedPrimitive_CheckPtr = TRUE;
	if (Stride == sBody || Stride == sWeapon || Stride == sWeapon)
	{
		pDevice->SetRenderState(D3DRS_ZENABLE,FALSE);
		pDevice->SetTexture(0, texYellow);
		DrawIndexedPrimitive_Pointer(pDevice,Type,BaseVertexIndex,MinIndex,NumVertices,StartIndex,PrimitiveCount);
		pDevice->SetRenderState(D3DRS_ZENABLE,TRUE);
		pDevice->SetTexture(0, texBlue);
		//DrawCrosshair(pDevice , 13, 1.5, cPink);	
		
	}

	if( Stride == 1 )
	DrawCrosshair(pDevice , 13, 1.5, cPink);	

	DrawIndexedPrimitive_CheckPtr = FALSE;
}
__declspec(naked)VOID WINAPI DrawIndexedPrimitive_Call()
{
	if ( DrawIndexedPrimitive_Check == TRUE )
	{
		WriteMemory((LPVOID)DrawIndexedPrimitive_Hook,(LPBYTE)DrawIndexedPrimitive_Bytes,5);
		DrawIndexedPrimitive_Breakpoint();
		DrawIndexedPrimitive_Check = FALSE;
	}
	__asm
    {
		MOV EDI,DWORD PTR SS:[EBP+0x8]
		XOR EBX,EBX 
		PUSHFD 
		PUSHAD
     	MOV EDX,[DrawIndexedPrimitive_CheckPtr]
		CMP EDX,0x0
		JG Jump
		PUSH [EBP+0x20]
		PUSH [EBP+0x1C]
		PUSH [EBP+0x18]
		PUSH [EBP+0x14]
		PUSH [EBP+0x10]
		PUSH [EBP+0xC]
		PUSH [EBP+0x8]
	    CALL [DrawIndexedPrimitive_Main]
		Jump:
        POPAD
        POPFD
		CMP EDI,EBX
		JMP [DrawIndexedPrimitive_Jump]
    }
}
LONG WINAPI DrawIndexedPrimitive_Exception(EXCEPTION_POINTERS* ExceptionInfo)
{
	if ( ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_SINGLE_STEP && (DWORD)ExceptionInfo->ExceptionRecord->ExceptionAddress == DrawIndexedPrimitive_Hook )
	{
		ExceptionInfo->ContextRecord->Eip = (DWORD)DrawIndexedPrimitive_Call;
		return ( EXCEPTION_CONTINUE_EXECUTION );
	} 
	return ( EXCEPTION_CONTINUE_SEARCH );
}
VOID WINAPI DrawIndexedPrimitive_Breakpoint()
{
	AddVectoredExceptionHandler((rand()%0xFFFFFF),DrawIndexedPrimitive_Exception); 
	CONTEXT Context = {CONTEXT_DEBUG_REGISTERS};
	Context.Dr0 = DrawIndexedPrimitive_Hook;
	Context.Dr7 = 0x1;
	SetThreadContext(GetCurrentThread(),&Context);
}
//

//
VOID WINAPI DirectX9Main()
{
	PDWORD dwD3DVTable;
	do
	{
		*(DWORD*)&dwD3DVTable = *(DWORD*)D3D9VTable();
	}
	while ( !dwD3DVTable );
	/* This Hook Is For Windows 7 and Windows Vista */
	if ( CheckWindowsVersion(6,1,VER_NT_WORKSTATION) || CheckWindowsVersion(6,0,VER_NT_WORKSTATION) )
	{
	    DrawIndexedPrimitive_Hook = ( dwD3DVTable[82] + 0x2D );
	    DrawIndexedPrimitive_Jump = ( DrawIndexedPrimitive_Hook + 0x7 );
	    *(PDWORD)(&DrawIndexedPrimitive_Pointer) = (DWORD)dwD3DVTable[82];
	    WriteMemory((LPVOID)DrawIndexedPrimitive_Bytes,(LPBYTE)DrawIndexedPrimitive_Hook,5);
	    WriteJump((DWORD)DrawIndexedPrimitive_Call,(DWORD)DrawIndexedPrimitive_Hook);
		//
	}
	/* You Want A Hook For Windows XP ? - Add A Midfunction For Windows XP And A Check Here */
	else 
	{
		MessageBoxA(GetActiveWindow(),"CoderName >> Your System Is Not Supported","<Error>",MB_OK);
		ExitProcess(0);
	}
}

#include "stdafx.h"
#include "conio.h"
#include "Pattern.h"
#include <string>
#include <Windows.h>
#include <iostream>
#include <string.h>
#include <fstream>
#include <sstream>
//=== Public Values ===
extern DWORD CShell;
extern DWORD Cfexe;
//======== Weapon Manager ========
DWORD WeaponMgr = 0;
DWORD CShellPtr = 0;
DWORD BPlayerInfo = 0;
DWORD Speed = 0;
DWORD NormalWall = 0;
DWORD PlayerptrMgr ;
DWORD MemCGhosts = 0;
DWORD ZoneMgr = 0;
DWORD BlackWall =0;
DWORD ModelNodeMGR = 0;
DWORD GunKnifeRange = 0;
DWORD PlayerSize=0;
DWORD PlayerStart=0;
DWORD MePlayer=0;
DWORD IsLoop = 0;
DWORD WallDmg = 0;
DWORD CrossHairSize = 0;
DWORD PVEffect = 0;
DWORD AmmoDmg = 0;
DWORD Range = 0;
DWORD WeaponName = 0;
DWORD HaveKnife = 0;
DWORD KnifeAnim = 0;
DWORD KnifeSound = 0;
DWORD AmmoPerMagazine = 0;
DWORD MaxAmmo = 0;
DWORD DmgFactorByDis = 0;
DWORD DamageVariantionFactor = 0;
DWORD BoomDurationDmg = 0;
DWORD GrenadeBelowTime = 0;
DWORD DmgRatioPerNode = 0;
DWORD MoveSpeedPenalty = 0;
DWORD NanoGhostDmgPenaltyTime = 0;
DWORD NanoGhostDmgMoveRate = 0;
DWORD FireWeapon = 0;
DWORD ILTClient = 0;
DWORD PDeviceAdd = 0;
DWORD MapMgr = 0;
DWORD CharacterMgr = 0;
DWORD CharacterViewMgr = 0;
DWORD EffectIndicator = 0;
DWORD EffectIndicatorC = 0;
DWORD NanoCharMgr = 0x10C13E8;
DWORD FallPtr = 0;
DWORD MiscMgr = 0;
DWORD AI_Power = 0;
DWORD WallHackNew = 0;
//
DWORD MSGBOX=0;
DWORD MSGBOX_1Push=0;
DWORD MSGBOX_2Push=0;
DWORD MSGBOX_3Push=0;
DWORD MSGBOX_Add=0;
//
DWORD dwCPlayerStart=0;
DWORD GetMyPlayerIndex=0;
DWORD MeOffset=0;
DWORD GetBoneAddress=0;
//=== Zoom ===
DWORD ZoomAction = 0;
DWORD ZoomStage = 0;
//=== Attributes ===
DWORD RightClickAttribute = 0xAF0; // #Done
DWORD LeftClickAttribute = 0; // #Done
DWORD ZoomAttribute = 0xAF4; // #Done
DWORD ReloadAttribute = 0; // #Done
DWORD KnifeLeftClickAttribute = 0; // #Done
DWORD KnifeRightClickAttribute = 0; // #Done
//======== Knife Offsets =========
DWORD KnifeNormalAniRate = 0xA70;
DWORD KnifeNormalAngle = 0xAFC;
DWORD KnifeNormalAmmoDamage = 0x81C;
DWORD KnifeRange = 0x80C;
DWORD KnockBack = 0x3CD0;
//############# PTC ##############
DWORD PushToConsoleAddy = 0;
DWORD PTC_Addy = 0x204;
//########## BYPASS(s) ###########
DWORD Bypass_1 = 0;
DWORD Bypass_2 = 0x204;
//###### GET ADDRESS(s) ######
void GetAddress(){
DWORD FPWeaponMgr = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x8B\x4F\x04\xA1\x00\x00\x00\x00\x85\xC0\x8B\x51\x04\x8B\x6A\x04", "xxxx????xxxxxxxx");
    if(FPWeaponMgr!=NULL){ 
	WeaponMgr = (*(DWORD*)(FPWeaponMgr + 4)) - CShell;
						}
	DWORD Point = FindPattern(Cfexe,0xFFFFFF,(BYTE *)"\x75\xFF\x83\x0D\xFF\xFF\xFF\xFF\x01\xB8\xFF\xFF\xFF\xFF\xE8","x?xx????xx????x");
	if(Point!=NULL){
	BlackWall  = *(DWORD*)(Point + 0xA) + 0xA4 + 0x68 ;
	WallHackNew = BlackWall + 0xA4 + 0x68;
	}
	DWORD FPCShellPtr = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\xc6\x01\x01\x8b\x15\x00\x00\x00\x00\x8b\x82\x00\x00\x00\x00\x8B", "xxxxx????xx????x");
    if(FPCShellPtr!=NULL){ 
	CShellPtr = (*(DWORD*)(FPCShellPtr + 5)) - CShell;
						}
		DWORD FPPTC_Addy = FindPattern((DWORD)CShell, 0xFFFFFF, (PBYTE)"\x8B\x0D\x44\xA2\x59\x10\x8B\x91\x04\x02\x00\x00\x68\xB8\x55\x4C\x10\xFF\xD2\x83\xC4\x04\x53\xE8\x46\xF3\xFD\xFF\x8B\xC8\xE8\xBF\x5F\x2F\x00", "xx????xx????x????xxxxxxx????xxx????");
	if(FPPTC_Addy!=NULL){ 
	PTC_Addy = (*(DWORD*)(FPPTC_Addy + 8));
						}
	DWORD FPBPlayerInfo = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x8B\x0D\xD8\x52\xF6\x10\x83\xC4\x04\x69\xC0\xA8\x00\x00\x00\xD9\x9C\x08\x88\x00\x00\x00\x8B\x4C\x24\x30\x3B\xCB", "xx????xxxxx????xxx????xxx?xx");
    if(FPBPlayerInfo!=NULL){ 
	BPlayerInfo = (*(DWORD*)(FPBPlayerInfo + 2)) - CShell;
						}
	DWORD FPPushToConsoleAddy = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x8B\x0D\x44\xA2\x59\x10\x8B\x91\x04\x02\x00\x00\x68\xB8\x55\x4C\x10\xFF\xD2\x83\xC4\x04\x53\xE8\x46\xF3\xFD\xFF\x8B\xC8\xE8\xBF\x5F\x2F\x00", "xx????xx????x????xxxxxxx????xxx????");
	if(FPPushToConsoleAddy!=NULL){ 
	PushToConsoleAddy = (*(DWORD*)(FPPushToConsoleAddy + 2)) - CShell;
						}
	DWORD FPNormalWall = FindPattern((DWORD)Cfexe, 0x2D7000,(PBYTE)"\xB8\x00\x00\x00\x00\xE8\x00\x00\x00\x00\x8B\x06\x8B\x50\x18", "x????x????xxxxx");
    if(FPNormalWall!=NULL){ 
		NormalWall = *(DWORD*)(FPNormalWall + 1);
            NormalWall += 0xA4;
						}
	DWORD FPMemCGhosts = FindPattern((DWORD)Cfexe, 0x2D7000,(PBYTE)"\xB8\x00\x00\x00\x00\xE8\x00\x00\x00\x00\x8B\x06\x8B\x50\x18", "x????x????xxxxx");
    if(FPMemCGhosts!=NULL){ 
		MemCGhosts = *(DWORD*)(FPMemCGhosts + 1);
            MemCGhosts += 0xB8;
						}
	DWORD FPModelNodeMGR = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x8B\x15\x00\x00\x00\x00\x83\xC4\x20\x33\xED\x33\xFF\x8B\x4C\x24\x30", "xx????xxxxxxxxxxx");
	if(FPModelNodeMGR!=NULL){ 
	ModelNodeMGR = (*(DWORD*)(FPModelNodeMGR + 2)) - CShell;
						}
	DWORD FPReloadAttribute = FindPatternOffset((DWORD)CShell, 0xFFFFFF,(PBYTE)"\xFF\x15\x00\x00\x00\x00\x8B\x0D\x00\x00\x00\x00\x8B\x04\xB1\x83\x88\x00\x00\x00\x00\x00", "xx????xx????xxxxx?????", 19);
	if(FPReloadAttribute!=NULL){ 
	ReloadAttribute = (*(DWORD*)(FPReloadAttribute + 17));
						}
	DWORD FPRightClickAttribute = FindPatternOffset((DWORD)CShell, 0xFFFFFF,(PBYTE)"\xFF\x15\x00\x00\x00\x00\x8B\x0D\x00\x00\x00\x00\x8B\x04\xB1\x83\x88\x00\x00\x00\x00\x00", "xx????xx????xxxxx?????", 6);
	if(FPRightClickAttribute!=NULL){ 
	RightClickAttribute = (*(DWORD*)(FPRightClickAttribute + 17));
						}
	DWORD FPLeftClickAttribute = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\xFF\x15\x00\x00\x00\x00\x8B\x0D\x00\x00\x00\x00\x8B\x04\xB1\x83\x88\x00\x00\x00\x00\x00", "xx????xx????xxxxx?????");
	if(FPLeftClickAttribute!=NULL){ 
	LeftClickAttribute = (*(DWORD*)(FPLeftClickAttribute + 17));
						}
	DWORD FPZoomAttribute = FindPatternOffset((DWORD)CShell, 0xFFFFFF,(PBYTE)"\xFF\x15\x00\x00\x00\x00\x8B\x0D\x00\x00\x00\x00\x8B\x04\xB1\x83\x88\x00\x00\x00\x00\x00", "xx????xx????xxxxx?????", 13);
	if(FPZoomAttribute!=NULL){ 
	ZoomAttribute = (*(DWORD*)(FPZoomAttribute + 17));
						}
	DWORD FPKnifeLeftClickAttribute = FindPatternOffset((DWORD)CShell, 0xFFFFFF,(PBYTE)"\xFF\x15\x00\x00\x00\x00\x8B\x0D\x00\x00\x00\x00\x8B\x04\xB1\x83\x88\x00\x00\x00\x00\x00", "xx????xx????xxxxx?????", 25);
	if(FPKnifeLeftClickAttribute!=NULL){ 
	KnifeLeftClickAttribute = (*(DWORD*)(FPKnifeLeftClickAttribute + 17));
						}
	DWORD FPKnifeRightClickAttribute = FindPatternOffset((DWORD)CShell, 0xFFFFFF,(PBYTE)"\xFF\x15\x00\x00\x00\x00\x8B\x0D\x00\x00\x00\x00\x8B\x04\xB1\x83\x88\x00\x00\x00\x00\x00", "xx????xx????xxxxx?????", 27);
	if(FPKnifeRightClickAttribute!=NULL){ 
	KnifeRightClickAttribute = (*(DWORD*)(FPKnifeRightClickAttribute + 17));
						}
	DWORD FPPlayerptrMgr = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\xB9\x00\x00\x00\x00\xE8\x00\x00\x00\x00\x68\x00\x00\x00\x00\xE8\x00\x00\x00\x00\x59\xC3\xCC\xCC\xCC\xCC\xCC\xCC\xCC\xCC\xCC\xCC\x6A\x04\x68", "x????x????x????x????xxxxxxxxxxxxxxx");
	if(FPPlayerptrMgr!=NULL){ 
	PlayerptrMgr = (*(DWORD*)(FPPlayerptrMgr + 40))-CShell;
						}
	DWORD FPSpeed = FindPattern((DWORD)Cfexe, 0xFFFFFF,(PBYTE)"\xDC\x35\x00\x00\x00\x00\x83\xEC\x00\xDD\x1C\x24", "xx????xx?xxx");
    if(FPSpeed!=NULL){ 
	Speed = (*(DWORD*)(FPSpeed + 2));
	Speed += 0x4;
						}
	DWORD FPPVEffect = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\xFF\x15\x00\x00\x00\x00\x8B\x0D\x00\x00\x00\x00\x8B\x14\xA9\x8D\x8C\x1A\x00\x00\x00\x00\x8D\x64\x24\x00\x8A\x06\x88\x01", "xx????xx????xxxxxx????xxxxxxxx");
	if(FPPVEffect!=NULL){ 
	PVEffect =  (*(DWORD*)(FPPVEffect + 18));
						}
	DWORD FPLTClientShellSize = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x0C\xFF\x5E\xC3\x0F\xB6\x8E\x00\x00\x00\x00\x69\xC9\x00\x00\x00\x00\x8A\x84\x31\x00\x00\x00\x00", "xxxxxxx????xx????xxx????");
	if(FPLTClientShellSize!=NULL){ 
	dwCPlayerStart = (*(DWORD*)(FPLTClientShellSize + 7));
						}
	DWORD FPMeOffset = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x0C\xFF\x5E\xC3\x0F\xB6\x8E\x00\x00\x00\x00\x69\xC9\x00\x00\x00\x00\x8A\x84\x31\x00\x00\x00\x00", "xxxxxxx????xx????xxx????");
	if(FPMeOffset!=NULL){ 
	MeOffset = (*(DWORD*)(FPMeOffset + 20));
						}
	DWORD FPPlayerSize = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x0C\xFF\x5E\xC3\x0F\xB6\x8E\x00\x00\x00\x00\x69\xC9\x00\x00\x00\x00\x8A\x84\x31\x00\x00\x00\x00", "xxxxxxx????xx????xxx????");
	if(FPPlayerSize!=NULL){ 
	PlayerSize = (*(DWORD*)(FPPlayerSize + 13));
						}
	DWORD FPGetMyPlayerIndex = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x0C\xFF\x5E\xC3\x0F\xB6\x8E\x00\x00\x00\x00\x69\xC9\x00\x00\x00\x00\x8A\x84\x31\x00\x00\x00\x00", "xxxxxxx????xx????xxx????");
	if(FPGetMyPlayerIndex!=NULL){ 
	GetMyPlayerIndex = (FPGetMyPlayerIndex - 17) - CShell;
						}
	DWORD FPGetBoneAddress = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x8B\x0D\x00\x00\x00\x00\x8B\x11\x8B\x52\x34\x6A\x01\x8D\x7E\x40", "xx????xxxxxxxxxx");
	if(FPGetBoneAddress!=NULL){ 
	GetBoneAddress =  (*(DWORD*)(FPGetBoneAddress + 2))-CShell;
						}
	DWORD FPIsLoop = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x3B\xE8\x72\x0C\xFF\x15\x00\x00\x00\x00\x8B\x0D\x00\x00\x00\x00\x8B\x14\xA9\x89\xBC\xB2\x00\x00\x00\x00\x8B\x03\x83\xC6\x01\x83\xE8\x01", "xxxxxx????xx????xxxxxx????xxxxxxxx");
	if(FPIsLoop!=NULL){ 
	IsLoop =  (*(DWORD*)(FPIsLoop + 22));
						}
	DWORD FPWallDmg = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x8D\x2C\xB0\xFF\x15\x00\x00\x00\x00\xD9\x5C\x24\x14\xD9\x44\x24\x14\x8B\x4D\x00\xD9\x9C\x0F\x00\x00\x00\x00", "xxxxx????xxxxxxxxxxxxxx????");
	if(FPWallDmg!=NULL){ 
	WallDmg =  (*(DWORD*)(FPWallDmg + 23));
	}
	DWORD FPCrossHairSize = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\xFF\x15\x00\x00\x00\x00\xD9\x5C\x24\x14\xD9\x44\x24\x14\x8B\x4D\x00\xD9\x9C\x0F\x00\x00\x00\x00\x83\xC7\x04\x83\xC4\x04\x83\xFF\x14", "xx????xxxxxxxxxxxxxx????xxxxxxxxx");
	if(FPCrossHairSize!=NULL){ 
	CrossHairSize =  (*(DWORD*)(FPCrossHairSize + 20));
	}
	DWORD FPAmmoDmg = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\xFF\x15\x00\x00\x00\x00\xD9\x5C\x24\x14\xD9\x44\x24\x14\x8B\x06\xD9\x98\x00\x00\x00\x00\x83\xC4\x04",  "xx????xxxxxxxxxxxx????xxx");
	if(FPAmmoDmg!=NULL){ 
	AmmoDmg =  (*(DWORD*)(FPAmmoDmg + 18));
	}
	DWORD FPRange = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\xD9\x98\x00\x00\x00\x00\x68\x00\x00\x00\x00\x53\xE8\x00\x00\x00\x00\x83\xC4\x08\x85\xC0\x74\x58", "xx????x????xx????xxxxxxx");
	if(FPRange!=NULL){ 
	Range =  (*(DWORD*)(FPRange + 2));
	}
	DWORD FPWeaponName = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\xC1\xF8\x02\x3B\xE8\x72\x0C\xFF\x15\x00\x00\x00\x00\x8B\x0D\x00\x00\x00\x00\x8B\x04\xA9\x83\xC0", "xxxxxxxxx????xx????xxxxx");
	if(FPWeaponName!=NULL){ 
	WeaponName =  (*(BYTE*)(FPWeaponName + 24));
	}
	DWORD FPMSGBOX = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x80\x3D\x00\x00\x00\x00\x00\x74\x21\x83\x7C\x24\x00\x00\xC6\x05\x00\x00\x00\x00\x00\x75\x13", "xx?????xxxxx??xx?????xx");
	if(FPMSGBOX!=NULL){ 
	MSGBOX = *(DWORD*)(FPMSGBOX + 35) + (FPMSGBOX + 39);
	MSGBOX -= CShell;
	MSGBOX_1Push = (*(BYTE*)(FPMSGBOX + 29));
	MSGBOX_2Push = (*(BYTE*)(FPMSGBOX + 31));
	MSGBOX_3Push = (*(BYTE*)(FPMSGBOX + 33));
	MSGBOX_Add = (*(BYTE*)(FPMSGBOX + 41)) ;
	}
	DWORD FPHaveKnife = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x8D\x3C\xB1\xFF\x15\x00\x00\x00\x00\x8B\x0F\x83\xC4\x04\x85\xC0", "xxxxx????xxxxxxx");
	if(FPHaveKnife!=NULL){ 
	HaveKnife = (*(DWORD*)(FPHaveKnife + 21));
	}
	DWORD FPKnifeAnim = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\xFF\x15\x00\x00\x00\x00\x8B\x0D\x00\x00\x00\x00\x8B\x0C\xB1\x81\xC1\x00\x00\x00\x00\x90\x8A\x07\x88\x01", "xx????xx????xxxxx????xxxxx");
	if(FPKnifeAnim!=NULL){ 
	KnifeAnim = (*(DWORD*)(FPKnifeAnim + 17));
	}
	DWORD FPKnifeSound = FindPatternOffset((DWORD)CShell, 0xFFFFFF,(PBYTE)"\xC1\xF8\x02\x3B\xF0\x72\x0C\xFF\x15\x00\x00\x00\x00\x8B\x0D\x00\x00\x00\x00\x8B\x0C\xB1\x81\xC1\x00\x00\x00\x00\x8A\x07\x88\x01\x83\xC7\x01", "xxxxxxxxx????xx????xxxxx????xxxxxxx", 1);
	if(FPKnifeSound!=NULL){ 
	KnifeSound = (*(DWORD*)(FPKnifeSound + 24));
	}
	DWORD FPGunKnifeRange = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x8B\x17\xDC\x0D\x00\x00\x00\x00\x83\xC4\x04\xD9\x5C\x24\x10\xD9\x44\x24\x10\xD9\x9A\x00\x00\x00\x00", "xxxx????xxxxxxxxxxxxx????");
	if(FPGunKnifeRange!=NULL){
		GunKnifeRange = (*(DWORD*)(FPGunKnifeRange + 21));
	}
	/*DWORD FPAmmoPerMagazine = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x8B\x0D\x00\x00\x00\x00\x57\x8D\x34\xA9\xFF\xD3\x8B\x16\x83\xC4\x04\x66\x89\x82\x00\x00\x00\x00\x8B\x44\x24\x14", "xx????xxxxxxxxxxxxxx????xxxx");
	if(FPAmmoPerMagazine!=NULL){
		AmmoPerMagazine = (*(DWORD*)(FPAmmoPerMagazine + 20));
	}*/
	AmmoDmg = Range + 0x10;
	AmmoPerMagazine = Range + 0xA;
	MaxAmmo = AmmoPerMagazine - 0x2;
	DmgFactorByDis = AmmoDmg + 0x14;
	DamageVariantionFactor = DmgFactorByDis + 0x8;
	DWORD FPBoomDurationDmg = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x8B\x0F\x83\xC4\x04\x85\xC0\x0F\x95\xC0\x88\x81\x00\x00\x00\x00\x8B\x54\x24\x14", "xxxxxxxxxxxx????xxxx");
	if(FPBoomDurationDmg!=NULL){
		BoomDurationDmg = (*(DWORD*)(FPBoomDurationDmg + 12));
	}
	GrenadeBelowTime = BoomDurationDmg - 0x5;
	DWORD FPMoveSpeedPenalty = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\xD9\x99\x00\x00\x00\x00\x83\xC4\x04\x68\x00\x00\x00\x00\x57\xE8\x00\x00\x00\x00", "xx????xxxx????xx????");
	if(FPMoveSpeedPenalty!=NULL){
		MoveSpeedPenalty = (*(DWORD*)(FPMoveSpeedPenalty + 2));
	}
	DmgRatioPerNode = MoveSpeedPenalty + 0x4;
	NanoGhostDmgPenaltyTime = WallDmg - 0x8;
	NanoGhostDmgMoveRate = WallDmg - 0x4;
	DWORD FPFireWeapon = FindPattern((DWORD)CShell, 0xFFFFFF,(PBYTE)"\x84\xC0\x74\x36\x6A\x25\xE8\x00\x00\x00\x00\xC7\x80\x00\x00\x00\x00\x00\x00\x00\x00\xC6\x80\x00\x00\x00\x00\x00\x8B\x56\x04", "xxxxxxx????xx????????xx?????xxx");
	if(FPFireWeapon!=NULL){
		FireWeapon = *(DWORD*)(FPFireWeapon - 4) + (FPFireWeapon);
		FireWeapon -= CShell;
	}
	/*DWORD FPILTClient = FindPattern((DWORD)CShell, 0xFFFFFF, (PBYTE)"\x8B\x0D\x00\x00\x00\x00\x8B\x11\x8B\x82\x00\x00\x00\x00","xx????xxxx????");
	if(FPILTClient!=NULL){
	ILTClient = *(DWORD*)(ILTClient + 0x2);
	ILTClient -= CShell;
	}*/
	DWORD FPPDeviceAdd = FindPattern((DWORD)Cfexe, 0xFFFFFF, (PBYTE)"\x8B\x35\xFF\xFF\xFF\xFF\x8B\xEE\xE8\xFF\xFF\xFF\xFF\x8B\x45\x00\x8B\x08\x8B\x91\xFF\xFF\xFF\xFF\x57\x6A\xFF\x53","xx????xxx????xxxxxxx????xx?x");
	if(FPPDeviceAdd!=NULL){
	PDeviceAdd = *(DWORD*)(FPPDeviceAdd + 0x2);
	}
	DWORD FPEffectIndicator = FindPattern((DWORD)CShell, 0xFFFFFF, (PBYTE)"\xFF\x15\x00\x00\x00\x00\xA1\x00\x00\x00\x00\x8B\x14\xA8\x8B\x44\x24\x2C\x8D\x8C\x02\x00\x00\x00\x00\x8A\x07\x88\x01\x83\xC7\x01","xx????x????xxxxxxxxxx????xxxxxxx");
	if(FPEffectIndicator!=NULL){
	EffectIndicator = *(DWORD*)(FPEffectIndicator + 21);
	EffectIndicatorC = EffectIndicator + 0x96;
	}
	DWORD FPMapMgr = FindPattern((DWORD)CShell, 0xFFFFFF, (PBYTE)"\x8B\x40\x04\x50\xFF\xD6\x8B\x0D\x00\x00\x00\x00\x0F\xB7\xC0\x0F\xBF\xE8\x89\x6C\x24\x54", "xxxxxxxx????xxxxxxxxxx");
	if(FPMapMgr!=NULL){
	MapMgr = *(DWORD*)(FPMapMgr + 8);
	MapMgr -= CShell;
	}
	DWORD FPCharacterMgr = FindPattern((DWORD)CShell, 0xFFFFFF, (PBYTE)"\x8B\x51\x04\x0F\xBE\xC3\x69\xC0\x00\x00\x00\x00\x03\x05\x00\x00\x00\x00\x8A\x0A\x88\x08\x83\xC2\x01", "xxxxxxxx????xx????xxxxxxx");
	if(FPCharacterMgr!=NULL){
	CharacterMgr = *(DWORD*)(FPCharacterMgr + 14);
	CharacterMgr -= CShell;
	CharacterViewMgr = CharacterMgr + 0x8;
	}
	DWORD FPNanoCharMgr = FindPattern((DWORD)CShell, 0xFFFFFF, (PBYTE)"\x50\xFF\xD7\x8B\x0D\x00\x00\x00\x00\x83\xC4\x04\x89\x44\x29\x1C\x8B\x4C\x24\x30", "xxxxx????xxxxxxxxxxx");
	if(FPNanoCharMgr!=NULL){
	NanoCharMgr = *(DWORD*)(FPNanoCharMgr + 5);
	NanoCharMgr -= CShell;
	}
	DWORD FPZoomAction = FindPattern((DWORD)CShell, 0xFFFFFF, (PBYTE)"\x8B\x04\xB1\xD9\x98\x00\x00\x00\x00\xEB\x50", "xxxxx????xx");
	if(FPZoomAction!=NULL){
	ZoomAction = *(DWORD*)(FPZoomAction + 5);
	}
	DWORD FPZoomStage = FindPattern((DWORD)CShell, 0xFFFFFF, (PBYTE)"\x8B\x41\x04\x50\x81\xC7\x00\x00\x00\x00\xFF\x15\x00\x00\x00\x00", "xxxxxx????xx????");
	if(FPZoomStage!=NULL){
	ZoomStage = *(DWORD*)(FPZoomStage + 6);
	}
	DWORD FPMiscMgr = FindPattern((DWORD)CShell, 0xFFFFFF, (PBYTE)"\xFF\x15\x00\x00\x00\x00\x8B\x15\x00\x00\x00\x00\xD9\x1A", "xx????xx????xx");
	if(FPMiscMgr!=NULL){
	MiscMgr = *(DWORD*)(FPMiscMgr + 8);
	MiscMgr -= CShell;
	}
	DWORD FPAI_Power = FindPattern((DWORD)CShell, 0xFFFFFF, (PBYTE)"\x50\x8B\xCE\x88\x9C\x24\x00\x00\x00\x00\xE8\x00\x00\x00\x00", "xxxxxx????x????");
	if(FPAI_Power!=NULL){
	AI_Power = *(DWORD*)(FPAI_Power + 11) + (FPAI_Power + 15);
	AI_Power -= CShell;
	}

}

#include "stdafx.h"
#include <d3d9.h>
#include <d3dx9.h>
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
//=== Publick Booleans ===
//### I2 Specials ###
bool I2espectWM = true;
bool CharacterCh = false;
bool NanoCharacterCH = false;
bool SlugClaws = false;
bool KnifeRedCrystal = false;//ERROR
bool Specular = false;
bool Reflection = false;
bool i2_chams = false;
bool i2_Character = false;
//### AH & 1Hit ###
bool AlwaysHeadShot = false;
int HeadShotType = 1; // 1 Gold , 2 Silver
bool OneHitRifle = false;
bool OneHitSniper = false;
//### Normal ###
bool Gravity = false;
bool WallHack = false;
bool RemoteGrenade = false;
bool RemoteGrenadeExNow = false;
bool NoGrenadeDmg = false;
bool OneHitNadeG= false;
bool NoSmoke = false;
bool NoFlash = false;
bool No_Fall_Dmg = false;
bool One_Fall2Die = false;//Test :D
bool Fall_Recovery = false;//Test :D
bool WalkThroughWall = false;
bool M16_OHK = false;
bool GrenadeRange = false;
bool Stunner = false;
bool KnockerBack = false;
bool FastKnife = false;
bool DescreaseIncomeDmg = false;
bool SeeGhosts = false;// Character Change
bool FullWallbang = false;
bool SnipersCS = false;
bool ES_MEMORY = false;
//### Test ###
bool IronBeastTest = false;
bool TuroialMapCH = false;
bool NewNoRecoil = false;
bool NewNoRecoil_2 = false;
bool TrainingWeapons = false;
bool WalkSpeed = false; //NUMPAD6
bool NoWeaponChangeDelay = false; //NUMPAD7
bool NoWeaponWeight = false; //NUMPAD9
// Masters
bool MWalkSpeed = false;
bool MNoWeaponChangeDelay = false;
bool MNoWeaponWeight = false;
//### Weapon Specials ###
bool Zoomer = false;
int Zoomer_ID = 25;
bool Small_CS = false;
int Small_CS_ID = -1;
//### TELEUPDOWN ###
bool TeleUPDOWN = true;
//### TELEPORT ###
bool Teleporter = true;
UINT SaveKey = VK_LSHIFT;
UINT SaveKey_2 = VK_END;
UINT LoadKey = VK_LSHIFT;
UINT LoadKey_2 = VK_HOME;
D3DXVECTOR3 SavedLocation;
//### Some Hotkeys ###
bool NoWorld = false;
UINT NoWorld_Key = VK_NUMPAD3;
bool Lagger = false;
UINT Lagger_Key = VK_LSHIFT;
UINT Lagger_Key2 = VK_NUMPAD3;
//### Public New ###
// Knife
bool Knife_Left_Click_Speed = true;
bool Knife_Right_Click_Speed = true;
bool Knife_Left_Click_Range = true;
bool Knife_Right_Click_Range = true;
// Misc
bool InstantDefuseC4 = true;
// Special
bool SeeGhostsMem = true;// Value
// VIP Weapons
bool M4A1VIP = false;
bool RPKVIP = false;
bool AWMVIP = false;
bool AKVIP = false;
// Creating Texture Once
bool OnceTxture = false;

#include "stdafx.h"
#include "stdafx.h"
#include <Windows.h>
#include <iostream>
#include <string.h>
#include "I2.h"
#include <fstream>
#include <sstream>
#include "Xor.h"
#include "Addresses.h"
#include "Booleans.h"
#include "I2-Tools.h"
using namespace std;
//=== Encrypted Strings ===
#define DPLCS /*CShell.dll*/XorStr<0x3B,11,0x023A6AF4>("\x78\x6F\x55\x5B\x53\x2C\x6F\x26\x2F\x28"+0x023A6AF4).s
#define DPLCF /*ClientFx.fxd*/XorStr<0x7F,13,0x52C2A048>("\x3C\xEC\xE8\xE7\xED\xF0\xC3\xFE\xA9\xEE\xF1\xEE"+0x52C2A048).s
#define DPCFexe /*crossfire.exe*/XorStr<0x63,14,0x09C5EFE1>("\x00\x16\x0A\x15\x14\x0E\x00\x18\x0E\x42\x08\x16\x0A"+0x09C5EFE1).s
//#define eMsg1 /*I2-Dev / I2espect@Mpgh.net*/XorStr<0x19,27,0xF4CB3860>("\x50\x28\x36\x58\x78\x68\x3F\x0F\x01\x6B\x11\x41\x56\x56\x42\x4B\x5D\x6A\x66\x5C\x4A\x46\x01\x5E\x54\x46"+0xF4CB3860).s
#define eMsg2 /*Working..*/XorStr<0x97,10,0xA8874BB3>("\xC0\xF7\xEB\xF1\xF2\xF2\xFA\xB0\xB1"+0xA8874BB3).s
#define eMsg1 /*I2-Devlopment Cf Project*/XorStr<0x79,25,0x1DD0351C>("\x30\x48\x56\x38\x18\x08\x13\xEF\xF1\xEF\xE6\xEA\xF1\xA6\xC4\xEE\xA9\xDA\xF9\xE3\xE7\xEB\xEC\xE4"+0x1DD0351C).s
//=== Public Values ===
DWORD CShell = (DWORD)GetModuleHandleA(DPLCS);
DWORD ClientFx = (DWORD)GetModuleHandleA(DPLCF);
DWORD Cfexe = (DWORD)GetModuleHandleA(DPCFexe);
void MemoryNormal();
int SpecialLogCounter = 1;
//
string OUTPUT3("C:\OUTPUT.txt");
ofstream OUTPUT(OUTPUT3.c_str());
string Addy("C:\(U)AddyLogger.txt");
ofstream AddyLogger(Addy.c_str());
string Weap("C:\(U)WeaponsLogger.txt");
ofstream WeapLogger(Weap.c_str());
string SpecLog("C:\(U)SpecialLog.txt");
ofstream SpecialLog(SpecLog.c_str());
string MapLo("C:\(U)MapLog.txt");
ofstream MapLog(MapLo.c_str());
string CharactersL("C:\(U)Characters[NORMAL].txt");
ofstream CharactersLog(CharactersL.c_str());
string CharactersA("C:\(U)Characters[Advanced].txt");
ofstream CharactersAdvLog(CharactersA.c_str());
string FullWeaponLogL("C:\(U)FullWeaponLog.txt");
ofstream FullWeaponLog(FullWeaponLogL.c_str());
string NanoCharactersL("C:\(U)NanoCharactersLog.txt");
ofstream NanoCharactersLog(NanoCharactersL.c_str());
void LogMaps(){
	MapLog << "########################################"  << endl;
	MapLog << "## I2esp ##### Map Data Log ##### ect ##"  << endl;
	MapLog << "########################################"  << endl << endl;
	DWORD pMapMgr=(*(DWORD*)(CShell + MapMgr));
	for(int i=0;i<=110;i++){
		CFMap* map = (CFMap*)(pMapMgr + (0x818*i));
		  if(map!=NULL){
		 MapLog << "################# " << i << " ####################" << endl;
		 MapLog << map->MapName<<endl<<"Index: "<< map->MapIndex<<endl;
		 MapLog <<"FileName: "<<map->MapFileName<<endl;
		 MapLog <<"MapRule: "<<map->MapRuleType<<endl;
		 MapLog <<"Environment: "<<(int)map->Environment<<endl;
		 MapLog <<"SpotWeaponType: "<<(int)map->SpotWeaponType<<endl;
		 MapLog <<"Gravity: "<<map->GravityAccel<<endl;
		 MapLog <<"MapRuleSubType: "<<map->MapRuleSubType<<endl;
		 MapLog <<"UsableBag: "<<(int)map->UsableBag<<endl;
		 MapLog <<"Bag1: "<<(int)map->UseWeapons[0]<<endl;
		 MapLog <<"Bag2: "<<(int)map->UseWeapons[1]<<endl;
		 MapLog <<"Bag3: "<<(int)map->UseWeapons[2]<<endl;
		 MapLog <<"Bag4: "<<(int)map->UseWeapons[3]<<endl;
		 MapLog << "########################################" << endl << endl;
		 		  }
			  }
	MapLog.close();
}
void LogChars(){
	DWORD pMapMgr=(*(DWORD*)(CShell + CharacterMgr));
	CharactersLog<< "########################################"  << endl;
	CharactersLog<< "#### I2esp ## CharacterData ##### ect ##"  << endl;
	CharactersLog<< "########################################"  << endl << endl;
	for(int i=0;i<=50;i++){
		Character* CharacterD = (Character*)(pMapMgr + (0x3F4*i));
		  if(CharacterD!=NULL){
		 CharactersLog << "######################" << i << "##################" << endl;
		 CharactersLog <<"Character Name : [" << CharacterD->CharName <<"]" <<endl;
		 CharactersLog <<"Index: "<<CharacterD->CharacterIndex<<endl;
		 CharactersLog <<"HeadType : "<<CharacterD->HeadType<<endl;
		 CharactersLog <<"Uniform: "<<CharacterD->UniformItemType<<endl;
		 CharactersLog <<"Target: "<<(int)CharacterD->TargetTeamIndex<<endl;
		 CharactersLog <<"Special Item Type: "<<(int)CharacterD->SpecialItemType<<endl;
		 CharactersLog << "ModelFileName :" << CharacterD->ModelFileName<< endl;
		 CharactersLog << "ChildModel : " << CharacterD->ChildModelFileName<< endl;
		 CharactersLog << "SkinFile : " << CharacterD->SkinFileName << endl;
		 CharactersLog << "########################################" << endl << endl;
		 		}
			  }
	CharactersLog<< "########################################" << endl ;
	CharactersLog<< "########################################" << endl << endl;
	CharactersLog.close();
}
void LogCharsV(){
	DWORD pCharacterViewMgr=(*(DWORD*)(CShell + CharacterViewMgr));
	CharactersAdvLog<< "########################################" << endl ;
	CharactersAdvLog<< "####### CharacterData [Advanced] #######" << endl ;
	CharactersAdvLog<< "########################################" << endl << endl ;
	for(int i=0;i<=60;i++){
		cCharacter* Character = (cCharacter*)(pCharacterViewMgr + (0x958*i));
		  if(Character!=NULL){
			  CharactersAdvLog << "############## " << i << " ##############" << endl;
			  CharactersAdvLog << "CharacterType " << Character->CharacterType << endl;
			  CharactersAdvLog << "CharacterRealType " << Character->RealCharacterType << endl;
			  CharactersAdvLog << "GR Model " << Character->GRModelName << endl;
			  CharactersAdvLog << "BL Model " << Character->BLModelName << endl;
			  CharactersAdvLog << "GR Model " << Character->GRModelName2 << endl;
			  CharactersAdvLog << "BL Model " << Character->BLModelName2 << endl;
			  CharactersAdvLog << "GR Txture File " << Character->GRTextureFile << endl;
			  CharactersAdvLog << "BL Txture File " << Character->BLTextureFile << endl;
			  CharactersAdvLog << "Child Model " << Character->ChildModelFile << endl;
			  CharactersAdvLog << "RenderStyle " << Character->RenderStyle << endl;
			  CharactersAdvLog << "GR PV Arm Txture " << Character->GRPvArmTxtFile << endl;
			  CharactersAdvLog << "BL PV Arm Txture " << Character->BLPvArmTxtFile << endl;
			  CharactersAdvLog << "GR PV Hand Txture " << Character->GRPvHandTxtFile << endl;
			  CharactersAdvLog << "BL PV Hand Txture " << Character->BLPvHandTxtFile << endl;
			  CharactersAdvLog << "Item Name " << Character->ItemName << endl;
			  CharactersAdvLog << "Item ID " << Character->ItemID << endl;
			  CharactersAdvLog << "Item Code " << Character->ItemCode << endl;
			  CharactersAdvLog << "ButeType " << Character->ButeType << endl;
			  CharactersAdvLog << "ButePath " << Character->ButePath << endl;
			  CharactersAdvLog << "XLSMsgIndex " << Character->XLSMsgIndex << endl;
			  CharactersAdvLog << "IsWoman " << Character->IsWoman << endl;
			  CharactersAdvLog << "HUDEffectPath " << Character->HUDEffectPath << endl;
			  CharactersAdvLog << "HUDLinePath " << Character->HUDLinePath << endl;
			  CharactersAdvLog << "Resource Name " << Character->ResourceName << endl;
			  CharactersAdvLog << "ClientBasicPlayerInfoButeType " << Character->CPBIBUTE << endl;
			  CharactersAdvLog << "WearStateDress " << Character->WearStateDress << endl;
			  CharactersAdvLog << "#########################################" << endl << endl;
		 		  }
			  }
	CharactersAdvLog<< "########################################" << endl;
	CharactersAdvLog<< "########################################" << endl << endl;
	CharactersAdvLog.close();
}
void LogFullWeapons(){
	FullWeaponLog << "########################################" << endl ;
	FullWeaponLog << "## I2esp ##### Weapons Data ##### ect ##"  << endl;
	FullWeaponLog << "########################################" << endl << endl ;
	DWORD pWeaponMgr = *(DWORD*)(CShell +  WeaponMgr);
		if(	pWeaponMgr != NULL){
	for(int i = 0; i<= 1250; i ++){
		DWORD WeaponDWORD = (*(DWORD*)( pWeaponMgr + (4*i)) );			
	if(WeaponDWORD != NULL){
		cWeapon* Weapon = (cWeapon*)(*(DWORD*)( pWeaponMgr + (4*i)) );	
		if(strlen(Weapon->Name)>2){
	FullWeaponLog << "############## " << i << " ##############" << endl;
	FullWeaponLog << " Weapon Id : " << i << endl;
	FullWeaponLog << " Weapon Class : " << Weapon->Class << endl;
	FullWeaponLog << " Weapon Name : " << Weapon->Name << endl;
	FullWeaponLog << " Weapon Range : " << Weapon->Range << endl;
	FullWeaponLog << " Weapon AIModeRange : " << Weapon->AIModeRange << endl;
	FullWeaponLog << " Weapon Damage : " << Weapon->AmmoDmg << endl;
	FullWeaponLog << " Weapon AIModeDmg : " << Weapon->AIModeDmg << endl;
	FullWeaponLog << " Weapon MaxAmmo : " << Weapon->MaxAmmo << endl;
	FullWeaponLog << " Weapon AmmoPerMagazine : " << Weapon->AmmoPerMagazine << endl;
	FullWeaponLog << " Weapon ModelFileName : " << Weapon->ModelFileName << endl;
	FullWeaponLog << " Weapon SkinFileName : " << Weapon->SkinFileName << endl;
	FullWeaponLog << " Weapon RenderStyleFileName : " << Weapon->RenderStyleFileName << endl;
	FullWeaponLog << " Weapon NanoMaxAmmo : " << Weapon->NanoMaxAmmo << endl;
	FullWeaponLog << " Weapon NanoAmmoPerMagazine : " << Weapon->NanoAmmoPerMagazine << endl;
	FullWeaponLog << " Weapon GViewAnimName : " << Weapon->GViewAnimName << endl;
	FullWeaponLog << " Weapon GVModelScale : " << Weapon->GVModelScale << endl;
	FullWeaponLog << " Weapon ReloadSoundName : " << Weapon->ReloadSoundName << endl;
	FullWeaponLog << " Weapon SubExplosionSoundName : " << Weapon->SubExplosionSoundName << endl;
	FullWeaponLog << " Weapon DmgFactorByDistance : " << Weapon->DmgFactorByDistance << endl;
	FullWeaponLog << " Weapon AIDmgFactorByDistance : " << Weapon->AIDmgFactorByDistance << endl;
	FullWeaponLog << " Weapon DmgVariantionFactor : " << Weapon->DmgVariantionFactor << endl;
	FullWeaponLog << " Weapon ShotsPerAmmo : " << Weapon->ShotsPerAmmo << endl;
	FullWeaponLog << " Weapon WeaponPrice : " << Weapon->WeaponPrice << endl;
	FullWeaponLog << " Weapon AmmoPrice : " << Weapon->AmmoPrice << endl;
	FullWeaponLog << " Weapon ReloadSingleAmmo : " << Weapon->ReloadSingleAmmo << endl;
	FullWeaponLog << " Weapon BoomDuration : " << Weapon->BoomDuration << endl;
	FullWeaponLog << "[+] Weapon Attribute : " << endl;
	FullWeaponLog << " Weapon LeftClickAttribute : " << Weapon->LeftClickAttribute << endl;
	FullWeaponLog << " Weapon RightClickAttribute : " << Weapon->RightClickAttribute << endl;
	FullWeaponLog << " Weapon ZoomAttribute : " << Weapon->ZoomAttribute << endl;
	FullWeaponLog << " Weapon ReloadAttributes : " << Weapon->ReloadAttributes << endl;
	FullWeaponLog << " Weapon KnifeLeftClickAttribute : " << Weapon->KnifeLeftClickAttribute << endl;
	FullWeaponLog << " Weapon KnifeRightClickAttribute : " << Weapon->KnifeRightClickAttribute << endl;
	FullWeaponLog << " Weapon IsDroopedWhenDie : " << Weapon->IsDroopedWhenDie << endl;
	FullWeaponLog << " Weapon DependentRoundType : " << Weapon->DependentRoundType << endl;
	FullWeaponLog << " Weapon StunTime : " << Weapon->StunTime << endl;
	FullWeaponLog << " Weapon SubWeaponIndex : " << Weapon->SubWeaponIndex << endl;
	FullWeaponLog << " Weapon MoveSpeedPenalty : " << Weapon->MoveSpeedPenalty << endl;
	FullWeaponLog << " Weapon ReloadAnimRatio : " << Weapon->ReloadAnimRatio << endl;
	FullWeaponLog << " Weapon ChangeWeaponAnimRatio : " << Weapon->ChangeWeaponAnimRatio << endl;
	FullWeaponLog << " Weapon GrenadeBelowTime : " << Weapon->GrenadeBelowTime << endl;
	FullWeaponLog << " Weapon BoomType : " << Weapon->BoomType << endl;
	FullWeaponLog << " Weapon BoomDurationDmg : " << Weapon->BoomDurationDmg << endl;
	FullWeaponLog << " Weapon NanoGhostDmgPenalty : " << Weapon->NanoGhostDmgPenalty << endl;
	FullWeaponLog << " Weapon NanoGhostDmgTime : " << Weapon->NanoGhostDmgTime << endl;
	FullWeaponLog << " Weapon ContinuousShotKeyInterval : " << Weapon->ContinuousShotKeyInterval << endl;
	FullWeaponLog << " Weapon HaveKnife : " << Weapon->HaveKnife << endl;
	FullWeaponLog << " Weapon KnifeAnim : " << Weapon->KnifeAnim << endl;
	FullWeaponLog << " Weapon KnfeAtkSoundName : " << Weapon->KnfeAtkSoundName << endl;
	FullWeaponLog << " Weapon GunKnifeRange : " << Weapon->GunKnifeRange << endl;
	FullWeaponLog << " Weapon NanoGhostDmgTime : " << Weapon->GunKnifeAmmoDmg << endl;
	FullWeaponLog << "[+] PvEffect : " << endl;
	FullWeaponLog << " Weapon PVEffectName : [" << Weapon->PVEffectName << "],[" << Weapon->PVEffectName2 << "]" << endl;
	FullWeaponLog << "[+] New Offsets : " << endl;
	FullWeaponLog << " Weapon IsGunKnifeJitter : " << Weapon->IsGunKnifeJitter << endl;
	FullWeaponLog << " Weapon CrosshairRadius : " << Weapon->CrosshairRadius << endl;
	FullWeaponLog << " Weapon LeverAction : " << Weapon->LeverAction << endl;
	FullWeaponLog << "[+] Added : " << endl;
	FullWeaponLog << " Weapon UnlimitedAmmo : " << Weapon->UnlimitedAmmo << endl;
	FullWeaponLog << " Weapon TargetSlot : " << Weapon->TargetSlot << endl;
	FullWeaponLog << " Weapon LeftHandModeFileName : " << Weapon->LeftHandModeFileName << endl;
	FullWeaponLog << " Weapon WLeftHandModeFileName : " << Weapon->WLeftHandModeFileName << endl;
	FullWeaponLog << " Weapon PViewModelFileName : " << Weapon->PViewModelFileName << endl;
	FullWeaponLog << " Weapon PViewSkinFileName : " << Weapon->PViewSkinFileName << endl;
	FullWeaponLog << " Weapon PViewRenderStyleFileName : " << Weapon->PViewRenderStyleFileName << endl;
	FullWeaponLog << " Weapon TempPVModel1 : " << Weapon->TempPVModel1 << endl;
	FullWeaponLog << " Weapon TempPVSkin1 : " << Weapon->TempPVSkin1 << endl;
	FullWeaponLog << " Weapon ShotSoundName : " << Weapon->ShotSoundName << endl;
	FullWeaponLog << " Weapon MagazineClipInSoundName : " << Weapon->MagazineClipInSoundName << endl;
	FullWeaponLog << " Weapon BlowBackSoundName : " << Weapon->BlowBackSoundName << endl;
	FullWeaponLog << " Weapon DelBlowSoundName : " << Weapon->DelBlowSoundName << endl;
	FullWeaponLog << " Weapon Extra01SoundName : " << Weapon->Extra01SoundName << endl;
	FullWeaponLog << " Weapon Extra02SoundName : " << Weapon->Extra02SoundName << endl;
	FullWeaponLog << " Weapon ShotSoundStartName : " << Weapon->ShotSoundStartName << endl;
	FullWeaponLog << " Weapon BigIconName : " << Weapon->BigIconName << endl;
	FullWeaponLog << " Weapon SmallIconName : " << Weapon->SmallIconName << endl;
	FullWeaponLog << " Weapon EffectSubName : " << Weapon->EffectSubName << endl;
	FullWeaponLog << " Weapon SpecularMapName1 : " << Weapon->SpecularMapName1 << endl;
	FullWeaponLog << " Weapon SpecularMapName2 : " << Weapon->SpecularMapName2 << endl;
	FullWeaponLog << " Weapon SpecularPower : " << Weapon->SpecularPower << endl;
	FullWeaponLog << " Weapon ReflectionName : " << Weapon->ReflectionName << endl;
	FullWeaponLog << " Weapon ReflectionValue : " << Weapon->ReflectionValue << endl;
	FullWeaponLog << " Weapon FakeSpecularFalloff : " << Weapon->FakeSpecularFalloff << endl;
	FullWeaponLog << " Weapon LightCorrectionLegacyShader : " << Weapon->LightCorrectionLegacyShader << endl;
	FullWeaponLog << " Weapon ForceNoLegacyShaderAlpha : " << Weapon->ForceNoLegacyShaderAlpha << endl;
	FullWeaponLog << " Weapon GViewKnifeAttackAnimName : " << Weapon->WallShotDmgRatio[0] << ", " << Weapon->WallShotDmgRatio[1] 
	<< ", " << Weapon->WallShotDmgRatio[2] << ", " << Weapon->WallShotDmgRatio[3]
	<< ", " << Weapon->WallShotDmgRatio[4] << ", " << Weapon->WallShotDmgRatio[5] 
	<< ", " << Weapon->WallShotDmgRatio[6] << ", " <<Weapon->WallShotDmgRatio[7]
	<< ", " << Weapon->WallShotDmgRatio[8] << ", " <<Weapon->WallShotDmgRatio[9]
	<< ", " << Weapon->WallShotDmgRatio[10] << ", " <<Weapon->WallShotDmgRatio[11]
	<< ", " << Weapon->WallShotDmgRatio[12] << ", " << Weapon->WallShotDmgRatio[13] << endl;
	//FullWeaponLog << " Weapon GViewKnifeAttackAnimName : " << Weapon->GViewKnifeAttackAnimName << endl;
	FullWeaponLog << "###############################" << endl << endl;
						}
					}
				}
			}
	FullWeaponLog << "########################################" << endl;
	FullWeaponLog << "########################################" << endl;
	FullWeaponLog.close();
}
void LogNanoCharacter(){
	NanoCharactersLog << "########################################" << endl ;
	NanoCharactersLog << "## I2esp #### NanoCharacter ##### ect ##"  << endl;
	NanoCharactersLog << "########################################" << endl << endl ;
	DWORD pNanoMgr = *(DWORD*)(CShell +  NanoCharMgr);
		if(	pNanoMgr != NULL){
	for(int i=0;i<=55;i++){
		NanoCharacter* NanoCharacterClass = (NanoCharacter*)(pNanoMgr + (0x0598*i));
		  if(NanoCharacterClass !=NULL){
		NanoCharactersLog << "######################" << i << "##################" << endl;
		NanoCharactersLog <<"Type : " << NanoCharacterClass->NanoType <<endl;
		NanoCharactersLog <<"NanoAbility : " << NanoCharacterClass->NanoAbility <<endl;
		NanoCharactersLog <<"NanoAddHp : " << NanoCharacterClass->NanoAddHp <<endl;
		NanoCharactersLog <<"ModelFileName : " << NanoCharacterClass->ModelFileName <<endl;
		NanoCharactersLog <<"NanoDefaultWepIndex : " << NanoCharacterClass->NanoDefaultWepIndex <<endl;
		NanoCharactersLog <<"NanoDefaultWepInvisible : " << NanoCharacterClass->NanoDefaultWepInvisible <<endl;
		NanoCharactersLog <<"NanoSpecialWepIndex : " << NanoCharacterClass->NanoSpecialWepIndex <<endl;
		NanoCharactersLog <<"NanoSpecialWepInvisible : " << NanoCharacterClass->NanoSpecialWepInvisible <<endl;
		NanoCharactersLog <<"NanoSkillWepIndex : " << NanoCharacterClass->NanoSkillWepIndex <<endl;
		NanoCharactersLog <<"NextLevelNanoType : " << NanoCharacterClass->NextLevelNanoType <<endl;
				}
			}
		}
		NanoCharactersLog.close();
}
//=== FunctionsProtype ===
typedef void ( __thiscall *lpDrawEngineString ) ( unsigned long ulFontBase, char* szString, int xCoord, int yCoord, unsigned long clColor, bool bShadow, bool bUnderline, bool bUnk);
lpDrawEngineString DrawEngineString;
#define DrawEngineString_Call 0x377020
#define DrawEngineString_ulBase 0x10CCF80
//=== Defines === Useless As I Check The Weapon Class !!
#define Rifle (i==11 || i==12 || i==13 || i==22 || i==24 || i==25 || i==27 || i==29 || i==30 || i==31 || i==34 || i==38 || i==40 || i==41 || i==42 || i==45 || i==47 || i==49 || i==50 || i==56 || i==72 || i==73 || i==76 || i==77 || i==85 || i==87 || i==88 || i==90 || i==94 || i==95 || i==96 || i==97 || i==98 || i==103 || i==104 || i==106 || i==113 || i==121 || i==127 || i==133 || i==140 || i==141 || i==160 || i==161 || i==164 || i==167 || i==174 || i==175 || i==179 || i==187 || i==190 || i==201 || i==203 || i==206 || i==208 || i==212 || i==221 || i==222 || i==230 || i==233 || i==234 || i==236 || i==237 || i==280 || i==291 || i==333 || i==340 || i==341 || i==349 || i==351 || i==364 || i==365 || i==366 || i==367 || i==374 || i==377 || i==390 || i==391 || i==403 || i==415 || i==418 || i==421 || i==429 || i==431 || i==436 || i==440 || i==444 || i==462 || i==471 || i==479 || i==484 || i==486 || i==499 || i==502 || i==503 || i==509 || i==510 || i==511 || i==512 || i==526 || i==532 || i==536 || i==538 || i==539 || i==542 || i==559 || i==573 || i==591 || i==597 || i==598 || i==619 || i==622 || i==623 || i==628 || i==629 || i==630 || i==636 || i==652 || i==656 || i==664 || i==667 || i==676 || i==678 || i==679 || i==682 || i==683 || i==687 || i==688 || i==691 || i==712 || i==713 || i==723 || i==726 || i==727 || i==730 || i==731 || i==734 || i==735 || i==737 || i==742 || i==750 || i==751 || i==754 || i==755 || i==763 || i==765 || i==769 || i==790 || i==791 || i==820 || i==850 || i==868 || i==913 || i==914 || i==915 || i==916)
#define Sniper (i==14 || i==15 || i==16 || i==23 || i==43 || i==46 || i==91 || i==110 || i==111 || i==122 || i==136 || i==150 || i==152 || i==163 || i==185 || i==186 || i==194 || i==232 || i==249 || i==268 || i==279 || i==294 || i==323 || i==358 || i==368 || i==378 || i==380 || i==461 || i==500 || i==513 || i==525 || i==554 || i==602 || i==625 || i==632 || i==657 || i==714 || i==724 || i==746 || i==807 || i==812 || i==814 || i==827 || i==917)
#define Knife (i==5 || i==35 || i==74 || i==120 || i==132 || i==176 || i==177 || i==178 || i==182 || i==189 || i==195 || i==196 || i==197 || i==198 || i==199 || i==223 || i==224 || i==225 || i==226 || i==227 || i==228 || i==239 || i==244 || i==261 || i==269 || i==270 || i==271 || i==302 || i==303 || i==304 || i==305 || i==306 || i==307 || i==345 || i==346 || i==372 || i==376 || i==381 || i==404 || i==405 || i==406 || i==407 || i==408 || i==409 || i==417 || i==437 || i==455 || i==456 || i==457 || i==488 || i==517 || i==518 || i==531 || i==540 || i==541 || i==548 || i==561 || i==576 || i==584 || i==587 || i==620 || i==647 || i==672 || i==673 || i==693 || i==700 || i==718 || i==719 || i==728 || i==736 || i==744 || i==760 || i==764 || i==921 || i==922)
#define Pistol (i==1 || i==4 || i==18 || i==19 || i==20 || i==26 || i==33 || i==37 || i==44 || i==60 || i==75 || i==78 || i==92 || i==105 || i==115 || i==116 || i==153 || i==155 || i==156 || i==217 || i==235 || i==241 || i==247 || i==267 || i==281 || i==283 || i==309 || i==328 || i==348 || i==350 || i==370 || i==371 || i==430 || i==439 || i==470 || i==497 || i==515 || i==516 || i==528 || i==589 || i==600 || i==626 || i==644 || i==650 || i==670 || i==684 || i==694 || i==716 || i==717 || i==725 || i==771 || i==775 || i==844 || i==847 || i==878 || i==919 || i==920)
#define Mutants ((i==120)||(i==176)||(i==177)||(i==178)||(i==182)||(i==195)||(i==196)||(i==197)||(i==198)||(i==199)||(i==223)||(i==224)||(i==225)||(i==226)||(i==227)||(i==228)||(i==270)||(i==271)||(i==302)||(i==303)||(i==304)||(i==305)||(i==306)||(i==307)||(i==404)||(i==405)||(i==406)||(i==407)||(i==408)||(i==409))
#define Hmx ((i==673) || (i==541))
#define IsSmokeGrenade(i) (i == 8 || i == 64 || i == 65 || i == 384 || i == 521 || i==925 )
#define IsFlashGrenade(i) (i == 7 || i == 383 || i == 520 || i==924 )
#define Grenade (i==6 || i==7 || i==8 || i==64 || i==65 || i==100 || i==126 || i==135 || i==200 || i==209 || i==210 || i==240 || i==262 || i==263 || i==272 || i==288 || i==313 || i==324 || i==338 || i==357 || i==382 || i==383 || i==384 || i==416 || i==423 || i==424 || i==425 || i==435 || i==438 || i==473 || i==481 || i==519 || i==520 || i==521 || i==654 || i==696 || i==698 || i==720 || i==721 || i==722 || i==729 || i==749 || i==923 || i==924 || i==925)
// Strides
#define sWeapon 36
#define sMap 24
#define sSkyWalls 28
#define sBody 44
#define sHead 40
//=== PTC ===
void __cdecl PushToConsole(CHAR* sVal ) {
	DWORD dwCShell = (DWORD)GetModuleHandleA(DPLCS);
	if( CShell != NULL )
	{
		DWORD *zAddress = (DWORD*)( CShell + PushToConsoleAddy );
		void* szConsole = (void*)*(DWORD*)( *zAddress + PTC_Addy );

		_asm
		{
			PUSH sVal
			CALL szConsole		
			ADD ESP, 0x4
		}
	}
}
//=== Ingame MSGBOX ===
void PushNMessage(const char *szMessage)
{
    typedef void(__cdecl *pGameMsgBox_t)(DWORD, DWORD, DWORD, const char*);
    pGameMsgBox_t pGameMsgBox = (pGameMsgBox_t)(MSGBOX + CShell);
     pGameMsgBox(MSGBOX_3Push, MSGBOX_2Push, MSGBOX_1Push, szMessage);
}
void PushMessage(char* Message)
{
	DWORD MessageAddress = CShell + MSGBOX;
	__asm
	{
		PUSH Message;
		PUSH 0;
		PUSH 0;
		PUSH 0;
		call MessageAddress;
		add esp, MSGBOX_Add;
	}
}
//=== Zoom Adder ===
void Zoom(int weaponid){
				DWORD pWeaponMgr = *(DWORD*)(CShell +  WeaponMgr);
	if(	pWeaponMgr != NULL){
	DWORD Weapon = (*(DWORD*)( pWeaponMgr + (4*weaponid)) );			
		if(Weapon != NULL){
							*(int*)(Weapon + RightClickAttribute) = 0x2;
							*(int*)(Weapon + ZoomAttribute) = 0x10;
                            *(int*)(Weapon + (ZoomStage)) = 2; // Amount Of Scope Lvl(s)
                            *(float*)(Weapon + (ZoomStage + 4)) = 500.0f;
                            *(float*)(Weapon + (ZoomStage + 8)) = 500.0f;
							*(float*)(Weapon + ZoomAction + 0*4) = 1; // Normal x1
							*(float*)(Weapon + ZoomAction + 1*4) = 2;
		}
	}
}
//=== Weapon Changer [NO ERROR] ===
void ChangeWeaponP(int weaponid, int targetid){
	DWORD pWeaponMgr = *(DWORD*)(CShell +  WeaponMgr);
	if(	pWeaponMgr != NULL){
	for(int i=5000; i<=12000; i++)
	{
    DWORD wWeapon =  *(DWORD*)((*(DWORD*)(CShell+WeaponMgr))+(4*weaponid)); // Knife
    DWORD wTarget = *(DWORD*)((*(DWORD*)(CShell+WeaponMgr))+(4*targetid));
    *(DWORD*)(wWeapon + i) = *(DWORD*)(wTarget + i); 
	}
	}
}
//=== Weapon Changer [FullCHANGER] ===
void ChangeWeaponF(int weaponid, int targetid){
		DWORD pWeaponMgr = *(DWORD*)(CShell +  WeaponMgr);
	if(	pWeaponMgr != NULL){
		DWORD* weapon = (DWORD*)((*(DWORD*)(CShell + WeaponMgr )) + weaponid*4);// melee
				DWORD* target = (DWORD*)((*(DWORD*)(CShell + WeaponMgr )) + targetid*4);	
				*weapon = *target;
	}
}
//=== CharacterChange ===
void CharacterChange(int cid, int targetid){
	DWORD pCharacterViewMgr=(*(DWORD*)(CShell + CharacterViewMgr));
	memcpy((void*)(pCharacterViewMgr + (0x958*cid) + 0x4),(void*)(pCharacterViewMgr + (0x958*targetid) + 0x4),0x603);
	 cCharacter* Character = (cCharacter*)(pCharacterViewMgr + (0x958*cid));
	 cCharacter* Character2 = (cCharacter*)(pCharacterViewMgr + (0x958*targetid));
	 memcpy((Character->HUDEffectPath),(Character->HUDEffectPath), 256);
	 memcpy((Character->HUDLinePath),(Character->HUDLinePath), 256);
}
void NanoCharacterChange(int cid, int targetid){
	DWORD pNanoCharacterMgr=(*(DWORD*)(CShell + NanoCharMgr));
	memcpy((void*)(pNanoCharacterMgr + (0x0598*cid) + 0x4),(void*)(pNanoCharacterMgr + (0x0598*targetid) + 0x4),0x0598-0x4);
}
void CharacterChangeF(int cid, int targetid, int targetid2){// 1 UNSF , 2 GSG9
	DWORD pCharacterViewMgr=(*(DWORD*)(CShell + CharacterViewMgr));
	//memcpy((void*)(pCharacterViewMgr + (0x958*cid) + 0x4),(void*)(pCharacterViewMgr + (0x958*targetid) + 0x4),0x603);
	 cCharacter* Character = (cCharacter*)(pCharacterViewMgr + (0x958*cid));
	 cCharacter* Character2 = (cCharacter*)(pCharacterViewMgr + (0x958*targetid));
	 cCharacter* Character3 = (cCharacter*)(pCharacterViewMgr + (0x958*targetid2));

	 memcpy((Character->GRModelName),(Character2->GRModelName), 81);
	 memcpy((Character->BLModelName),(Character3->BLModelName), 81);

	 memcpy((Character->GRTextureFile),(Character2->GRTextureFile), 81);
	 memcpy((Character->BLTextureFile),(Character3->BLTextureFile), 81);

	 memcpy((Character->GRPvArmTxtFile),(Character2->GRPvArmTxtFile), 81);
	 memcpy((Character->BLPvArmTxtFile),(Character3->BLPvArmTxtFile), 81);

	 memcpy((Character->GRPvHandTxtFile),(Character2->GRPvHandTxtFile), 81);
	 memcpy((Character->BLPvHandTxtFile),(Character3->BLPvHandTxtFile), 81);

	 memcpy((Character->HUDEffectPath),(Character2->HUDEffectPath), 256);
	 memcpy((Character->HUDLinePath),(Character2->HUDLinePath), 256);
}
void Chams(){
	DWORD pWeaponMgr = *(DWORD*)(CShell +  WeaponMgr);
	cWeapon* RedCrystal = (cWeapon*)(*(DWORD*)( pWeaponMgr + (4*868)) );
	DWORD pCharacterViewMgr=(*(DWORD*)(CShell + CharacterViewMgr));
	for(int i= 1 ; i <20; i++){
	cCharacter* Character = (cCharacter*)(pCharacterViewMgr + (0x958*i));
	memcpy((Character->BLTextureFile),"ModelTextures/PlayerView/pv-AWM-Blue Crystal.dtx", 81);
	memcpy((Character->GRTextureFile),"ModelTextures/PlayerView/pv-AWM-Blue Crystal.dtx", 81);
	}
}
//=== BackupMemory ===
float BUMovementWalkRate;
float BUMoveSpeedPenalty[1000];
float BUChangeWeaponAnimRatio[1000];
void BackupMemory(){
	// BPlayerInfo
	DWORD pBPLayerInfo = *(DWORD*)(CShell +  BPlayerInfo);
	sBasicPlayerInfo* BasicPlayerInfoC = (sBasicPlayerInfo*)pBPLayerInfo;
	BUMovementWalkRate = BasicPlayerInfoC->MovementWalkRate;
	// Weapons
	DWORD pWeaponMgr = *(DWORD*)(CShell +  WeaponMgr);
		if(	pWeaponMgr != NULL){
			for(int i=0; i<925; i++){
				DWORD Weapon = (*(DWORD*)( pWeaponMgr + (4*i)) );
				cWeapon* WeaponClass = (cWeapon*)(*(DWORD*)( pWeaponMgr + (4*i)) );
					if(Weapon != NULL){
						BUMoveSpeedPenalty[i] = WeaponClass->MoveSpeedPenalty;
						BUChangeWeaponAnimRatio[i] = WeaponClass->ChangeWeaponAnimRatio;
			}
		}
	}
}
//=== Hook ===
DWORD retMyDIP;
void D3Dfunktionen (LPDIRECT3DDEVICE9 pDevice)
{
	IDirect3DVertexBuffer9* pStreamData = NULL; 
	UINT iOffsetInBytes,iStride;  
	pDevice->GetStreamSource(0,&pStreamData,&iOffsetInBytes,&iStride); 

	if(iStride == sBody || iStride == sHead || iStride == sWeapon)
	{
		pDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);//WallHack
	}
}
__declspec(naked) HRESULT WINAPI MyDIP()
{
	static LPDIRECT3DDEVICE9 pDevice;

	__asm
	{
		MOV EDI,EDI
		PUSH EBP
		MOV EBP,ESP
		MOV EAX,DWORD PTR SS:[EBP + 0x8]
		MOV pDevice,EAX
	}
	D3Dfunktionen(pDevice);
	__asm
	{
		JMP retMyDIP
	}
}
void Hook ()
{
	DWORD hD3D = (DWORD)GetModuleHandleA(DPD3D);
	if(hD3D){
	DWORD *vtbl;

	DWORD adr = FindPattern(hD3D, 0x128000, (PBYTE)"\xC7\x06\x00\x00\x00\x00\x89\x86\x00\x00\x00\x00\x89\x86", "xx????xx????xx");
	if(adr)
	{
		memcpy(&vtbl,(void*)(adr + 2),4);
		retMyDIP = vtbl[82] + 0x5;
		MakeCall((PBYTE)vtbl[82],(DWORD)MyDIP,0x5);
	}
	}
}
//=== Memory 1 Time Change ===
void MemoryNormal(){

	// CfexeMgrNano
	/*DWORD NanoCfexe = *(DWORD*)(0x68F608);
	CfexeNano* Class = (CfexeNano*)(NanoCfexe + (0x54*0));
	SpecialLog << "STARTED" << endl << Class->ModeIndex << endl;
	SpecialLog << "ModeIndex2" << Class->ModeIndex2 << endl;
	SpecialLog << "DamagePerPoint" << Class->DamagePerPoint << endl;
	SpecialLog << "HeroCharacterType" << Class->HeroCharacterType << endl;
	SpecialLog << "HeroWeaponIndex" << Class->HeroWeaponIndex << endl;
	SpecialLog << Class->KillPointOfInfectHero << endl;
	CfexeNano* Class2 = (CfexeNano*)(NanoCfexe + (0x54*2));
	SpecialLog << "ModeIndex" << Class2->ModeIndex << endl;
	SpecialLog << "ModeIndex2" << Class2->ModeIndex2 << endl;
	SpecialLog << "DamagePerPoint" << Class2->DamagePerPoint << endl;
	SpecialLog << "HeroCharacterType" << Class2->HeroCharacterType << endl;
	SpecialLog << "HeroWeaponIndex" << Class2->HeroWeaponIndex << endl;
	SpecialLog << "KillPointOfInfectHero" << Class2->KillPointOfInfectHero << endl;*/

	/*if(SeeGhostsMem){
		*(DWORD *)(MemCGhosts) = 14;
		}// End WallHack*/

	// BasicPlayerInfo
	DWORD pBPLayerInfo = *(DWORD*)(CShell +  BPlayerInfo);
	sBasicPlayerInfo* BasicPlayerInfoC = (sBasicPlayerInfo*)pBPLayerInfo;
	if(	pBPLayerInfo != NULL){
		if(DescreaseIncomeDmg){
					
			}// DescreaseInComeDmg
		if(InstantDefuseC4){
			BasicPlayerInfoC->C4DefuseTime = 1.0f;
			}// InstantDefuseC4
		}// End BasicPlayerInfo

	// MapMgr
	DWORD pMapMgr=(*(DWORD*)(CShell + MapMgr));
	if(TuroialMapCH){
	CFMap* map = (CFMap*)(pMapMgr + (0x818*18));
	memcpy((void*)(pMapMgr + (0x818*18)+0x22),(void*)(pMapMgr + (0x818*66)+0x22),0x818-0x22);//change training magazine room to random
	map->MapRuleType=14;
	}// Tutorail Map Changer

	// CharacterMgr
	 DWORD pCharacterMgr=(*(DWORD*)(CShell + CharacterMgr));

	 // CharacterViewMgr
	 DWORD pCharacterViewMgr=(*(DWORD*)(CShell + CharacterViewMgr));	 
	 if(CharacterCh){
	 CharacterChangeF(1, 13, 5);
	 }
	 if(SeeGhosts){
	 CharacterChange(11, 1);
	 CharacterChange(12, 1);
	 }
	 if(i2_Character){
	 cCharacter* Character = (cCharacter*)(pCharacterViewMgr + (0x958*1));
	 cCharacter* Unsf = (cCharacter*)(pCharacterViewMgr + (0x958*19));
	 cCharacter* Gsg9 = (cCharacter*)(pCharacterViewMgr + (0x958*5));

	 memcpy((Character->GRModelName),(Gsg9->BLModelName), 81);
	 memcpy((Character->BLModelName),(Gsg9->BLModelName), 81);
	 memcpy((Character->GRTextureFile),(Gsg9->BLTextureFile), 81);
	 memcpy((Character->BLTextureFile),"ModelTextures/PlayerView/pv-AWM-Blue Crystal.dtx", 81);

	 memcpy((Character->GRPvArmTxtFile),(Unsf->GRPvArmTxtFile), 81);
	 memcpy((Character->BLPvArmTxtFile),(Gsg9->BLPvArmTxtFile), 81);
	 memcpy((Character->GRPvHandTxtFile),(Unsf->GRPvHandTxtFile), 81);
	 memcpy((Character->BLPvHandTxtFile),(Unsf->GRPvHandTxtFile), 81);

	 memcpy((Character->HUDEffectPath),(Unsf->HUDEffectPath), 256);
	 memcpy((Character->HUDLinePath),(Unsf->HUDLinePath), 256);
	 }
	 if(i2_chams){
	 Chams();
	 }
	 for(int id=1; id<20;id++){
	 cCharacter* Character = (cCharacter*)(pCharacterViewMgr + (0x958*id));
	 CharacterChange(id, 20);
	 }
	 ChangeWeaponP(11, 1023);

	 // NanoCharacterMgr
	 DWORD pNanoCharacterMgr=(*(DWORD*)(CShell + NanoCharMgr));
	 if(NanoCharacterCH){
	NanoCharacter* Havoc = (NanoCharacter*)(pCharacterViewMgr + (0x598*21));
	 for(int id=1; id<20;id++){
	 NanoCharacter* Character = (NanoCharacter*)(pCharacterViewMgr + (0x598*id));
	 if(Character){
	 NanoCharacterChange(id, 21);
	 Character->BigShotDmg = Havoc->BigShotDmg;
	 Character->NormalDmg = Havoc->NormalDmg;
	 }
		}
	 }

	// WeaponMgr
	DWORD pWeaponMgr = *(DWORD*)(CShell +  WeaponMgr);
	if(	pWeaponMgr != NULL){
		for(int i=0; i<925; i++){
			DWORD Weapon = (*(DWORD*)( pWeaponMgr + (4*i)) );
			cWeapon* WeaponClass = (cWeapon*)(*(DWORD*)( pWeaponMgr + (4*i)) );
	if(Weapon != NULL){
		if(OneHitNadeG){
			if(Grenade && !IsSmokeGrenade(i) && !IsFlashGrenade(i)){
				*(float*)(Weapon + DamageVariantionFactor)= -9999.2f;
					}
						}// One Hit Nade [Grenade]
		if(NoSmoke){
			if(WeaponClass->Class == 6){
				*(float*)(Weapon + GrenadeBelowTime)= 999999.0f;
					}
						}// No Smoke
		if(NoFlash){
			if(WeaponClass->Class == 6){
				*(float*)(Weapon + Range)= 0.0f;
					}
						}// No Flash
		if(OneHitRifle && AlwaysHeadShot){
			if(WeaponClass->Class == 3){
				for(int x=0; x < 29; x++){
							*(float*)(Weapon + DmgRatioPerNode + x*4) = 1.48f;
						}
					}
						}// One Hit Rifle
		if(OneHitSniper && AlwaysHeadShot){
			if(WeaponClass->Class == 4){
				for(int x=0; x < 29; x++){
							*(float*)(Weapon + DmgRatioPerNode + x*4) = 1.48f;
						}
					}
						}// One Hit Sniper
		if(I2espectWM){
			char I2espectTxt[9] = "I2espect";
				for(int x=0; x<9; x++){
					*(char*)(Weapon + WeaponName + x) = I2espectTxt[x];
										}
				}// I2espect WaterMark
		if(M16_OHK){
			if(i==25){
					*(float*)(Weapon + DmgFactorByDis ) = -9999.2f;
					}
				}// M16 OHK
		if(GrenadeRange){
			if(Grenade && !IsSmokeGrenade(i) && !IsFlashGrenade(i)){
				*(float*)(Weapon + Range ) = 9999.0f;
					}
				}// Grenade Range
		if(Stunner && KnockerBack){
			if(!Grenade && !IsSmokeGrenade(i) && !IsFlashGrenade(i) && !Knife){
				*(float*)(Weapon + NanoGhostDmgPenaltyTime ) = 999.0f;
				*(float*)(Weapon + NanoGhostDmgMoveRate ) = 999.0f;
					}
				}// Stunner , Knocker
		if(IronBeastTest){
			if(i==25){
				ChangeWeaponF(25, 856);
				ChangeWeaponF(5, 728);
				ChangeWeaponF(6, 262);
					}
				}// IronBeast
		if(SlugClaws){
				ChangeWeaponP(5, 345);
				SlugClaws = false;
				}// SlugClaws
		if(NewNoRecoil){
			for(int c=0;c<30;c++){
				*(float*)(Weapon + 0x3A18 + c*4) = 0.0f;
					}
				}// NewNoRecoil
		if(KnifeRedCrystal){
			cWeapon* KnifeW = (cWeapon*)(*(DWORD*)( pWeaponMgr + (4*5)) );
			cWeapon* RedCrystal = (cWeapon*)(*(DWORD*)( pWeaponMgr + (4*868)) );
			memcpy((void*)(KnifeW->SkinFileName),(void*)(RedCrystal->SkinFileName),81);
			KnifeRedCrystal = false;
					}// Knife Red Crystal
		if(Specular && Reflection){
			*(float*)(Weapon + 0x34CC)= 999.0f;
			*(float*)(Weapon + 0x3524)= 999.0f;
					}// Specular
		if(Small_CS){
			if(Small_CS && Small_CS_ID == -1){
				for(int x=0;x<5;x++){
					*(float*)(Weapon + CrossHairSize + x*4)= 0.001f;
							}
						}// AllWeapons
			if(Small_CS && Small_CS_ID == i){
				for(int x=0;x<5;x++){
					*(float*)(Weapon + CrossHairSize + x*4)= 0.001f;
							}
				Small_CS = false;
						}// 1 Weapon Only
					}// Small Crosshair
		if(Zoomer){
			if(Zoomer && Zoomer_ID == -1){
				Zoom(i);
						}// AllWeapons
			if(Zoomer && Zoomer_ID == i){
				Zoom(i);
				Zoomer = false;
						}// 1 Weapon Only
					}// Zoom Adder
		if(TrainingWeapons){
			if(i==728){
			ChangeWeaponF(25, 323);
			//ChangeWeaponF(6, 416);
			//ChangeWeaponF(5, 862);
			TrainingWeapons = false;
			}
					}// Training Weapons
		if(FastKnife){
			if(WeaponClass->Class == 7){
			WeaponClass->KnifeNormalAniRate = 1.3f;
			WeaponClass->KnifeNormalAniRate2 = 1.3f;
			WeaponClass->KnifeNormalAniRate3 = 1.3f;
				}
					}// Fast Knife
		if(NoGrenadeDmg){
			if(WeaponClass->Class == 6){
				WeaponClass->AmmoDmg = 0.0f;
				}
					}// No Grenade Damage
		if(FullWallbang){

					}// Full WallBang
		if(SnipersCS){
			if(WeaponClass->Class == 4){
				*(int*)(Weapon + ZoomAttribute) = 0x10;
					for(int x=0;x<5;x++){
					*(float*)(Weapon + 0x3B8C + x*4)= 0.001f;
							}
					for(int y=0; y<30; y++){
				*(float*)(Weapon + 0x53C + y*4)= 0.0f;
				*(float*)(Weapon + 0x6A4 + y*4)= 0.0f;
						}
					}
				} // Show Sniper Crosshair
		if(Knife_Left_Click_Speed){
			if(WeaponClass->Class == 7){
				WeaponClass->KnifeNormalAniRate *= 3.0f;
				WeaponClass->KnifeNormalAniRate2 *= 3.0f;
				WeaponClass->KnifeNormalAniRate3 *= 3.0f;
					}
				} // Knife Left Click Speed x3
		if(Knife_Right_Click_Speed){
			if(WeaponClass->Class == 7){
				WeaponClass->KnifeBigShotAniRate *= 3.0f;
				WeaponClass->KnifeBigShotAniRate2 *= 3.0f;
				WeaponClass->KnifeBigShotAniRate3 *= 3.0f;
					}
				} // Knife Right Click Speed x3
		if(Knife_Left_Click_Range){
			if(WeaponClass->Class == 7){
				WeaponClass->Range *= 2.0f;
				WeaponClass->KnifeNormalRange2 *= 2.0f;
				WeaponClass->KnifeNormalRange2_ *= 2.0f;
					}
				} // Knife Left Click Range x2
		if(Knife_Right_Click_Range){
			if(WeaponClass->Class == 7){
				WeaponClass->KnifeBigShotRange *= 2.0f;
				WeaponClass->KnifeBigShotRange2 *= 2.0f;
					}
				} // Knife Right Click Range x2
		if(M4A1VIP){
			ChangeWeaponP(11, 856);
				M4A1VIP = false;
				} // M4A1 > M4A1 Iron Beast
		if(AWMVIP){
			ChangeWeaponP(15, 812);
				AWMVIP = false;
				} // AWM > AWM Infernal Dragon
		if(RPKVIP){
			ChangeWeaponP(61, 813);
				RPKVIP = false;
				} // RPK > RPK Infernal Dragon
		if(AKVIP){
			ChangeWeaponP(12, 730);
				AKVIP = false;
				} // Ak > Ak Fury
			}// End Weapon
		}// End Loop
	}\

	// Always HeadShot
	if(AlwaysHeadShot && HeadShotType!=0){
	DWORD pNodeMgr = *(DWORD*)(CShell + ModelNodeMGR);
		if(pNodeMgr!=NULL){
			  for (int i=0; i < 54; i++){
				*(DWORD*)(pNodeMgr + 0x54 + (i*0x7C)) = HeadShotType;
										}
						  }
						}

	// MiscMgr
	DWORD pMiscMgr = *(DWORD*)(CShell + MiscMgr);
	cMisc* MiscClass = (cMisc*)( pMiscMgr );
	if (pMiscMgr!=NULL && No_Fall_Dmg){ MiscClass->DistFallDamageStartFrom = 999999.0f; }
	if (pMiscMgr!=NULL && One_Fall2Die){ MiscClass->DamagePerMeter = 999999.0f; }
	if (pMiscMgr!=NULL && Fall_Recovery){ MiscClass->DamagePerMeter = -9999.0f; }
	if (pMiscMgr!=NULL && NewNoRecoil_2){ MiscClass->ReloadTime = 999999;	}
	}
//=== Hotkey Functions Loop ===
void HotkeyStart(){
	while(1){
		DWORD Playerptr = *(DWORD*)(CShell + PlayerptrMgr + 0x54);
	if (GetAsyncKeyState(VK_F2) < 0){
		PushNMessage(eMsg1);
		//SearchI2();
		Sleep(100);
			}
	if (GetAsyncKeyState(VK_NUMPAD3) < 0){
		DWORD PlayerClient  = *(DWORD*)( CShell + PlayerptrMgr + 0x54 );
			if(PlayerClient){	
				*(DWORD*)(PlayerClient + 0x354)= 4;
				}
		Sleep(100);
			}
	
	if (GetAsyncKeyState(NoWorld_Key) < 0){
		NoWorld = !NoWorld;
		if(NoWorld){PushToConsole("DrawWorld 0");}
		else{PushToConsole("DrawWorld 1");}
		Sleep(300);
			}
	if (GetAsyncKeyState(Lagger_Key) < 0 && GetAsyncKeyState(Lagger_Key2) < 0){
		Lagger = !Lagger;
		Beep(200, 800);
		if(Lagger){PushToConsole("LatencySim 99999999");}
		else{PushToConsole("LatencySim 0");}
		Sleep(300);
			}
	if (GetAsyncKeyState(VK_NUMPAD8) < 0 && TeleUPDOWN){
			DWORD pLTObject = *(DWORD*)(Playerptr + 0x144);
					LTObject* MyObject = (LTObject*)pLTObject;
				MyObject->Position.y += 70.0f;
			Sleep(100);
					} // END TELEUPDOWN [UP]
		if (GetAsyncKeyState(VK_NUMPAD2) < 0 && TeleUPDOWN){
			DWORD pLTObject = *(DWORD*)(Playerptr + 0x144);
					LTObject* MyObject = (LTObject*)pLTObject;
				MyObject->Position.y -= 70.0f;
			Sleep(100);
					} // END TELEUPDOWN [DOWN]
		if (GetAsyncKeyState(SaveKey) < 0 && GetAsyncKeyState(SaveKey_2) < 0 && Teleporter){
			DWORD pLTObject = *(DWORD*)(Playerptr + 0x144);
					LTObject* MyObject = (LTObject*)pLTObject;
					SavedLocation.x = MyObject->Position.x;
					SavedLocation.y = MyObject->Position.z;
					SavedLocation.z = MyObject->Position.y;
			Sleep(500);
					} // END TELPORTER [SAVE]
		if (GetAsyncKeyState(LoadKey) < 0 && GetAsyncKeyState(LoadKey_2) < 0 && Teleporter){
			DWORD pLTObject = *(DWORD*)(Playerptr + 0x144);
				LTObject* MyObject = (LTObject*)pLTObject;
					MyObject->Position.x = SavedLocation.x;
					MyObject->Position.z = SavedLocation.y;
					MyObject->Position.y = SavedLocation.z;
			Sleep(500);
					} // END TELPORTER [LOAD]
		if (GetAsyncKeyState(0x56) < 0 && Gravity){
			DWORD pLTObject = *(DWORD*)(Playerptr + 0x144);
					LTObject* MyObject = (LTObject*)pLTObject;
				MyObject->Velocity.x += 999.0f;
				MyObject->Velocity.y += 999.0f;
				MyObject->Velocity.z += 999.0f;
				MyObject->Rotation.x = 50;
				MyObject->Rotation.y = 9999;
				MyObject->Rotation.z = 0;
				MyObject->Rotation.w = 1;
			Sleep(100);
					} // END TELEUPDOWN [UP]
		if (GetAsyncKeyState(VK_NUMPAD6) < 0 && MWalkSpeed){
			WalkSpeed = !WalkSpeed;
				Beep(200, 800);
					DWORD pBPLayerInfo = *(DWORD*)(CShell +  BPlayerInfo);
					sBasicPlayerInfo* BasicPlayerInfoC = (sBasicPlayerInfo*)pBPLayerInfo;
						if(WalkSpeed)
							{BasicPlayerInfoC->MovementWalkRate += 0.7f;}
						else
							{BasicPlayerInfoC->MovementWalkRate = BUMovementWalkRate;}
						Sleep(300);
					} // Walk Speed
		if (GetAsyncKeyState(VK_NUMPAD9) < 0 && MNoWeaponWeight){
			NoWeaponWeight = !NoWeaponWeight;
				Beep(200, 800);
					DWORD pWeaponMgr = *(DWORD*)(CShell +  WeaponMgr);
						if(	pWeaponMgr != NULL){
							for(int i=0; i<925; i++){
						DWORD Weapon = (*(DWORD*)( pWeaponMgr + (4*i)) );
					cWeapon* WeaponClass = (cWeapon*)(*(DWORD*)( pWeaponMgr + (4*i)) );
						if(Weapon != NULL){
							if(NoWeaponWeight)
								{WeaponClass->MoveSpeedPenalty = 0.0f;}
							else
								{WeaponClass->MoveSpeedPenalty = BUMoveSpeedPenalty[i];}
										}
											}
												}
						Sleep(300);
					} // NoWeaponWeight
		if (GetAsyncKeyState(VK_NUMPAD7) < 0 && MNoWeaponChangeDelay){
			NoWeaponChangeDelay = !NoWeaponChangeDelay;
				Beep(200, 800);
					DWORD pWeaponMgr = *(DWORD*)(CShell +  WeaponMgr);
						if(	pWeaponMgr != NULL){
							for(int i=0; i<925; i++){
						DWORD Weapon = (*(DWORD*)( pWeaponMgr + (4*i)) );
					cWeapon* WeaponClass = (cWeapon*)(*(DWORD*)( pWeaponMgr + (4*i)) );
						if(Weapon != NULL){
							if(NoWeaponChangeDelay)
								{WeaponClass->ChangeWeaponAnimRatio += 25.0f;}
							else
								{WeaponClass->ChangeWeaponAnimRatio = BUChangeWeaponAnimRatio[i];}
										}
											}
												}
						Sleep(300);
					} // NoWeaponWeight
		if (GetAsyncKeyState(VK_F5) < 0 && RemoteGrenade){
			RemoteGrenadeExNow = !RemoteGrenadeExNow;
				Beep(200, 800);
					DWORD pWeaponMgr = *(DWORD*)(CShell +  WeaponMgr);
						if(	pWeaponMgr != NULL){
							for(int i=0; i<925; i++){
						DWORD Weapon = (*(DWORD*)( pWeaponMgr + (4*i)) );
					cWeapon* WeaponClass = (cWeapon*)(*(DWORD*)( pWeaponMgr + (4*i)) );
						if(Weapon != NULL){
							if(Grenade){
							if(RemoteGrenadeExNow)
								{WeaponClass->GrenadeBelowTime += 0.0f;}
							else
								{WeaponClass->GrenadeBelowTime = 999999.0f;}
										}
											}
												}
													}
						Sleep(300);
					} // NoWeaponWeight
	
		// Wall Hack
	if(WallHack){
		cWallHack* pWallHack;
		pWallHack = (cWallHack*)NormalWall;
		pWallHack->WallHack = 15;
		//memcpy((PVOID)(NormalWall + 0x68), (PBYTE)"\X90\X90\X90\X90", 4);
		//*(BYTE*)(BlackWall  + 0xB8) = 0x1;
		//*( BYTE*)(NormalWall + 0x68) = 8 ;
		//*(BYTE *)(WallHackNew) = 90;
		//*(BYTE *)(BlackWall) = 90;
		//memcpy((void*)(0x7480AC), (PBYTE)"\x90\x90\x90\x90", 4);
		//memcpy((void*)(NormalWall), (PBYTE)"\x1F\x1F\x1F\x1F\x1F\x1F", 6);
		//memcpy((void*)(NormalWall + 0x68 ), (PBYTE)"\x1F\x1F\x1F\x1F", 4);
		//WallHack = false;
		}// End WallHack

		// See Ghosts
	if(SeeGhostsMem){
		*(DWORD*)(MemCGhosts) = 14;
		}// End See Ghosts
	}
}
//=== PlayerClient Changes ===
void PlayerClientCh(){
	while(1){
DWORD Playerptr = *(DWORD*)(CShell + PlayerptrMgr + 0x54);
	if(Playerptr){
		if(WalkThroughWall && GetAsyncKeyState(VK_RSHIFT)){
			for (int i=0; i<0x1FF; ++i){
				if (*(float*)(Playerptr + 4*i) == 56){*(float*)(Playerptr + 4*i) = -56;}
					}
				}// End WTW [R-SHIFT]
		
			}
	Sleep(150);
	}
}
//=== GetReadyForHacking ===
void Dark(){
while(true) {
		CShell = (DWORD)GetModuleHandleA(DPLCS);
		ClientFx = (DWORD)GetModuleHandleA(DPLCF);
		Cfexe = (DWORD)GetModuleHandleA(DPCFexe);
		if(CShell && ClientFx) 
		{
			GetAddress();
			DWORD CFWeaponMgr = *(DWORD*)(CShell + WeaponMgr);
			if(CFWeaponMgr)
			{
			Sleep(2000);
			LogCharsV();
			LogFullWeapons();
			BackupMemory();
			MemoryNormal();
			CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)PlayerClientCh, NULL, NULL, NULL);
			CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)DirectX9Main, NULL, NULL, NULL);
			HotkeyStart();
			}
				break;
			}
		}
	}
//=== Dll Main ===
BOOL APIENTRY DllMain(HINSTANCE hinstDLL, DWORD status, LPVOID lpvReserved)
{
		if(status == DLL_PROCESS_ATTACH)
	{
	DisableThreadLibraryCalls(hinstDLL);
	/*MessageBoxA(0, eMsg2, eMsg1, 0);
	hWnd = CreateWindowEx(WS_EX_TOPMOST, L"RADAR", L"RADAR", WS_POPUP, position_x, position_y, 350, 350, NULL, NULL, NULL, 0);*/
	CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)Dark, hinstDLL, NULL, NULL);
	}
		if(status == DLL_PROCESS_DETACH)
		{
			OUTPUT.close();
		}
	return true;
}