static void ConfigureLocalPlayer()
{
if (BaseAdress == 0)
{
BaseAdress = CylMem.ReadInt(Modules.ClientDLLAdress + dwLocalPlayer);
}
}
public static Teams Team(int entB)
{
if (entB != 0)
{
if (CylMem.ReadInt(entB + m_iTeamNum) == (int)Teams.ANTI_TERRORIST)
{
return(Teams.ANTI_TERRORIST);
}
else if (CylMem.ReadInt(entB + m_iTeamNum) == (int)Teams.NONE)
{
return(Teams.NONE);
}
else if (CylMem.ReadInt(entB + m_iTeamNum) == (int)Teams.SPECTATOR)
{
return(Teams.SPECTATOR);
}
else if (CylMem.ReadInt(entB + m_iTeamNum) == (int)Teams.TERRORIST)
{
return(Teams.TERRORIST);
}
else
{
return(Teams.NONE);
}
}
else
{
return(Teams.NONE);
}
}
public static void UpdateSkin()
{
if (CylMem.ReadInt(WeaponBase + m_iItemIDHigh) != -1)
{
CylMem.WriteInt(WeaponBase + m_iItemIDHigh, -1);
}
}
public static void RunGlowESPPanorama(int EntBase)
{
int GlowIndex = CylMem.ReadInt(EntBase + m_iGlowIndex);
if (CEntityPlayer.Team(EntBase) == Teams.TERRORIST && CheatStatus.WallActive && CEntityPlayer.isAlive(EntBase) && ((CLocalPlayer.Team != CEntityPlayer.Team(EntBase) && VisualConfig.glowEnemyTeam) || (CLocalPlayer.Team == CEntityPlayer.Team(EntBase) && VisualConfig.glowLocalTeam))) //T
{
if (VisualConfig.selectedGlowColor == VisualColor.ENGINE)
{
CEntityPlayer.Glow(GlowIndex, VisualConfig.GlowEngineTerrorist, VisualConfig.selectedGlowStyle, VisualConfig.selectedGlowType);
}
else if (VisualConfig.selectedGlowColor == VisualColor.REDBLUE)
{
CEntityPlayer.Glow(GlowIndex, VisualConfig.GlowRed, VisualConfig.selectedGlowStyle, VisualConfig.selectedGlowType);
}
else if (VisualConfig.selectedGlowColor == VisualColor.HEALTH)
{
CEntityPlayer.Glow(GlowIndex, Parsers.ParseEnemyGlowHealth(CEntityPlayer.Health(EntBase)), VisualConfig.selectedGlowStyle, VisualConfig.selectedGlowType);
}
}
if (CEntityPlayer.Team(EntBase) == Teams.ANTI_TERRORIST && CheatStatus.WallActive && CEntityPlayer.isAlive(EntBase) && ((CLocalPlayer.Team != CEntityPlayer.Team(EntBase) && VisualConfig.glowEnemyTeam) || (CLocalPlayer.Team == CEntityPlayer.Team(EntBase) && VisualConfig.glowLocalTeam))) //AT
{
if (VisualConfig.selectedGlowColor == VisualColor.ENGINE)
{
CEntityPlayer.Glow(GlowIndex, VisualConfig.GlowEngineATerrorist, VisualConfig.selectedGlowStyle, VisualConfig.selectedGlowType);
}
else if (VisualConfig.selectedGlowColor == VisualColor.REDBLUE)
{
CEntityPlayer.Glow(GlowIndex, VisualConfig.GlowBlue, VisualConfig.selectedGlowStyle, VisualConfig.selectedGlowType);
}
else if (VisualConfig.selectedGlowColor == VisualColor.HEALTH)
{
CEntityPlayer.Glow(GlowIndex, Parsers.ParseEnemyGlowHealth(CEntityPlayer.Health(EntBase)), VisualConfig.selectedGlowStyle, VisualConfig.selectedGlowType);
}
}
}
public static void MainThread()
{
if (Modules.IsModuleRunning(Modules.ClientDLLName))
{
}
while (true)
{
if (CLocalPlayer.IsPlaying)
{
for (int i = 0; i <= EngineClient.MaxPlayer; i++)
{
int EntBase = CylMem.ReadInt(Modules.ClientDLLAdress + CoreCheat_Reborn.CheatClasses.Offsets.signatures.dwEntityList + i * 0x10);
if (EntBase == 0)
{
continue;
}
if (CEntityPlayer.isDormant(EntBase))
{
continue;
}
GlowESP.RunGlowESPLegit(EntBase, deadESP, GlowEngineTerrorist, GlowEngineATerrorist);
Chams.RunChamsLegit(EntBase, chams, deadESP);
EngineRadar.RunRadarLegit(EntBase, radar);
}
Thread.Sleep(1);
}
}
}
public static void ConfigureClientState()
{
if (ClientStateBase == 0)
{
ClientStateBase = CylMem.ReadInt(Modules.EngineDLLAdress + dwClientState);
}
}
public static bool IsScoped(int entB)
{
if (entB != 0)
{
if (CylMem.ReadInt(entB + m_bIsScoped) == 1)
{
return(true);
}
else
{
return(false);
}
}
else
{
if (CylMem.ReadInt(entB + m_bIsScoped) == 1)
{
return(true);
}
else
{
return(false);
}
}
}
public static Vector3 GetBonePos(int target, Enums.Bones bone)
{
int bMatrix = CylMem.ReadInt(target + Offsets.netvars.m_dwBoneMatrix);
Vector3 vec = new Vector3();
vec.X = CylMem.ReadFloat(bMatrix + (0x30 * (int)bone) + 0xC);
vec.Y = CylMem.ReadFloat(bMatrix + (0x30 * (int)bone) + 0x1C);
vec.Z = CylMem.ReadFloat(bMatrix + (0x30 * (int)bone) + 0x2C);
return(vec);
}
public static int Health(int entB)
{
if (entB > 0)
{
return(CylMem.ReadInt(entB + m_iHealth));
}
else
{
return(-1);
}
}
public static int ArmorValue(int entB)
{
if (entB != 0)
{
return(CylMem.ReadInt(entB + m_ArmorValue));
}
else
{
return(CylMem.ReadInt(entB + m_ArmorValue));
}
}
public static string WeaponName(int entB)
{
if (entB != 0)
{
int ActiveWeapon = CylMem.ReadInt(entB + m_hActiveWeapon) & 0xFFF;
ActiveWeapon = CylMem.ReadInt(Modules.ClientDLLAdress + dwEntityList + (ActiveWeapon - 1) * 0x10);
short ActiveWeaponID = CylMem.ReadShort(ActiveWeapon + m_iItemDefinitionIndex);
return(Managers.Parsers.ParseItemName(ActiveWeaponID));
}
else
{
return(Managers.Parsers.ParseItemName(0));
}
}
public static void RunNoSmokePanorama()
{
if (CheatStatus.NoSmokeActive)
{
for (int i = 0; i < 512; i++)
{
int EntBase = CylMem.ReadInt(Modules.ClientDLLAdress + dwEntityList + i * 0x10);
if (EntBase == 0)
{
continue;
}
if (EngineClient.GetClassId(EntBase) == ClassID.CSmokeGrenadeProjectile)
{
CylMem.CWrite <Vector3>(EntBase + m_vecOrigin, new Vector3(999, 999, 999));
}
}
}
}
public static void ChangeSkin(string CustomName, int PaintKit, EntityQuality EntityQuality, int StatTrack)
{
SkinStruct WeaponSkin = new SkinStruct
{
CustomName = CustomName,
PaintKit = PaintKit,
StatTrack = StatTrack,
EntityQualityIndex = EntityQuality,
Wear = 0.0001f,
Seed = 0
};
for (int i = 0; i < 8; i++)
{
WeaponBase = CylMem.ReadInt(CLocalPlayer.LocalPlayerBase + m_hMyWeapons + i * 0x4) & 0xFFF;
WeaponBase = CylMem.ReadInt((int)Modules.ClientDLLAdress + dwEntityList + (WeaponBase - 1) * 0x10);
if (WeaponSkin.PaintKit != 0)
{
if (CylMem.ReadInt(WeaponBase + m_iItemIDHigh) != -1)
{
CylMem.WriteInt(WeaponBase + m_iItemIDHigh, -1);
}
CylMem.WriteInt(WeaponBase + m_OriginalOwnerXuidLow, 0);
CylMem.WriteInt(WeaponBase + m_OriginalOwnerXuidHigh, 0);
CylMem.WriteInt(WeaponBase + m_nFallbackPaintKit, WeaponSkin.PaintKit);
CylMem.WriteInt(WeaponBase + m_nFallbackSeed, WeaponSkin.Seed);
CylMem.WriteInt(WeaponBase + m_nFallbackStatTrak, WeaponSkin.StatTrack);
CylMem.WriteFloat(WeaponBase + m_flFallbackWear, WeaponSkin.Wear);
CylMem.CWrite <char[]>(WeaponBase + m_szCustomName, WeaponSkin.CustomName.ToCharArray());
if (StatTrack >= 0)
{
CylMem.WriteInt(WeaponBase + m_iEntityQuality, (int)WeaponSkin.EntityQualityIndex);
}
else
{
CylMem.WriteInt(WeaponBase + m_iEntityQuality, 0);
}
}
}
}
public static void ChangeViewAngles(Vector3 Angles, bool CanShoot)
{
//read pointers to commands buffer and clientstate
CInput Input = CylMem.CRead2 <CInput>(Modules.ClientDLLAdress + dwInput);
int ClientState = CylMem.ReadInt(Modules.EngineDLLAdress + dwClientState);
//stop sending packets
EngineClient.SendPackets = false;
int DesiredCmd = CylMem.ReadInt(ClientState + clientstate_last_outgoing_command); //read the last outgoing command
DesiredCmd += 2; //+1 current one +2 incomming one
//calculate addresses of Icomming cmd and current cmd + verified, 150 is the size of the commands buffer
int IncommingUserCmd = Input.Commands + (DesiredCmd % 150) * Marshal.SizeOf(typeof(CUserCmd));
int CurrentUserCmd = Input.Commands + ((DesiredCmd - 1) % 150) * Marshal.SizeOf(typeof(CUserCmd));
int VerifiedCurrentUserCmd = Input.VerifiedCommands + ((DesiredCmd - 1) % 150) * Marshal.SizeOf(typeof(CVerifiedUserCmd));
int CmdNumber = 0;
while (CmdNumber < DesiredCmd) //now we wait until is the right time to hit, dont sleep! the wait time is really short, in fact it doesnt consume cpu, +0x04 skips vft and reads the cmd number
{
CmdNumber = CylMem.ReadInt(IncommingUserCmd + 0x04);
}
CUserCmd CMD = CylMem.CRead2 <CUserCmd>(CurrentUserCmd); //we hack this one, read it
CMD.ViewAngles.X = Angles.X; //set new view angles
CMD.ViewAngles.Y = Angles.Y;
if (CanShoot) //trigger shoot button if we set CanShoot to true
{
CMD.Buttons |= 1 << 0;
}
//when you are done write em back
CylMem.CWrite <CUserCmd>(CurrentUserCmd, CMD);
CylMem.CWrite <CUserCmd>(VerifiedCurrentUserCmd, CMD); //dont bother calculating crc (accualy you can do it to make vac happy and not get banned easilly lol)
EngineClient.SendPackets = true; //restore sending packets
}
public static void RunGlowESPLegit(int EntBase, bool Active, GlowStruct TColor, GlowStruct ATColor)
{
int GlowIndex = CylMem.ReadInt(EntBase + m_iGlowIndex);
if (Active)
{
if (CLocalPlayer.isDead)
{
if (CLocalPlayer.Team != CEntityPlayer.Team(EntBase))
{
if (CEntityPlayer.Team(EntBase) == Teams.TERRORIST && CEntityPlayer.isAlive(EntBase)) //T
{
CEntityPlayer.Glow(GlowIndex, TColor, GlowStyle.NORMAL, GlowType.NORMAL);
}
if (CEntityPlayer.Team(EntBase) == Teams.ANTI_TERRORIST && CEntityPlayer.isAlive(EntBase)) //AT
{
CEntityPlayer.Glow(GlowIndex, ATColor, GlowStyle.NORMAL, GlowType.NORMAL);
}
}
}
}
}
public static void RunChamsLegit(int EntBase, bool Active, bool dEspActive)
{
int GlowIndex = CylMem.ReadInt(EntBase + m_iGlowIndex);
if (Active)
{
if (CLocalPlayer.Team != CEntityPlayer.Team(EntBase))
{
if (CLocalPlayer.isAlive || !dEspActive)
{
CEntityPlayer.Glow(GlowIndex, Parsers.ParseEnemyGlowHealth(CEntityPlayer.Health(EntBase)), GlowStyle.NORMAL, GlowType.FROZEN);
}
CEntityPlayer.ApplyChams(Parsers.ParseEnemyChamsHealth(CEntityPlayer.Health(EntBase)), 90, EntBase);
}
}
else if (!Active)
{
if (CLocalPlayer.Team != CEntityPlayer.Team(EntBase))
{
CEntityPlayer.ClearChams(EntBase);
}
}
}
public static void RunGlowESPOWALL(GlowStruct red, GlowStruct blue, bool Active)
{
for (int i = 0; i <= EngineClient.MaxPlayer; i++)
{
int EntBase = CylMem.ReadInt(Modules.ClientDLLAdress + dwEntityList + i * 0x10);
if (EntBase == 0)
{
continue;
}
if (CEntityPlayer.isDormant(EntBase))
{
continue;
}
if (CEntityPlayer.isDead(EntBase))
{
continue;
}
if (CEntityPlayer.Team(EntBase) == Teams.NONE || CEntityPlayer.Team(EntBase) == Teams.SPECTATOR)
{
continue;
}
if (CEntityPlayer.WeaponName(EntBase) == "NONE")
{
continue;
}
int GlowIndex = CylMem.ReadInt(EntBase + m_iGlowIndex);
if (CEntityPlayer.Team(EntBase) == Teams.TERRORIST && Active && CEntityPlayer.isAlive(EntBase)) //T
{
CEntityPlayer.Glow(GlowIndex, red, GlowStyle.NORMAL, GlowType.NORMAL);
}
if (CEntityPlayer.Team(EntBase) == Teams.ANTI_TERRORIST && Active && CEntityPlayer.isAlive(EntBase)) //AT
{
CEntityPlayer.Glow(GlowIndex, blue, GlowStyle.NORMAL, GlowType.NORMAL);
}
}
}
private static void MainThread()
{
Main m = Main.getInstance();
m.log("Main Thread Started");
m.log("A:" + aimbot.ToString());
AimBotController aimbotController = new AimBotController();
if (Modules.IsModuleRunning(Modules.ClientDLLName))
{
while (true)
{
if (CLocalPlayer.IsPlaying)
{
#region Aimbot-Start
if (aimbot)
{
aimbotController.setFrom(CLocalPlayer.Position);
}
#endregion
#region PlayerLoop
for (int i = 0; i <= EngineClient.MaxPlayer; i++)
{
#region Entity Cheats
int EntBase = CylMem.ReadInt(Modules.ClientDLLAdress + dwEntityList + i * 0x10);
if (EntBase == 0)
{
continue;
}
if (CEntityPlayer.isDormant(EntBase))
{
continue;
}
#region Aimbot-GetClosestPlayer
int health = CEntityPlayer.Health(EntBase);
Teams team = CEntityPlayer.Team(EntBase);
if (CheatStatus.AimbotActive &&
team != CLocalPlayer.Team &&
team != Teams.SPECTATOR &&
team != Teams.NONE &&
CEntityPlayer.isAlive(EntBase) &&
health > 0 && health <= 100
)
{
aimbotController.closestEngine(EntBase, CEntityPlayer.Position(EntBase));
}
#endregion
#endregion
}
#region Aimbot-Target
if (aimbot)
{
int target_aim_entbase = aimbotController.closestPlayerEntityBase;
Vector3 target_aim_vector = aimbotController.closestPlayerVector;
if (CEntityPlayer.isPlayerSpotted(target_aim_entbase) && Methods.HoldingKey(Keys.LButton))
{
Vector3 raw = aimbotController.CalcAngle(target_aim_vector);
Vector3 raw_unp = aimbotController.RemovePunch(raw);
Vector3 target_angle = Parsers.ClampAngle(raw_unp);
CLocalPlayer.ViewAngles = target_angle;
//m.log(
// String.Format("Closest Player x:{0} y:{1} z:{2} Distance : {3}", target_aim_vector.X, target_aim_vector.Y, target_aim_vector.Z,aimbotController.target_distance),
// "Aimbot Closest"
// );
//m.log(
// String.Format("Angle x:{0} y:{1} z:{2} Distance : {3}", raw_unp.X, raw_unp.Y, raw_unp.Z, aimbotController.target_distance),
// "Aimbot Closest"
// );
}
}
#endregion
#endregion
}
}
}
}
public static void RunTriggerBotPanorama()
{
if (CheatStatus.TriggerActive)
{
if (AssistsConfig.TriggerKey == KeysList.NOKEYS || (AssistsConfig.TriggerKey != KeysList.NOKEYS && Methods.HoldingKey(Parsers.KeyListToRealKey(AssistsConfig.TriggerKey))))
{
if (CLocalPlayer.IsCloseRangeWeapon)
{
return;
}
if (CLocalPlayer.IsThrowableWeapon)
{
return;
}
else
{
int CrossEntity;
if (CylMem.ReadInt(Modules.ClientDLLAdress + dwEntityList + (CLocalPlayer.CrossID - 1) * 0x10) == -1)
{
CrossEntity = 0;
}
else
{
CrossEntity = CylMem.ReadInt(Modules.ClientDLLAdress + dwEntityList + (CLocalPlayer.CrossID - 1) * 0x10);
}
if (CrossEntity == 0)
{
return;
}
if (CEntityPlayer.isDormant(CrossEntity))
{
return;
}
if (CEntityPlayer.isDead(CrossEntity))
{
return;
}
if (CEntityPlayer.Team(CrossEntity) == Teams.NONE || CEntityPlayer.Team(CrossEntity) == Teams.SPECTATOR)
{
return;
}
if (CEntityPlayer.WeaponName(CrossEntity) == "NONE")
{
return;
}
if (AssistsConfig.isNoScope)
{
if (CLocalPlayer.CrossID > 0 && CLocalPlayer.CrossID <= EngineClient.MaxPlayer && ((CEntityPlayer.Team(CrossEntity) == CLocalPlayer.Team && AssistsConfig.isFriendlyFire) || (CEntityPlayer.Team(CrossEntity) != CLocalPlayer.Team)))
{
if (CEntityPlayer.isAlive(CrossEntity) && CLocalPlayer.CrossID >= 0)
{
for (int i = 0; i < 2; i++)
{
if (CLocalPlayer.IsPistolWeapon)
{
CLocalPlayer.ShootWithPointer(new Random().Next(7, 20));
continue;
}
else if (AssistsConfig.isSprayRandom)
{
CLocalPlayer.ShootWithPointer(new Random().Next(7, 20));
}
else
{
CLocalPlayer.ShootWithPointer(WeaponSettings.TriggerSprayTime);
}
}
}
}
}
else if (!CLocalPlayer.Scoped)
{
if (CLocalPlayer.IsScopedWeapon)
{
return;
}
else
{
if (CLocalPlayer.CrossID > 0 && CLocalPlayer.CrossID <= EngineClient.MaxPlayer && ((CEntityPlayer.Team(CrossEntity) == CLocalPlayer.Team && AssistsConfig.isFriendlyFire) || (CEntityPlayer.Team(CrossEntity) != CLocalPlayer.Team)))
{
if ((CEntityPlayer.Team(CrossEntity) != CLocalPlayer.Team) && CEntityPlayer.isAlive(CrossEntity) && CLocalPlayer.CrossID >= 0)
{
for (int i = 0; i < 2; i++)
{
if (CLocalPlayer.IsPistolWeapon)
{
CLocalPlayer.ShootWithPointer(new Random().Next(7, 20));
continue;
}
else if (AssistsConfig.isSprayRandom)
{
CLocalPlayer.ShootWithPointer(new Random().Next(7, 20));
}
else
{
CLocalPlayer.ShootWithPointer(WeaponSettings.TriggerSprayTime);
}
}
}
}
}
}
else
{
if (CLocalPlayer.CrossID > 0 && CLocalPlayer.CrossID <= EngineClient.MaxPlayer)
{
if (CLocalPlayer.CrossID > 0 && CLocalPlayer.CrossID <= EngineClient.MaxPlayer && ((CEntityPlayer.Team(CrossEntity) == CLocalPlayer.Team && AssistsConfig.isFriendlyFire) || (CEntityPlayer.Team(CrossEntity) != CLocalPlayer.Team)))
{
for (int i = 0; i < 2; i++)
{
if (CLocalPlayer.IsPistolWeapon)
{
CLocalPlayer.ShootWithPointer(new Random().Next(7, 20));
continue;
}
else if (AssistsConfig.isSprayRandom)
{
CLocalPlayer.ShootWithPointer(new Random().Next(7, 20));
}
else
{
CLocalPlayer.ShootWithPointer(WeaponSettings.TriggerSprayTime);
}
}
}
}
}
}
}
}
}
public static ClassID GetClassId(int EntBase)
{
return((ClassID)CylMem.ReadInt(CylMem.ReadInt(CylMem.ReadInt(CylMem.ReadInt(EntBase + 8) + 2 * 4) + 1) + 20));
}
private static void MainThread()
{
if (Modules.IsModuleRunning(Modules.ClientDLLName))
{
AimBotController Aim = new AimBotController();
while (true)
{
if (CLocalPlayer.IsPlaying)
{
for (int i = 0; i <= EngineClient.MaxPlayer; i++)
{
int EntBase = CylMem.ReadInt(Modules.ClientDLLAdress + Offsets.signatures.dwEntityList + i * 0x10);
if (EntBase == 0)
{
continue;
}
if (CEntityPlayer.isDormant(EntBase))
{
continue;
}
if (CEntityPlayer.isDead(EntBase))
{
continue;
}
if (CEntityPlayer.Team(EntBase) == Teams.NONE || CEntityPlayer.Team(EntBase) == Teams.SPECTATOR)
{
continue;
}
if (CEntityPlayer.WeaponName(EntBase) == "NONE")
{
continue;
}
Aimbot.ConfigureAimbot(EntBase, Aim);
GlowESP.RunGlowESPPanorama(EntBase);
Chams.RunChamsPanorama(EntBase);
EngineRadar.RunRadarPanorama(EntBase);
}
BunnyHop.RunBunnyHopPanorama();
AutoPistol.RunAutoPistolPanorama();
Triggerbot.RunTriggerBotPanorama();
NoFlash.RunNoFlashPanorama();
NoHands.RunNoHandsPanorama();
DamageIndicator.RunDamageIndicatorPanorama();
RemoveScope.RunRemoveScopePanorama();
ViewModelFOV.RunViewModelFOV();
RecoilControlSystem.RunRCSPanorama();
GrenadeTrajectory.RunGPRJPanorama();
NoSmoke.RunNoSmokePanorama();
Aimbot.RunAimbotPanorama(Aim);
#region Performance Settings
if (CheatPerf == PerformanceTimes.VHIGH)
{
}
else
{
Thread.Sleep((int)CheatPerf);
}
#endregion
}
}
}
}
public static int GetEntity(int i)
{
return(CylMem.ReadInt(Modules.ClientDLLAdress + dwEntityList + i * 0x10));
}
private static int GetModelIndex(int entB)
{
return(CylMem.ReadInt(entB + m_nModelIndex));
}