public static void UpdateSkin()
{
if (CylMem.ReadInt(WeaponBase + m_iItemIDHigh) != -1)
{
CylMem.WriteInt(WeaponBase + m_iItemIDHigh, -1);
}
}
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 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 ConfigureClientState()
{
if (ClientStateBase == 0)
{
ClientStateBase = CylMem.ReadInt(Modules.EngineDLLAdress + dwClientState);
}
}
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 GoRight()
{
if (IsPlaying)
{
CylMem.WriteInt(Modules.ClientDLLAdress + dwForceRight, (int)MoveState.MAKEMOVE);
}
}
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);
}
}
}
static void ConfigureLocalPlayer()
{
if (BaseAdress == 0)
{
BaseAdress = CylMem.ReadInt(Modules.ClientDLLAdress + dwLocalPlayer);
}
}
public static void ClearChams(int EntBase)
{
uint thisPtr = BitConverter.ToUInt32(CylMem.ReadBytes(Modules.EngineDLLAdress + (model_ambient_min - 0x2C), 4), 0);
CylMem.WriteBytes(Modules.EngineDLLAdress + model_ambient_min, BitConverter.GetBytes(thisPtr ^ BitConverter.ToInt32(BitConverter.GetBytes(0), 0)));
CylMem.WriteByte(EntBase + 0x70, (byte)255);
CylMem.WriteByte(EntBase + 0x71, (byte)255);
CylMem.WriteByte(EntBase + 0x72, (byte)255);
}
public static void ShootWithPointer(int time)
{
if (IsPlaying)
{
CylMem.WriteInt(Modules.ClientDLLAdress + dwForceAttack, (int)ShootState.SHOOT);
Methods.Wait(time);
CylMem.WriteInt(Modules.ClientDLLAdress + dwForceAttack, (int)ShootState.STOP);
}
}
public static void ApplyChams(Structs.ColorStruct ChamsColor, float brightness, int EntBase)
{
uint thisPtr = BitConverter.ToUInt32(CylMem.ReadBytes(Modules.EngineDLLAdress + (model_ambient_min - 0x2C), 4), 0);
CylMem.WriteBytes(Modules.EngineDLLAdress + model_ambient_min, BitConverter.GetBytes(thisPtr ^ BitConverter.ToInt32(BitConverter.GetBytes(brightness), 0)));
CylMem.WriteByte(EntBase + 0x70, (byte)ChamsColor.r);
CylMem.WriteByte(EntBase + 0x71, (byte)ChamsColor.g);
CylMem.WriteByte(EntBase + 0x72, (byte)ChamsColor.b);
}
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 void InitializeCheat()
{
Process[] p = Process.GetProcessesByName("csgo");
CylMem.OpenProcess(p[0].Id);
Modules.ClientDLLAdress = Modules.GetModule("csgo", Modules.ClientDLLName);
Modules.EngineDLLAdress = Modules.GetModule("csgo", Modules.EngineDLLName);
Thread Cheats = new Thread(new ThreadStart(MainThread));
Cheats.Start();
}
public static Vector3 GetBonePos(int entB, int bone)
{
float x = CylMem.ReadFloat(entB + m_dwBoneMatrix + 0x30 * bone + 0x0C);
float y = CylMem.ReadFloat(entB + m_dwBoneMatrix + 0x30 * bone + 0x1C);
float z = CylMem.ReadFloat(entB + m_dwBoneMatrix + 0x30 * bone + 0x2C);
Vector3 BonePos = new Vector3(x, y, z);
return(BonePos);
}
public static bool HasHelmet(int entB)
{
if (entB != 0)
{
return(CylMem.ReadBool(entB + m_bHasHelmet));
}
else
{
return(CylMem.ReadBool(entB + m_bHasHelmet));
}
}
public static bool isDormant(int entB)
{
if (entB > 0)
{
return(CylMem.ReadBool(entB + m_bDormant));
}
else
{
return(false);
}
}
public static string LastPlace(int entB)
{
if (entB != 0)
{
return(CylMem.ReadString(entB + m_szLastPlaceName));
}
else
{
return(CylMem.ReadString(entB + m_szLastPlaceName));
}
}
public static int ArmorValue(int entB)
{
if (entB != 0)
{
return(CylMem.ReadInt(entB + m_ArmorValue));
}
else
{
return(CylMem.ReadInt(entB + m_ArmorValue));
}
}
public static int Health(int entB)
{
if (entB > 0)
{
return(CylMem.ReadInt(entB + m_iHealth));
}
else
{
return(-1);
}
}
public void InitializeCheat()
{
Modules.ClientDLLAdress = Modules.GetModule("csgo", Modules.ClientDLLName);
Modules.EngineDLLAdress = Modules.GetModule("csgo", Modules.EngineDLLName);
Process[] p = Process.GetProcessesByName("csgo");
CylMem.OpenProcess(p[0].Id);
OffsetUpdater.Updater.GetNetvars();
OffsetUpdater.Updater.ScanAllPatterns();
Thread Cheats = new Thread(new ThreadStart(MainThread));
Cheats.Start();
}
public static void ForceUpdate()
{
if (ClientStateBase != 0)
{
CylMem.WriteInt(ClientState + clientstate_delta_ticks, -1);
}
else
{
ConfigureClientState();
CylMem.WriteInt(ClientState + clientstate_delta_ticks, -1);
}
}
private void Main_Load(object sender, EventArgs e)
{
Process[] p = Process.GetProcessesByName("csgo");
CylMem.OpenProcess(p[0].Id);
Modules.ClientDLLAdress = Modules.GetModule("csgo", Modules.ClientDLLName);
Modules.EngineDLLAdress = Modules.GetModule("csgo", Modules.EngineDLLName);
OffsetUpdater.Updater.GetNetvars();
OffsetUpdater.Updater.ScanAllPatterns();
Thread Cheats = new Thread(new ThreadStart(MainThread));
Cheats.Start();
}
public static void HideBombTrajectory()
{
if (ClientStateBase != 0)
{
CylMem.CWrite <byte>(Modules.ClientDLLAdress + sv_grenade_trajectory, (byte)112);
}
else
{
ConfigureClientState();
CylMem.CWrite <byte>(Modules.ClientDLLAdress + sv_grenade_trajectory, (byte)112);
}
}
public static void RemoveHands()
{
if (!IsModelGrabbed)
{
ViewModelId = ModelIndex;
IsModelGrabbed = true;
}
if (ModelIndex != (int)ViewModel.NOMODEL)
{
CylMem.WriteInt(LocalPlayerBase + m_nModelIndex, (int)ViewModel.NOMODEL);
}
}
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 Glow(int GlowIndex, Structs.GlowStruct GlowColor, GlowStyle _GlowStyle, GlowType _GlowType)
{
CylMem.WriteFloat(GlowObject + ((GlowIndex * 0x38) + 0x4), GlowColor.r);
CylMem.WriteFloat(GlowObject + ((GlowIndex * 0x38) + 0x8), GlowColor.g);
CylMem.WriteFloat(GlowObject + ((GlowIndex * 0x38) + 0xC), GlowColor.b);
CylMem.WriteFloat(GlowObject + ((GlowIndex * 0x38) + 0x10), GlowColor.a);
CylMem.WriteInt(GlowObject + ((GlowIndex * 0x38) + 0x2C), (int)_GlowType);
CylMem.WriteBoolean(GlowObject + ((GlowIndex * 0x38) + 0x24), true);
CylMem.WriteBoolean(GlowObject + ((GlowIndex * 0x38) + 0x25), false);
if (_GlowStyle == Enums.GlowStyle.BLOOM)
{
CylMem.WriteBoolean(GlowObject + ((GlowIndex * 0x38) + 0x26), true);
}
}
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 AddHands()
{
if (BaseAdress != 0)
{
if (ModelIndex == (int)ViewModel.NOMODEL)
{
CylMem.WriteInt(LocalPlayerBase + m_nModelIndex, ViewModelId);
IsModelGrabbed = false;
}
else
{
ConfigureLocalPlayer();
if (ModelIndex == (int)ViewModel.NOMODEL)
{
CylMem.WriteInt(LocalPlayerBase + m_nModelIndex, ViewModelId);
IsModelGrabbed = false;
}
}
}
}
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
}
