├── .gitignore ├── CSGOIntExt ├── CSGO │ ├── Features │ │ ├── Aimbot │ │ │ ├── Aimbot.cpp │ │ │ └── Aimbot.h │ │ ├── Misc │ │ │ ├── Misc.cpp │ │ │ └── Misc.h │ │ ├── Triggerbot │ │ │ ├── Triggerbot.cpp │ │ │ └── Triggerbot.h │ │ └── Visual │ │ │ ├── Glow │ │ │ ├── Glow.cpp │ │ │ └── Glow.h │ │ │ └── Radar │ │ │ ├── Radar.cpp │ │ │ └── Radar.h │ ├── Main.cpp │ ├── SDK │ │ ├── Includes │ │ │ ├── Classes.h │ │ │ ├── Const.h │ │ │ ├── Enums.h │ │ │ ├── Offsets.h │ │ │ └── Structs.h │ │ ├── Main │ │ │ ├── BaseEntity │ │ │ │ ├── BaseEntity.cpp │ │ │ │ └── BaseEntity.h │ │ │ ├── ClientState │ │ │ │ ├── ClientState.cpp │ │ │ │ └── ClientState.h │ │ │ ├── Engine │ │ │ │ ├── Engine.cpp │ │ │ │ └── Engine.h │ │ │ └── EntityCache │ │ │ │ ├── EntityCache.cpp │ │ │ │ └── EntityCache.h │ │ └── SDK.h │ └── Utils │ │ ├── Math │ │ └── Math.h │ │ ├── Memory │ │ ├── Memory.cpp │ │ └── Memory.h │ │ └── Utils.h ├── CSGOIntExt.vcxproj ├── CSGOIntExt.vcxproj.filters └── CSGOIntExt.vcxproj.user └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | CSGOIntExt/Release/Engine.obj 3 | *.obj 4 | *.tlog 5 | *.dll 6 | *.iobj 7 | *.ipdb 8 | *.log 9 | *.txt 10 | *.pdb 11 | *.idb 12 | *.ilk 13 | *.ipch 14 | CSGOIntExt/.vs/CSGOIntExt/v16/.suo 15 | *.db 16 | *.db-shm 17 | *.opendb 18 | *.db-wal 19 | -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/Features/Aimbot/Aimbot.cpp: -------------------------------------------------------------------------------- 1 | #include "Aimbot.h" 2 | 3 | C_Aimbot gAimbot; 4 | 5 | void C_Aimbot::Run() 6 | { 7 | if (ShouldRun()) 8 | { 9 | if (const auto& pLocal = gEntCache.pLocal) 10 | { 11 | //Update some vars we need here, to remove need of multiple reads. 12 | m_vLocalEyePos = pLocal->GetEyePos(); 13 | m_vLocalAngle = gEngine.GetViewAngles(); 14 | m_vLocalPunch = pLocal->GetAimPunch() * 2.0f; 15 | 16 | Target_t Target = { }; 17 | 18 | if (GetTarget(pLocal, Target)) 19 | { 20 | SetAngles(Target, pLocal); 21 | } 22 | } 23 | } 24 | } 25 | 26 | bool C_Aimbot::GetTarget(C_BaseEntity* pLocal, Target_t& out) 27 | { 28 | if (!GetTargets(pLocal)) 29 | return false; 30 | 31 | SortTargets(); 32 | 33 | for (auto& Target : m_vecTargets) 34 | { 35 | //TODO: 36 | //-Skip all non-visible entities (Visibility check) 37 | //-idk 38 | 39 | out = Target; 40 | return true; 41 | } 42 | 43 | return false; 44 | } 45 | 46 | bool C_Aimbot::GetTargets(C_BaseEntity* pLocal) 47 | { 48 | m_vecTargets.clear(); 49 | 50 | if (Core::Vars::Aimbot::AimPlayers) 51 | { 52 | const auto Players = gEntCache.GetGroup(Core::Vars::Aimbot::IgnoreTeam ? GroupType_t::PLAYERS_ENEMIES : GroupType_t::PLAYERS_ALL); 53 | 54 | for (const auto& pEntity : Players) 55 | { 56 | if (!pEntity->IsAlive() || pEntity->IsImmune()) 57 | continue; 58 | 59 | Target_t Target = { }; 60 | 61 | Target.pEntity = pEntity; 62 | Target.eType = ETargetType::PLAYER; 63 | Target.vPosition = pEntity->GetBonePos(Core::Vars::Aimbot::nBone); 64 | Target.vAngleTo = Math::CalcAngle(m_vLocalEyePos, Target.vPosition); 65 | Target.fFovTo = Math::CalcFov(m_vLocalAngle + m_vLocalPunch, Target.vAngleTo); 66 | 67 | if (!Core::Vars::Aimbot::SortByDistance && Target.fFovTo > Core::Vars::Aimbot::flFov) 68 | continue; 69 | 70 | Target.fDistTo = m_vLocalEyePos.DistTo(Target.vPosition); 71 | 72 | m_vecTargets.push_back(Target); 73 | } 74 | } 75 | 76 | if (Core::Vars::Aimbot::AimChicken) 77 | { 78 | for (const auto& pEntity : gEntCache.GetGroup(GroupType_t::CHICKEN_ALL)) 79 | { 80 | if (!pEntity->IsAlive()) 81 | continue; 82 | 83 | Target_t Target = { }; 84 | 85 | Target.pEntity = pEntity; 86 | Target.eType = ETargetType::CHICKEN; 87 | Target.vPosition = pEntity->GetVecOrigin() + Vec3(0, 0, 10); 88 | Target.vAngleTo = Math::CalcAngle(m_vLocalEyePos, Target.vPosition); 89 | Target.fFovTo = Math::CalcFov(m_vLocalAngle + m_vLocalPunch, Target.vAngleTo); 90 | 91 | if (!Core::Vars::Aimbot::SortByDistance && Target.fFovTo > Core::Vars::Aimbot::flFov) 92 | continue; 93 | 94 | Target.fDistTo = m_vLocalEyePos.DistTo(Target.vPosition); 95 | 96 | m_vecTargets.push_back(Target); 97 | } 98 | } 99 | 100 | return !m_vecTargets.empty(); 101 | } 102 | 103 | void C_Aimbot::SetAngles(const Target_t& Target, C_BaseEntity* pLocal) 104 | { 105 | Vec3 vAngle = Target.vAngleTo - m_vLocalPunch; 106 | Math::ClampAngles(vAngle); 107 | 108 | if (Core::Vars::Aimbot::SmoothAim) 109 | { 110 | Vec3 vDelta = (vAngle - m_vLocalAngle); 111 | Math::ClampAngles(vDelta); 112 | 113 | if (Core::Vars::Aimbot::CurveAim) 114 | { 115 | vDelta += Vec3(vDelta.y / Core::Vars::Aimbot::flCurveX, vDelta.x / Core::Vars::Aimbot::flCurveY, 0.0f); 116 | Math::ClampAngles(vDelta); 117 | } 118 | 119 | m_vLocalAngle += vDelta / Core::Vars::Aimbot::flSmooth; 120 | Math::ClampAngles(m_vLocalAngle); 121 | 122 | gEngine.SetViewAngles(m_vLocalAngle); 123 | } 124 | else 125 | { 126 | gEngine.SetViewAngles(vAngle); 127 | } 128 | } 129 | 130 | void C_Aimbot::SortTargets() 131 | { 132 | std::sort(m_vecTargets.begin(), m_vecTargets.end(), [&](const Target_t& a, const Target_t& b) -> bool 133 | { 134 | if (Core::Vars::Aimbot::SortByDistance) 135 | return (a.fDistTo < b.fDistTo); 136 | else 137 | return (a.fFovTo < b.fFovTo); 138 | }); 139 | } 140 | 141 | bool C_Aimbot::ShouldRun() 142 | { 143 | if (!Core::Vars::Aimbot::Active || !Util::IsKeyDown(Core::Vars::Aimbot::nKey)) 144 | return false; 145 | 146 | return true; 147 | } -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/Features/Aimbot/Aimbot.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../SDK/SDK.h" 4 | 5 | class C_Aimbot 6 | { 7 | public: 8 | void Run(); 9 | 10 | private: 11 | enum struct ETargetType 12 | { 13 | DEFAULT = -1, 14 | PLAYER, 15 | DRONE, 16 | CHICKEN 17 | }; 18 | 19 | struct Target_t 20 | { 21 | C_BaseEntity* pEntity = nullptr; 22 | ETargetType eType = ETargetType::DEFAULT; 23 | Vec3 vPosition = Vec3(); 24 | Vec3 vAngleTo = Vec3(); 25 | float fFovTo = 0.0f; 26 | float fDistTo = 0.0f; 27 | }; 28 | 29 | void SortTargets(); 30 | void SetAngles(const Target_t& Target, C_BaseEntity* pLocal); 31 | bool GetTargets(C_BaseEntity* pLocal); 32 | bool GetTarget(C_BaseEntity* pLocal, Target_t& out); 33 | bool ShouldRun(); 34 | 35 | std::vector m_vecTargets; 36 | Vec3 m_vLocalEyePos; 37 | Vec3 m_vLocalAngle; 38 | Vec3 m_vLocalPunch; 39 | }; 40 | 41 | extern C_Aimbot gAimbot; -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/Features/Misc/Misc.cpp: -------------------------------------------------------------------------------- 1 | #include "Misc.h" 2 | 3 | C_Misc gMisc; 4 | 5 | void C_Misc::Run() 6 | { 7 | if (Core::Vars::Misc::Bunnyhop) 8 | RunBhop(); 9 | 10 | //... 11 | } 12 | 13 | void C_Misc::RunBhop() 14 | { 15 | if (const auto& pLocal = gEntCache.pLocal) 16 | { 17 | if (GetAsyncKeyState(VK_SPACE) & 0x8000 && pLocal->IsOnGround()) 18 | SendMessage(Core::GameWindow, WM_MOUSEWHEEL, -32, NULL); 19 | } 20 | } -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/Features/Misc/Misc.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../SDK/SDK.h" 4 | 5 | class C_Misc 6 | { 7 | public: 8 | void Run(); 9 | 10 | private: 11 | void RunBhop(); 12 | }; 13 | 14 | extern C_Misc gMisc; -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/Features/Triggerbot/Triggerbot.cpp: -------------------------------------------------------------------------------- 1 | #include "Triggerbot.h" 2 | 3 | C_Triggerbot gTrigger; 4 | 5 | void C_Triggerbot::Run() 6 | { 7 | if (const auto& pLocal = gEntCache.pLocal) 8 | { 9 | if (ShouldRun(pLocal)) 10 | { 11 | if (const auto& pEntity = gEntCache.pCrossEnt) 12 | { 13 | if (IsValid(pEntity, pLocal)) 14 | Attack(); 15 | } 16 | } 17 | } 18 | } 19 | 20 | bool C_Triggerbot::ShouldRun(C_BaseEntity* pLocal) 21 | { 22 | if (!Core::Vars::Trigger::Active || !Util::IsKeyDown(Core::Vars::Trigger::nKey)) return false; 23 | if (Core::Vars::Trigger::WaitForPunch && !pLocal->GetAimPunch().IsZero()) return false; 24 | if (Core::Vars::Trigger::OnlyOnGround && !pLocal->IsOnGround()) return false; 25 | 26 | return true; 27 | } 28 | 29 | bool C_Triggerbot::IsValid(C_BaseEntity* pEntity, C_BaseEntity* pLocal) 30 | { 31 | if (!pEntity) return false; 32 | 33 | auto nClassID = pEntity->GetClassID(); 34 | 35 | if (!IsValidEntity(nClassID)) return false; 36 | 37 | if (IsPlayer(nClassID)) 38 | { 39 | if (pEntity->IsImmune()) return false; 40 | if (Core::Vars::Trigger::IgnoreTeam && pEntity->GetTeamNum() == pLocal->GetTeamNum()) return false; 41 | if (Core::Vars::Trigger::IgnoreJumping && !pEntity->IsOnGround()) return false; 42 | } 43 | 44 | return true; 45 | } 46 | 47 | bool C_Triggerbot::IsValidEntity(int nClassID) 48 | { 49 | switch (nClassID) 50 | { 51 | case CCSPlayer: if (Core::Vars::Trigger::Players) return true; break; 52 | case CChicken: if (Core::Vars::Trigger::Chickens) return true; break; 53 | default: break; 54 | } 55 | 56 | return false; 57 | } 58 | 59 | bool C_Triggerbot::IsPlayer(int nClassID) 60 | { 61 | return (nClassID == CCSPlayer); 62 | } 63 | 64 | //TODO: This is quite stupid 65 | void C_Triggerbot::Attack() 66 | { 67 | mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0); 68 | std::this_thread::sleep_for(std::chrono::milliseconds(Util::RandInt(1, 25))); 69 | mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0); 70 | } -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/Features/Triggerbot/Triggerbot.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../SDK/SDK.h" 4 | 5 | class C_Triggerbot 6 | { 7 | public: 8 | void Run(); 9 | 10 | private: 11 | void Attack(); 12 | 13 | bool IsValidEntity(int nClassID); 14 | bool IsPlayer(int nClassID); 15 | bool IsValid(C_BaseEntity* pEntity, C_BaseEntity* pLocal); 16 | bool ShouldRun(C_BaseEntity* pLocal); 17 | 18 | }; 19 | 20 | extern C_Triggerbot gTrigger; -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/Features/Visual/Glow/Glow.cpp: -------------------------------------------------------------------------------- 1 | #include "Glow.h" 2 | 3 | C_Glow gGlow; 4 | 5 | static constexpr fColor_t clrTer = { 0.4f, 0.4f, 0.1f, 1.0f }; 6 | static constexpr fColor_t clrCT = { 0.1f, 0.4f, 0.4f, 1.0f }; 7 | 8 | void C_Glow::Run() 9 | { 10 | if (ShouldRun()) 11 | { 12 | if (const auto dwGlowBase = gEngine.GetGlowManager()) 13 | { 14 | if (Core::Vars::Glow::Players) 15 | { 16 | const auto Players = 17 | gEntCache.GetGroup(Core::Vars::Glow::IgnoreTeam ? GroupType_t::PLAYERS_ENEMIES : GroupType_t::PLAYERS_ALL); 18 | 19 | for (const auto& pEntity : Players) 20 | ForceGlow(dwGlowBase, pEntity->GetGlowIndex(), pEntity->GetTeamNum() == 3 ? clrCT : clrTer); 21 | } 22 | } 23 | } 24 | } 25 | 26 | void C_Glow::ForceGlow(DWORD dwBase, int nIndex, fColor_t clrGlow) 27 | { 28 | ReadProcessMemory(gMem.m_hProcess, reinterpret_cast((dwBase + (nIndex * 0x38) + 0x4)), &m_sGlowObj, sizeof(m_sGlowObj), NULL); 29 | m_sGlowObj.r = clrGlow.r; 30 | m_sGlowObj.g = clrGlow.g; 31 | m_sGlowObj.b = clrGlow.b; 32 | m_sGlowObj.a = clrGlow.a; 33 | //m_sGlowObj.m_nGlowStyle = 0; //Should be 0 by default NOTE: See what to do with 3 34 | m_sGlowObj.m_bRenderWhenOccluded = true; 35 | m_sGlowObj.m_bRenderWhenUnoccluded = false; 36 | WriteProcessMemory(gMem.m_hProcess, reinterpret_cast((dwBase + (nIndex * 0x38) + 0x4)), &m_sGlowObj, sizeof(m_sGlowObj), NULL); 37 | } 38 | 39 | bool C_Glow::ShouldRun() 40 | { 41 | if (!Core::Vars::Glow::Active) 42 | return false; 43 | 44 | return true; 45 | } -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/Features/Visual/Glow/Glow.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../../SDK/SDK.h" 4 | 5 | struct fColor_t { float r, g, b, a; }; 6 | 7 | class C_Glow 8 | { 9 | public: 10 | void Run(); 11 | 12 | private: 13 | void ForceGlow(DWORD dwBase, int nIndex, fColor_t clrGlow); 14 | bool ShouldRun(); 15 | 16 | struct GlowObject_t 17 | { 18 | float r; 19 | float g; 20 | float b; 21 | float a; 22 | char __pad0[4]; 23 | float __pad1; 24 | float m_flBloomAmount; 25 | float __pad2; 26 | bool m_bRenderWhenOccluded; 27 | bool m_bRenderWhenUnoccluded; 28 | bool m_bFullBloomRender; 29 | char __pad3; 30 | int m_nFullBloomStencilTestValue; 31 | int m_nGlowStyle; 32 | int m_nSplitScreenSlot; 33 | int m_nNextFreeSlot; 34 | }; 35 | 36 | GlowObject_t m_sGlowObj; 37 | }; 38 | 39 | extern C_Glow gGlow; -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/Features/Visual/Radar/Radar.cpp: -------------------------------------------------------------------------------- 1 | #include "Radar.h" 2 | 3 | C_Radar gRadar; 4 | 5 | void C_Radar::Run() 6 | { 7 | if (ShouldRun()) 8 | { 9 | for (auto& pEntity : gEntCache.GetGroup(GroupType_t::PLAYERS_ENEMIES)) 10 | { 11 | if (!pEntity->IsSpotted()) 12 | pEntity->SetSpotted(true); 13 | } 14 | } 15 | } 16 | 17 | bool C_Radar::ShouldRun() 18 | { 19 | if (!Core::Vars::Radar::Active) 20 | return false; 21 | 22 | return true; 23 | } -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/Features/Visual/Radar/Radar.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../../SDK/SDK.h" 4 | 5 | class C_Radar 6 | { 7 | public: 8 | void Run(); 9 | 10 | private: 11 | bool ShouldRun(); 12 | 13 | }; 14 | 15 | extern C_Radar gRadar; -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/Main.cpp: -------------------------------------------------------------------------------- 1 | #include "SDK/SDK.h" 2 | 3 | #include "Utils/Memory/Memory.h" 4 | 5 | #include "Features/Misc/Misc.h" 6 | #include "Features/Visual/Glow/Glow.h" 7 | #include "Features/Visual/Radar/Radar.h" 8 | #include "Features/Aimbot/Aimbot.h" 9 | #include "Features/Triggerbot/Triggerbot.h" 10 | 11 | DWORD WINAPI MainThread(LPVOID lpParam) 12 | { 13 | if (gEngine.TrainingSoftware()) 14 | { 15 | Beep(300, 200); //Beep 16 | 17 | while (!(GetAsyncKeyState(VK_F11) & 0x01)) 18 | { 19 | if (gEngine.IsGameFocused()) 20 | { 21 | gEntCache.Fill(); 22 | { 23 | gTrigger.Run(); 24 | gAimbot.Run(); 25 | gMisc.Run(); 26 | gGlow.Run(); 27 | gRadar.Run(); 28 | } 29 | gEntCache.Clear(); 30 | } 31 | 32 | std::this_thread::sleep_for(std::chrono::milliseconds(1)); 33 | } 34 | } 35 | 36 | Beep(300, 200); //Beep 37 | Beep(200, 200); //Boop 38 | 39 | gMem.Clear(); 40 | 41 | return Util::Detach(lpParam); 42 | } 43 | 44 | BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) 45 | { 46 | switch (fdwReason) 47 | { 48 | case DLL_PROCESS_ATTACH: 49 | { 50 | if (auto hEntry = CreateThread(0, 0, MainThread, hinstDLL, 0, 0)) 51 | CloseHandle(hEntry); 52 | 53 | break; 54 | } 55 | 56 | default: 57 | { 58 | break; 59 | } 60 | } 61 | 62 | return TRUE; 63 | } -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/SDK/Includes/Classes.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/SDK/Includes/Const.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #define FL_ONGROUND (1<<0) 4 | #define FL_DUCKING (1<<1) 5 | #define FL_WATERJUMP (1<<2) 6 | #define FL_ONTRAIN (1<<3) 7 | #define FL_INRAIN (1<<4) 8 | #define FL_FROZEN (1<<5) 9 | #define FL_ATCONTROLS (1<<6) 10 | #define FL_CLIENT (1<<7) 11 | #define FL_FAKECLIENT (1<<8) 12 | 13 | #define LIFE_ALIVE 0 14 | #define LIFE_DYING 1 15 | #define LIFE_DEAD 2 16 | #define LIFE_RESPAWNABLE 3 17 | #define LIFE_DISCARDBODY 4 18 | 19 | #define MAX_PLAYERS 64 -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/SDK/Includes/Enums.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | enum EClientClass 4 | { 5 | CTestTraceline = 223, 6 | CTEWorldDecal = 224, 7 | CTESpriteSpray = 221, 8 | CTESprite = 220, 9 | CTESparks = 219, 10 | CTESmoke = 218, 11 | CTEShowLine = 216, 12 | CTEProjectedDecal = 213, 13 | CFEPlayerDecal = 71, 14 | CTEPlayerDecal = 212, 15 | CTEPhysicsProp = 209, 16 | CTEParticleSystem = 208, 17 | CTEMuzzleFlash = 207, 18 | CTELargeFunnel = 205, 19 | CTEKillPlayerAttachments = 204, 20 | CTEImpact = 203, 21 | CTEGlowSprite = 202, 22 | CTEShatterSurface = 215, 23 | CTEFootprintDecal = 199, 24 | CTEFizz = 198, 25 | CTEExplosion = 196, 26 | CTEEnergySplash = 195, 27 | CTEEffectDispatch = 194, 28 | CTEDynamicLight = 193, 29 | CTEDecal = 191, 30 | CTEClientProjectile = 190, 31 | CTEBubbleTrail = 189, 32 | CTEBubbles = 188, 33 | CTEBSPDecal = 187, 34 | CTEBreakModel = 186, 35 | CTEBloodStream = 185, 36 | CTEBloodSprite = 184, 37 | CTEBeamSpline = 183, 38 | CTEBeamRingPoint = 182, 39 | CTEBeamRing = 181, 40 | CTEBeamPoints = 180, 41 | CTEBeamLaser = 179, 42 | CTEBeamFollow = 178, 43 | CTEBeamEnts = 177, 44 | CTEBeamEntPoint = 176, 45 | CTEBaseBeam = 175, 46 | CTEArmorRicochet = 174, 47 | CTEMetalSparks = 206, 48 | CSteamJet = 167, 49 | CSmokeStack = 157, 50 | DustTrail = 275, 51 | CFireTrail = 74, 52 | SporeTrail = 281, 53 | SporeExplosion = 280, 54 | RocketTrail = 278, 55 | SmokeTrail = 279, 56 | CPropVehicleDriveable = 144, 57 | ParticleSmokeGrenade = 277, 58 | CParticleFire = 116, 59 | MovieExplosion = 276, 60 | CTEGaussExplosion = 201, 61 | CEnvQuadraticBeam = 66, 62 | CEmbers = 55, 63 | CEnvWind = 70, 64 | CPrecipitation = 137, 65 | CPrecipitationBlocker = 138, 66 | CBaseTempEntity = 18, 67 | NextBotCombatCharacter = 0, 68 | CEconWearable = 54, 69 | CBaseAttributableItem = 4, 70 | CEconEntity = 53, 71 | CWeaponXM1014 = 272, 72 | CWeaponTaser = 267, 73 | CTablet = 171, 74 | CSnowball = 158, 75 | CSmokeGrenade = 155, 76 | CWeaponShield = 265, 77 | CWeaponSG552 = 263, 78 | CSensorGrenade = 151, 79 | CWeaponSawedoff = 259, 80 | CWeaponNOVA = 255, 81 | CIncendiaryGrenade = 99, 82 | CMolotovGrenade = 112, 83 | CMelee = 111, 84 | CWeaponM3 = 247, 85 | CKnifeGG = 108, 86 | CKnife = 107, 87 | CHEGrenade = 96, 88 | CFlashbang = 77, 89 | CFists = 76, 90 | CWeaponElite = 238, 91 | CDecoyGrenade = 47, 92 | CDEagle = 46, 93 | CWeaponUSP = 271, 94 | CWeaponM249 = 246, 95 | CWeaponUMP45 = 270, 96 | CWeaponTMP = 269, 97 | CWeaponTec9 = 268, 98 | CWeaponSSG08 = 266, 99 | CWeaponSG556 = 264, 100 | CWeaponSG550 = 262, 101 | CWeaponScout = 261, 102 | CWeaponSCAR20 = 260, 103 | CSCAR17 = 149, 104 | CWeaponP90 = 258, 105 | CWeaponP250 = 257, 106 | CWeaponP228 = 256, 107 | CWeaponNegev = 254, 108 | CWeaponMP9 = 253, 109 | CWeaponMP7 = 252, 110 | CWeaponMP5Navy = 251, 111 | CWeaponMag7 = 250, 112 | CWeaponMAC10 = 249, 113 | CWeaponM4A1 = 248, 114 | CWeaponHKP2000 = 245, 115 | CWeaponGlock = 244, 116 | CWeaponGalilAR = 243, 117 | CWeaponGalil = 242, 118 | CWeaponG3SG1 = 241, 119 | CWeaponFiveSeven = 240, 120 | CWeaponFamas = 239, 121 | CWeaponBizon = 234, 122 | CWeaponAWP = 232, 123 | CWeaponAug = 231, 124 | CAK47 = 1, 125 | CWeaponCSBaseGun = 236, 126 | CWeaponCSBase = 235, 127 | CC4 = 34, 128 | CBumpMine = 32, 129 | CBumpMineProjectile = 33, 130 | CBreachCharge = 28, 131 | CBreachChargeProjectile = 29, 132 | CWeaponBaseItem = 233, 133 | CBaseCSGrenade = 8, 134 | CSnowballProjectile = 160, 135 | CSnowballPile = 159, 136 | CSmokeGrenadeProjectile = 156, 137 | CSensorGrenadeProjectile = 152, 138 | CMolotovProjectile = 113, 139 | CItem_Healthshot = 104, 140 | CItemDogtags = 106, 141 | CDecoyProjectile = 48, 142 | CPhysPropRadarJammer = 126, 143 | CPhysPropWeaponUpgrade = 127, 144 | CPhysPropAmmoBox = 124, 145 | CPhysPropLootCrate = 125, 146 | CItemCash = 105, 147 | CEnvGasCanister = 63, 148 | CDronegun = 50, 149 | CParadropChopper = 115, 150 | CSurvivalSpawnChopper = 170, 151 | CBRC4Target = 27, 152 | CInfoMapRegion = 102, 153 | CFireCrackerBlast = 72, 154 | CInferno = 100, 155 | CChicken = 36, 156 | CDrone = 49, 157 | CFootstepControl = 79, 158 | CCSGameRulesProxy = 39, 159 | CWeaponCubemap = 0, 160 | CWeaponCycler = 237, 161 | CTEPlantBomb = 210, 162 | CTEFireBullets = 197, 163 | CTERadioIcon = 214, 164 | CPlantedC4 = 128, 165 | CCSTeam = 43, 166 | CCSPlayerResource = 41, 167 | CCSPlayer = 40, 168 | CPlayerPing = 130, 169 | CCSRagdoll = 42, 170 | CTEPlayerAnimEvent = 211, 171 | CHostage = 97, 172 | CHostageCarriableProp = 98, 173 | CBaseCSGrenadeProjectile = 9, 174 | CHandleTest = 95, 175 | CTeamplayRoundBasedRulesProxy = 173, 176 | CSpriteTrail = 165, 177 | CSpriteOriented = 164, 178 | CSprite = 163, 179 | CRagdollPropAttached = 147, 180 | CRagdollProp = 146, 181 | CPropCounter = 141, 182 | CPredictedViewModel = 139, 183 | CPoseController = 135, 184 | CGrassBurn = 94, 185 | CGameRulesProxy = 93, 186 | CInfoLadderDismount = 101, 187 | CFuncLadder = 85, 188 | CTEFoundryHelpers = 200, 189 | CEnvDetailController = 61, 190 | CDangerZone = 44, 191 | CDangerZoneController = 45, 192 | CWorldVguiText = 274, 193 | CWorld = 273, 194 | CWaterLODControl = 230, 195 | CWaterBullet = 229, 196 | CVoteController = 228, 197 | CVGuiScreen = 227, 198 | CPropJeep = 143, 199 | CPropVehicleChoreoGeneric = 0, 200 | CTriggerSoundOperator = 226, 201 | CBaseVPhysicsTrigger = 22, 202 | CTriggerPlayerMovement = 225, 203 | CBaseTrigger = 20, 204 | CTest_ProxyToggle_Networkable = 222, 205 | CTesla = 217, 206 | CBaseTeamObjectiveResource = 17, 207 | CTeam = 172, 208 | CSunlightShadowControl = 169, 209 | CSun = 168, 210 | CParticlePerformanceMonitor = 117, 211 | CSpotlightEnd = 162, 212 | CSpatialEntity = 161, 213 | CSlideshowDisplay = 154, 214 | CShadowControl = 153, 215 | CSceneEntity = 150, 216 | CRopeKeyframe = 148, 217 | CRagdollManager = 145, 218 | CPhysicsPropMultiplayer = 122, 219 | CPhysBoxMultiplayer = 120, 220 | CPropDoorRotating = 142, 221 | CBasePropDoor = 16, 222 | CDynamicProp = 52, 223 | CProp_Hallucination = 140, 224 | CPostProcessController = 136, 225 | CPointWorldText = 134, 226 | CPointCommentaryNode = 133, 227 | CPointCamera = 132, 228 | CPlayerResource = 131, 229 | CPlasma = 129, 230 | CPhysMagnet = 123, 231 | CPhysicsProp = 121, 232 | CStatueProp = 166, 233 | CPhysBox = 119, 234 | CParticleSystem = 118, 235 | CMovieDisplay = 114, 236 | CMaterialModifyControl = 110, 237 | CLightGlow = 109, 238 | CItemAssaultSuitUseable = 0, 239 | CItem = 0, 240 | CInfoOverlayAccessor = 103, 241 | CFuncTrackTrain = 92, 242 | CFuncSmokeVolume = 91, 243 | CFuncRotating = 90, 244 | CFuncReflectiveGlass = 89, 245 | CFuncOccluder = 88, 246 | CFuncMoveLinear = 87, 247 | CFuncMonitor = 86, 248 | CFunc_LOD = 81, 249 | CTEDust = 192, 250 | CFunc_Dust = 80, 251 | CFuncConveyor = 84, 252 | CFuncBrush = 83, 253 | CBreakableSurface = 31, 254 | CFuncAreaPortalWindow = 82, 255 | CFish = 75, 256 | CFireSmoke = 73, 257 | CEnvTonemapController = 69, 258 | CEnvScreenEffect = 67, 259 | CEnvScreenOverlay = 68, 260 | CEnvProjectedTexture = 65, 261 | CEnvParticleScript = 64, 262 | CFogController = 78, 263 | CEnvDOFController = 62, 264 | CCascadeLight = 35, 265 | CEnvAmbientLight = 60, 266 | CEntityParticleTrail = 59, 267 | CEntityFreezing = 58, 268 | CEntityFlame = 57, 269 | CEntityDissolve = 56, 270 | CDynamicLight = 51, 271 | CColorCorrectionVolume = 38, 272 | CColorCorrection = 37, 273 | CBreakableProp = 30, 274 | CBeamSpotlight = 25, 275 | CBaseButton = 5, 276 | CBaseToggle = 19, 277 | CBasePlayer = 15, 278 | CBaseFlex = 12, 279 | CBaseEntity = 11, 280 | CBaseDoor = 10, 281 | CBaseCombatCharacter = 6, 282 | CBaseAnimatingOverlay = 3, 283 | CBoneFollower = 26, 284 | CBaseAnimating = 2, 285 | CAI_BaseNPC = 0, 286 | CBeam = 24, 287 | CBaseViewModel = 21, 288 | CBaseParticleEntity = 14, 289 | CBaseGrenade = 13, 290 | CBaseCombatWeapon = 7, 291 | CBaseWeaponWorldModel = 23 292 | }; -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/SDK/Includes/Offsets.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/SDK/Includes/Structs.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/SDK/Main/BaseEntity/BaseEntity.cpp: -------------------------------------------------------------------------------- 1 | #include "BaseEntity.h" 2 | 3 | void C_BaseEntity::SetSpotted(bool bState) 4 | { 5 | gMem.lpWrite(this + Core::Offsets::m_bSpotted, bState); 6 | } 7 | 8 | int C_BaseEntity::GetHealth() const 9 | { 10 | return gMem.lpRead(this + Core::Offsets::m_iHealth); 11 | } 12 | 13 | int C_BaseEntity::GetFlags() const 14 | { 15 | return gMem.lpRead(this + Core::Offsets::m_fFlags); 16 | } 17 | 18 | int C_BaseEntity::GetCrosshairID() const 19 | { 20 | return gMem.lpRead(this + Core::Offsets::m_iCrosshairId); 21 | } 22 | 23 | int C_BaseEntity::GetTeamNum() const 24 | { 25 | return gMem.lpRead(this + Core::Offsets::m_iTeamNum); 26 | } 27 | 28 | int C_BaseEntity::GetOwner() const 29 | { 30 | return gMem.lpRead(this + Core::Offsets::m_hOwnerEntity); 31 | } 32 | 33 | int C_BaseEntity::GetGlowIndex() const 34 | { 35 | return gMem.lpRead(this + Core::Offsets::m_iGlowIndex); 36 | } 37 | 38 | int C_BaseEntity::GetIndex() const 39 | { 40 | int m_nVT = gMem.lpRead(this + 0x8); 41 | return gMem.Read(m_nVT + 9 * 0x4); 42 | } 43 | 44 | int C_BaseEntity::GetClassID() const 45 | { 46 | int m_nVT = gMem.lpRead(this + 0x8); //Networkable 47 | int m_nFN = gMem.Read(m_nVT + 2 * 0x4); //GetClientClass 48 | int m_nCC = gMem.Read(m_nFN + 0x1); //sClientClass 49 | return gMem.Read(m_nCC + 20); //And finally, class ID 50 | } 51 | 52 | bool C_BaseEntity::IsImmune() const 53 | { 54 | return gMem.lpRead(this + Core::Offsets::m_bGunGameImmunity); 55 | } 56 | 57 | bool C_BaseEntity::IsDormant() const 58 | { 59 | return gMem.lpRead(this + Core::Offsets::m_bDormant); 60 | } 61 | 62 | bool C_BaseEntity::IsSpotted() const 63 | { 64 | return gMem.lpRead(this + Core::Offsets::m_bSpotted); 65 | } 66 | 67 | bool C_BaseEntity::IsOnGround() const 68 | { 69 | return (GetFlags() & FL_ONGROUND); 70 | } 71 | 72 | bool C_BaseEntity::IsInValidTeam() const 73 | { 74 | int m_nTeam = GetTeamNum(); 75 | return (m_nTeam == 2 || m_nTeam == 3); 76 | } 77 | 78 | bool C_BaseEntity::IsAlive() const 79 | { 80 | return (GetLifeState() == LIFE_ALIVE); 81 | } 82 | 83 | byte C_BaseEntity::GetLifeState() const 84 | { 85 | return gMem.lpRead(this + Core::Offsets::m_lifeState); 86 | } 87 | 88 | Vec3 C_BaseEntity::GetVecOrigin() const 89 | { 90 | return gMem.lpRead(this + Core::Offsets::m_vecOrigin); 91 | } 92 | 93 | Vec3 C_BaseEntity::GetAimPunch() const 94 | { 95 | return gMem.lpRead(this + Core::Offsets::m_aimPunchAngle); 96 | } 97 | 98 | Vec3 C_BaseEntity::GetEyePos() const 99 | { 100 | return (gMem.lpRead(this + Core::Offsets::m_vecViewOffset)) + GetVecOrigin(); 101 | } 102 | 103 | Vec3 C_BaseEntity::GetBonePos(int nBoneID) const 104 | { 105 | Vec3 vBone = Vec3(); 106 | 107 | if (const auto dwBase = GetBoneMatrix()) 108 | { 109 | vBone.x = gMem.Read(dwBase + 0x30 * nBoneID + 0x0C); 110 | vBone.y = gMem.Read(dwBase + 0x30 * nBoneID + 0x1C); 111 | vBone.z = gMem.Read(dwBase + 0x30 * nBoneID + 0x2C); 112 | } 113 | 114 | return vBone; 115 | } 116 | 117 | DWORD C_BaseEntity::GetBoneMatrix() const 118 | { 119 | return gMem.lpRead(this + Core::Offsets::m_dwBoneMatrix); 120 | } -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/SDK/Main/BaseEntity/BaseEntity.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../SDK.h" 4 | 5 | class C_BaseEntity 6 | { 7 | public: 8 | void SetSpotted(bool bState); 9 | 10 | int GetHealth() const; 11 | int GetCrosshairID() const; 12 | int GetFlags() const; 13 | int GetGlowIndex() const; 14 | int GetOwner() const; 15 | int GetTeamNum() const; 16 | int GetClassID() const; 17 | int GetIndex() const; 18 | 19 | bool IsDormant() const; 20 | bool IsAlive() const; 21 | bool IsInValidTeam() const; 22 | bool IsSpotted() const; 23 | bool IsOnGround() const; 24 | bool IsImmune() const; 25 | 26 | Vec3 GetVecOrigin() const; 27 | Vec3 GetAimPunch() const; 28 | Vec3 GetEyePos() const; 29 | Vec3 GetBonePos(int nBoneID) const; 30 | 31 | DWORD GetBoneMatrix() const; 32 | 33 | byte GetLifeState() const; 34 | }; -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/SDK/Main/ClientState/ClientState.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Lak3/CSGO-InternalExternal/c6301bd34a1c34dc874a60d045e29ccd10917976/CSGOIntExt/CSGO/SDK/Main/ClientState/ClientState.cpp -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/SDK/Main/ClientState/ClientState.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Lak3/CSGO-InternalExternal/c6301bd34a1c34dc874a60d045e29ccd10917976/CSGOIntExt/CSGO/SDK/Main/ClientState/ClientState.h -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/SDK/Main/Engine/Engine.cpp: -------------------------------------------------------------------------------- 1 | #include "Engine.h" 2 | 3 | C_Engine gEngine; 4 | 5 | bool C_Engine::TrainingSoftware() 6 | { 7 | //if (gMem.GetProcess(Core::String::szSteam) || gMem.GetProcess(Core::String::szCSGO)) 8 | // return Util::ErrorBox(Core::String::szFailSteam); 9 | 10 | Util::InfoBox(Core::String::szInfoWaiting); 11 | 12 | while (!gMem.GetProcess(Core::String::szCSGO)) 13 | std::this_thread::sleep_for(std::chrono::seconds(1)); 14 | 15 | while (!Core::GameWindow) 16 | Core::GameWindow = Util::FindWind(Core::String::szCSGOWindow); 17 | 18 | if (!gMem.m_hProcess || !gMem.m_dwPID) 19 | return Util::ErrorBox(Core::String::szFailHandle); 20 | 21 | //Once we get client, engine should be ready too, so I'll just wait for client. 22 | while (!Core::Client) 23 | { 24 | Core::Client = gMem.GetModule(Core::String::szClientDLL); 25 | std::this_thread::sleep_for(std::chrono::seconds(1)); 26 | Core::Engine = gMem.GetModule(Core::String::szEngineDLL); 27 | } 28 | 29 | if (!Core::Client || !Core::Engine) 30 | return Util::ErrorBox(Core::String::szFailModules); 31 | 32 | return true; //Fuck yeah. 33 | } 34 | 35 | void C_Engine::SetViewAngles(Vec3 vAngle) 36 | { 37 | gMem.Write(GetClientState() + Core::Offsets::dwClientState_ViewAngles, vAngle); 38 | } 39 | 40 | int C_Engine::GetMaxUsedServerIndex() 41 | { 42 | return gMem.Read(Core::Client + Core::Offsets::dwEntityList + 0x24); 43 | } 44 | 45 | bool C_Engine::IsGameFocused() 46 | { 47 | return (GetForegroundWindow() == Core::GameWindow); 48 | } 49 | 50 | C_BaseEntity* C_Engine::GetLocalPlayer() 51 | { 52 | return gMem.Read(Core::Client + Core::Offsets::dwLocalPlayer); 53 | } 54 | 55 | C_BaseEntity* C_Engine::GetEntity(int nIndex) 56 | { 57 | return gMem.Read(Core::Client + Core::Offsets::dwEntityList + (nIndex * 0x10)); 58 | } 59 | 60 | DWORD C_Engine::GetClientState() 61 | { 62 | return gMem.Read(Core::Engine + Core::Offsets::dwClientState); 63 | } 64 | 65 | DWORD C_Engine::GetGlowManager() 66 | { 67 | return gMem.Read(Core::Client + Core::Offsets::dwGlowObjectManager); 68 | } 69 | 70 | Vec3 C_Engine::GetViewAngles() 71 | { 72 | return gMem.Read(GetClientState() + Core::Offsets::dwClientState_ViewAngles); 73 | } -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/SDK/Main/Engine/Engine.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../SDK.h" 4 | 5 | //"Engine" 6 | class C_BaseEntity; 7 | class C_Engine 8 | { 9 | public: 10 | bool TrainingSoftware(); 11 | void SetViewAngles(Vec3 vAngle); 12 | int GetMaxUsedServerIndex(); 13 | bool IsGameFocused(); 14 | C_BaseEntity* GetLocalPlayer(); 15 | C_BaseEntity* GetEntity(int nIndex); 16 | DWORD GetClientState(); 17 | DWORD GetGlowManager(); 18 | Vec3 GetViewAngles(); 19 | }; 20 | 21 | extern C_Engine gEngine; -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/SDK/Main/EntityCache/EntityCache.cpp: -------------------------------------------------------------------------------- 1 | #include "EntityCache.h" 2 | 3 | C_EntityCache gEntCache; 4 | 5 | void C_EntityCache::Fill() 6 | { 7 | auto _pLocal = gEngine.GetLocalPlayer(); 8 | 9 | if (_pLocal && _pLocal->IsInValidTeam()) 10 | { 11 | pLocal = _pLocal; 12 | pCrossEnt = gEngine.GetEntity((pLocal->GetCrosshairID() - 1)); 13 | 14 | for (int n = 0; n < gEngine.GetMaxUsedServerIndex(); n++) 15 | { 16 | auto pEntity = gEngine.GetEntity(n); 17 | 18 | if (!pEntity || !pEntity->IsAlive() || pEntity->IsDormant() || pEntity == pLocal) 19 | continue; 20 | 21 | switch (pEntity->GetClassID()) 22 | { 23 | case CCSPlayer: 24 | { 25 | Groups[GroupType_t::PLAYERS_ALL].push_back(pEntity); 26 | Groups[pEntity->GetTeamNum() != pLocal->GetTeamNum() ? GroupType_t::PLAYERS_ENEMIES : GroupType_t::PLAYERS_TEAMMATES].push_back(pEntity); 27 | break; 28 | } 29 | 30 | case CChicken: 31 | { 32 | Groups[GroupType_t::CHICKEN_ALL].push_back(pEntity); 33 | break; 34 | } 35 | } 36 | } 37 | } 38 | } 39 | 40 | void C_EntityCache::Clear() 41 | { 42 | pLocal = nullptr; 43 | pCrossEnt = nullptr; 44 | 45 | for (auto& group : Groups) 46 | group.second.clear(); 47 | } 48 | 49 | const std::vector& C_EntityCache::GetGroup(const GroupType_t& group) 50 | { 51 | return Groups[group]; 52 | } -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/SDK/Main/EntityCache/EntityCache.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../SDK.h" 4 | 5 | enum struct GroupType_t 6 | { 7 | PLAYERS_ALL, 8 | PLAYERS_ENEMIES, 9 | PLAYERS_TEAMMATES, 10 | 11 | CHICKEN_ALL 12 | }; 13 | 14 | class C_BaseEntity; 15 | class C_EntityCache 16 | { 17 | public: 18 | void Fill(); 19 | void Clear(); 20 | 21 | C_BaseEntity* pLocal; 22 | C_BaseEntity* pCrossEnt; 23 | const std::vector& GetGroup(const GroupType_t& group); 24 | 25 | private: 26 | std::map> Groups; 27 | }; 28 | 29 | extern C_EntityCache gEntCache; -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/SDK/SDK.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #include 27 | #include 28 | #include 29 | #include 30 | #include 31 | #include 32 | #include 33 | #include 34 | 35 | #include "Includes/Enums.h" 36 | #include "Includes/Classes.h" 37 | #include "Includes/Structs.h" 38 | 39 | #include "../Utils/Utils.h" 40 | #include "../Utils/Math/Math.h" 41 | #include "../Utils/Memory/Memory.h" 42 | 43 | #include "Main/Engine/Engine.h" 44 | #include "Main/BaseEntity/BaseEntity.h" 45 | #include "Main/EntityCache/EntityCache.h" 46 | #include "Main/ClientState/ClientState.h" 47 | 48 | #include "Includes/Const.h" 49 | #include "Includes/Enums.h" 50 | #include "Includes/Structs.h" 51 | #include "Includes/Classes.h" 52 | 53 | namespace Core 54 | { 55 | inline DWORD Client = 0x0; 56 | inline DWORD Engine = 0x0; 57 | 58 | inline HWND GameWindow = nullptr; 59 | 60 | namespace Vars 61 | { 62 | namespace Aimbot 63 | { 64 | inline bool Active = true; 65 | inline bool CurveAim = false; 66 | inline bool AimPlayers = true; 67 | inline bool IgnoreTeam = true; 68 | inline bool SortByDistance = false; 69 | inline bool SmoothAim = true; 70 | inline bool AimChicken = false; 71 | inline int nKey = 0x01; 72 | inline int nBone = 8; 73 | inline float flFov = 3.0f; 74 | inline float flSmooth = 5.0f; 75 | inline float flCurveX = 1.3f; 76 | inline float flCurveY = 3.7f; 77 | } 78 | 79 | namespace Trigger 80 | { 81 | inline bool Active = true; 82 | inline bool Players = true; 83 | inline bool IgnoreTeam = true; 84 | inline bool IgnoreJumping = false; 85 | inline bool WaitForPunch = true; 86 | inline bool OnlyOnGround = true; 87 | inline bool Chickens = true; 88 | inline int nKey = 0x06; 89 | } 90 | 91 | namespace Glow 92 | { 93 | inline bool Active = true; 94 | inline bool Players = true; 95 | inline bool IgnoreTeam = true; 96 | } 97 | 98 | namespace Radar 99 | { 100 | inline bool Active = false; 101 | } 102 | 103 | namespace Misc 104 | { 105 | inline bool Bunnyhop = true; 106 | } 107 | } 108 | 109 | namespace Offsets 110 | { 111 | constexpr std::int32_t m_fFlags = 0x104; 112 | constexpr std::int32_t m_iHealth = 0x100; 113 | constexpr std::int32_t m_iTeamNum = 0xF4; 114 | constexpr std::int32_t m_bDormant = 0xED; 115 | constexpr std::int32_t m_bSpotted = 0x93D; 116 | constexpr std::int32_t m_vecOrigin = 0x138; 117 | constexpr std::int32_t m_lifeState = 0x25F; 118 | constexpr std::int32_t m_hOwner = 0x29CC; 119 | constexpr std::int32_t m_hOwnerEntity = 0x14C; 120 | constexpr std::int32_t m_iGlowIndex = 0xA438; 121 | constexpr std::int32_t m_iCrosshairId = 0xB3E4; 122 | constexpr std::int32_t m_aimPunchAngle = 0x302C; 123 | constexpr std::int32_t dwEntityList = 0x4D5022C; 124 | constexpr std::int32_t dwLocalPlayer = 0xD3BC5C; 125 | constexpr std::int32_t m_dwBoneMatrix = 0x26A8; 126 | constexpr std::int32_t m_bGunGameImmunity = 0x3944; 127 | constexpr std::int32_t m_vecViewOffset = 0x108; 128 | constexpr std::int32_t dwClientState = 0x589DD4; 129 | constexpr std::int32_t dwClientState_MapDirectory = 0x188; 130 | constexpr std::int32_t dwClientState_MaxPlayer = 0x388; 131 | constexpr std::int32_t dwClientState_State = 0x108; 132 | constexpr std::int32_t dwClientState_ViewAngles = 0x4D88; 133 | constexpr std::int32_t dwGlowObjectManager = 0x5298078; 134 | } 135 | 136 | //These have no real meaning lol. 137 | namespace String 138 | { 139 | constexpr std::string_view szCSGO("csgo.exe"); 140 | constexpr std::string_view szSteam("steam.exe"); 141 | constexpr std::string_view szClientDLL("client.dll"); 142 | constexpr std::string_view szEngineDLL("engine.dll"); 143 | constexpr std::string_view szCSGOWindow("Counter-Strike: Global Offensive"); 144 | 145 | constexpr std::string_view szFailModules("Failed to get module(s)."); 146 | constexpr std::string_view szFailExe("Failed to find csgo.exe."); 147 | constexpr std::string_view szFailConsole("Failed to alloc console."); 148 | constexpr std::string_view szFailHandle("Invalid handle or PID (NULL)."); 149 | constexpr std::string_view szFailSteam("Close Steam/CSGO before injecting!"); 150 | 151 | constexpr std::string_view szInfoWaiting("Injected, close this and run Steam/CSGO!"); 152 | } 153 | } -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/Utils/Math/Math.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include //std::isfinite std::remainder 4 | #include //FLT_EPSILON 5 | #include //std::min std::max 6 | 7 | #define M_RADPI 57.295779513082 8 | #define PI 3.14159265358979323846 9 | #define DEG2RAD(x) ((float)(x) * (float)((float)(PI) / 180.0f)) 10 | #define RAD2DEG(x) ((float)(x) * (float)(180.0f / (float)(PI))) 11 | 12 | #pragma warning (disable : 26495) 13 | #pragma warning (disable : 26451) 14 | #pragma warning (disable : 4244) 15 | 16 | #undef min 17 | #undef max 18 | 19 | class Vec2 20 | { 21 | public: 22 | Vec2(void) 23 | { 24 | x = y = 0.0f; 25 | } 26 | 27 | Vec2(float X, float Y) 28 | { 29 | x = X; y = Y; 30 | } 31 | 32 | Vec2(float* v) 33 | { 34 | x = v[0]; y = v[1]; 35 | } 36 | 37 | Vec2(const float* v) 38 | { 39 | x = v[0]; y = v[1]; 40 | } 41 | 42 | Vec2(const Vec2& v) 43 | { 44 | x = v.x; y = v.y; 45 | } 46 | 47 | Vec2& operator=(const Vec2& v) 48 | { 49 | x = v.x; y = v.y; return *this; 50 | } 51 | 52 | float& operator[](int i) 53 | { 54 | return ((float*)this)[i]; 55 | } 56 | 57 | float operator[](int i) const 58 | { 59 | return ((float*)this)[i]; 60 | } 61 | 62 | Vec2& operator+=(const Vec2& v) 63 | { 64 | x += v.x; y += v.y; return *this; 65 | } 66 | 67 | Vec2& operator-=(const Vec2& v) 68 | { 69 | x -= v.x; y -= v.y; return *this; 70 | } 71 | 72 | Vec2& operator*=(const Vec2& v) 73 | { 74 | x *= v.x; y *= v.y; return *this; 75 | } 76 | 77 | Vec2& operator/=(const Vec2& v) 78 | { 79 | x /= v.x; y /= v.y; return *this; 80 | } 81 | 82 | Vec2& operator+=(float v) 83 | { 84 | x += v; y += v; return *this; 85 | } 86 | 87 | Vec2& operator-=(float v) 88 | { 89 | x -= v; y -= v; return *this; 90 | } 91 | 92 | Vec2& operator*=(float v) 93 | { 94 | x *= v; y *= v; return *this; 95 | } 96 | 97 | Vec2& operator/=(float v) 98 | { 99 | x /= v; y /= v; return *this; 100 | } 101 | 102 | Vec2 operator+(const Vec2& v) const 103 | { 104 | return Vec2(x + v.x, y + v.y); 105 | } 106 | 107 | Vec2 operator-(const Vec2& v) const 108 | { 109 | return Vec2(x - v.x, y - v.y); 110 | } 111 | 112 | Vec2 operator*(const Vec2& v) const 113 | { 114 | return Vec2(x * v.x, y * v.y); 115 | } 116 | 117 | Vec2 operator/(const Vec2& v) const 118 | { 119 | return Vec2(x / v.x, y / v.y); 120 | } 121 | 122 | Vec2 operator+(float v) const 123 | { 124 | return Vec2(x + v, y + v); 125 | } 126 | 127 | Vec2 operator-(float v) const 128 | { 129 | return Vec2(x - v, y - v); 130 | } 131 | 132 | Vec2 operator*(float v) const 133 | { 134 | return Vec2(x * v, y * v); 135 | } 136 | 137 | Vec2 operator/(float v) const 138 | { 139 | return Vec2(x / v, y / v); 140 | } 141 | 142 | void Set(float X = 0.0f, float Y = 0.0f) 143 | { 144 | x = X; y = Y; 145 | } 146 | 147 | float Lenght(void) const 148 | { 149 | return sqrtf(x * x + y * y); 150 | } 151 | 152 | float LenghtSqr(void) const 153 | { 154 | return (x * x + y * y); 155 | } 156 | 157 | float DistTo(const Vec2& v) const 158 | { 159 | return (*this - v).Lenght(); 160 | } 161 | 162 | float DistToSqr(const Vec2& v) const 163 | { 164 | return (*this - v).LenghtSqr(); 165 | } 166 | 167 | float Dot(const Vec2& v) const 168 | { 169 | return (x * v.x + y * v.y); 170 | } 171 | 172 | bool IsZero(void) const 173 | { 174 | return (x > -0.01f && x < 0.01f && 175 | y > -0.01f && y < 0.01f); 176 | } 177 | 178 | public: 179 | float x, y; 180 | }; 181 | 182 | class Vec3 183 | { 184 | public: 185 | Vec3(void) 186 | { 187 | x = y = z = 0.0f; 188 | } 189 | 190 | void Zero() 191 | { 192 | x = y = z = 0.f; 193 | } 194 | 195 | Vec3(float X, float Y, float Z) 196 | { 197 | x = X; y = Y; z = Z; 198 | } 199 | 200 | Vec3(float* v) 201 | { 202 | x = v[0]; y = v[1]; z = v[2]; 203 | } 204 | 205 | Vec3(const float* v) 206 | { 207 | x = v[0]; y = v[1]; z = v[2]; 208 | } 209 | 210 | Vec3(const Vec3& v) 211 | { 212 | x = v.x; y = v.y; z = v.z; 213 | } 214 | 215 | Vec3(const Vec2& v) 216 | { 217 | x = v.x; y = v.y; z = 0.0f; 218 | } 219 | 220 | Vec3& operator=(const Vec3& v) 221 | { 222 | x = v.x; y = v.y; z = v.z; return *this; 223 | } 224 | 225 | Vec3& operator=(const Vec2& v) 226 | { 227 | x = v.x; y = v.y; z = 0.0f; return *this; 228 | } 229 | 230 | float& operator[](int i) 231 | { 232 | return ((float*)this)[i]; 233 | } 234 | 235 | float operator[](int i) const 236 | { 237 | return ((float*)this)[i]; 238 | } 239 | 240 | Vec3& operator+=(const Vec3& v) 241 | { 242 | x += v.x; y += v.y; z += v.z; return *this; 243 | } 244 | 245 | Vec3& operator-=(const Vec3& v) 246 | { 247 | x -= v.x; y -= v.y; z -= v.z; return *this; 248 | } 249 | 250 | Vec3& operator*=(const Vec3& v) 251 | { 252 | x *= v.x; y *= v.y; z *= v.z; return *this; 253 | } 254 | 255 | Vec3& operator/=(const Vec3& v) 256 | { 257 | x /= v.x; y /= v.y; z /= v.z; return *this; 258 | } 259 | 260 | Vec3& operator+=(float v) 261 | { 262 | x += v; y += v; z += v; return *this; 263 | } 264 | 265 | Vec3& operator-=(float v) 266 | { 267 | x -= v; y -= v; z -= v; return *this; 268 | } 269 | 270 | Vec3& operator*=(float v) 271 | { 272 | x *= v; y *= v; z *= v; return *this; 273 | } 274 | 275 | Vec3& operator/=(float v) 276 | { 277 | x /= v; y /= v; z /= v; return *this; 278 | } 279 | 280 | Vec3 operator+(const Vec3& v) const 281 | { 282 | return Vec3(x + v.x, y + v.y, z + v.z); 283 | } 284 | 285 | Vec3 operator-(const Vec3& v) const 286 | { 287 | return Vec3(x - v.x, y - v.y, z - v.z); 288 | } 289 | 290 | Vec3 operator*(const Vec3& v) const 291 | { 292 | return Vec3(x * v.x, y * v.y, z * v.z); 293 | } 294 | 295 | Vec3 operator/(const Vec3& v) const 296 | { 297 | return Vec3(x / v.x, y / v.y, z / v.z); 298 | } 299 | 300 | Vec3 operator+(float v) const 301 | { 302 | return Vec3(x + v, y + v, z + v); 303 | } 304 | 305 | Vec3 operator-(float v) const 306 | { 307 | return Vec3(x - v, y - v, z - v); 308 | } 309 | 310 | Vec3 operator*(float v) const 311 | { 312 | return Vec3(x * v, y * v, z * v); 313 | } 314 | 315 | Vec3 operator/(float v) const 316 | { 317 | return Vec3(x / v, y / v, z / v); 318 | } 319 | 320 | void Set(float X = 0.0f, float Y = 0.0f, float Z = 0.0f) 321 | { 322 | x = X; y = Y; z = Z; 323 | } 324 | 325 | float Lenght(void) const 326 | { 327 | return sqrtf(x * x + y * y + z * z); 328 | } 329 | 330 | float LenghtSqr(void) const 331 | { 332 | return (x * x + y * y + z * z); 333 | } 334 | 335 | float Normalize() 336 | { 337 | float fl_lenght = Lenght(); 338 | float fl_lenght_normal = 1.f / (FLT_EPSILON + fl_lenght); 339 | 340 | x = x * fl_lenght_normal; 341 | y = y * fl_lenght_normal; 342 | z = z * fl_lenght_normal; 343 | 344 | return fl_lenght; 345 | } 346 | 347 | float NormalizeInPlace() 348 | { 349 | return Normalize(); 350 | } 351 | 352 | float Lenght2D(void) const 353 | { 354 | return sqrtf(x * x + y * y); 355 | } 356 | 357 | float Lenght2DSqr(void) const 358 | { 359 | return (x * x + y * y); 360 | } 361 | 362 | float DistTo(const Vec3& v) const 363 | { 364 | return (*this - v).Lenght(); 365 | } 366 | 367 | float DistToSqr(const Vec3& v) const 368 | { 369 | return (*this - v).LenghtSqr(); 370 | } 371 | 372 | float Dot(const Vec3& v) const 373 | { 374 | return (x * v.x + y * v.y + z * v.z); 375 | } 376 | 377 | Vec3 Cross(const Vec3& v) const 378 | { 379 | return Vec3(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x); 380 | } 381 | 382 | bool IsZero(void) const 383 | { 384 | return (x > -0.01f && x < 0.01f && 385 | y > -0.01f && y < 0.01f && 386 | z > -0.01f && z < 0.01f); 387 | } 388 | 389 | Vec3 Scale(float fl) { 390 | return Vec3(x * fl, y * fl, z * fl); 391 | } 392 | 393 | void Init(float ix, float iy, float iz) 394 | { 395 | x = ix; y = iy; z = iz; 396 | } 397 | 398 | public: 399 | float x, y, z; 400 | }; 401 | 402 | class __declspec(align(16))VectorAligned : public Vec3 403 | { 404 | public: 405 | inline VectorAligned(void) { }; 406 | 407 | inline VectorAligned(float x, float y, float z) { 408 | Set(x, y, z); 409 | } 410 | 411 | explicit VectorAligned(const Vec3& othr) { 412 | Set(othr.x, othr.y, othr.z); 413 | } 414 | 415 | VectorAligned& operator=(const Vec3& othr) { 416 | Set(othr.x, othr.y, othr.z); 417 | return *this; 418 | } 419 | 420 | float w; 421 | }; 422 | 423 | typedef float matrix3x4[3][4]; 424 | 425 | namespace Math 426 | { 427 | inline double __declspec (naked) __fastcall FastSqrt(double n) 428 | { 429 | _asm fld qword ptr[esp + 4] 430 | _asm fsqrt 431 | _asm ret 8 432 | } 433 | 434 | inline void SinCos(float radians, float* sine, float* cosine) 435 | { 436 | _asm 437 | { 438 | fld DWORD PTR[radians] 439 | fsincos 440 | 441 | mov edx, DWORD PTR[cosine] 442 | mov eax, DWORD PTR[sine] 443 | 444 | fstp DWORD PTR[edx] 445 | fstp DWORD PTR[eax] 446 | } 447 | } 448 | 449 | inline float NormalizeAngle(float ang) 450 | { 451 | if (!std::isfinite(ang)) 452 | return 0.0f; 453 | 454 | return std::remainder(ang, 360.0f); 455 | } 456 | 457 | inline void ClampAngles(Vec3& v) 458 | { 459 | v.x = std::max(-89.0f, std::min(89.0f, NormalizeAngle(v.x))); 460 | v.y = NormalizeAngle(v.y); 461 | v.z = 0.0f; 462 | } 463 | 464 | inline void VectorTransform(const Vec3& input, const matrix3x4& matrix, Vec3& output) 465 | { 466 | for (auto i = 0; i < 3; i++) 467 | output[i] = input.Dot((Vec3&)matrix[i]) + matrix[i][3]; 468 | } 469 | 470 | inline void AngleVectors(const Vec3& angles, Vec3* forward) 471 | { 472 | float sp, sy, cp, cy; 473 | 474 | SinCos(DEG2RAD(angles.x), &sp, &cp); 475 | SinCos(DEG2RAD(angles.y), &sy, &cy); 476 | 477 | if (forward) 478 | { 479 | forward->x = cp * cy; 480 | forward->y = cp * sy; 481 | forward->z = -sp; 482 | } 483 | } 484 | 485 | inline void AngleVectors(const Vec3 &angles, Vec3 *forward, Vec3 *right, Vec3 *up) 486 | { 487 | float sr, sp, sy, cr, cp, cy; 488 | SinCos(DEG2RAD(angles.x), &sp, &cp); 489 | SinCos(DEG2RAD(angles.y), &sy, &cy); 490 | SinCos(DEG2RAD(angles.z), &sr, &cr); 491 | 492 | if (forward) { 493 | forward->x = cp * cy; 494 | forward->y = cp * sy; 495 | forward->z = -sp; 496 | } 497 | 498 | if (right) { 499 | right->x = (-1 * sr * sp * cy + -1 * cr * -sy); 500 | right->y = (-1 * sr * sp * sy + -1 * cr * cy); 501 | right->z = -1 * sr * cp; 502 | } 503 | 504 | if (up) { 505 | up->x = (cr * sp * cy + -sr * -sy); 506 | up->y = (cr * sp * sy + -sr * cy); 507 | up->z = cr * cp; 508 | } 509 | } 510 | 511 | inline void AngleNormalize(Vec3& vector) 512 | { 513 | for (auto i = 0; i < 3; i++) 514 | { 515 | if (vector[i] < -180.0f) vector[i] += 360.0f; 516 | if (vector[i] > 180.0f) vector[i] -= 360.0f; 517 | } 518 | } 519 | 520 | inline float VectorNormalize(Vec3& vector) 521 | { 522 | float lenght = vector.Lenght(); 523 | 524 | if (!lenght) 525 | vector.Set(); 526 | else 527 | vector /= lenght; 528 | 529 | return lenght; 530 | } 531 | 532 | inline Vec3 CalcAngle(const Vec3& source, const Vec3& destination) 533 | { 534 | Vec3 angles = Vec3(0.0f, 0.0f, 0.0f); 535 | Vec3 delta = (source - destination); 536 | float fHyp = FastSqrt((delta.x * delta.x) + (delta.y * delta.y)); 537 | 538 | angles.x = (atanf(delta.z / fHyp) * M_RADPI); 539 | angles.y = (atanf(delta.y / delta.x) * M_RADPI); 540 | angles.z = 0.0f; 541 | 542 | if (delta.x >= 0.0f) 543 | angles.y += 180.0f; 544 | 545 | return angles; 546 | } 547 | 548 | inline float CalcFov(const Vec3& src, const Vec3& dst) 549 | { 550 | Vec3 v_src = Vec3(); 551 | AngleVectors(src, &v_src); 552 | 553 | Vec3 v_dst = Vec3(); 554 | AngleVectors(dst, &v_dst); 555 | 556 | float result = RAD2DEG(acos(v_dst.Dot(v_src) / v_dst.LenghtSqr())); 557 | 558 | if (!isfinite(result) || isinf(result) || isnan(result)) 559 | result = 0.0f; 560 | 561 | return result; 562 | } 563 | 564 | inline void CreateVector(const Vec3& angle, Vec3& vector) 565 | { 566 | float pitch, yaw, tmp; 567 | 568 | pitch = float(angle[0] * PI / 180); 569 | yaw = float(angle[1] * PI / 180); 570 | tmp = float(cos(pitch)); 571 | 572 | vector[0] = float(-tmp * -cos(yaw)); 573 | vector[1] = float(sin(yaw) * tmp); 574 | vector[2] = float(-sin(pitch)); 575 | } 576 | 577 | inline void VectorAngles(const Vec3& forward, Vec3& angles) 578 | { 579 | float tmp, yaw, pitch; 580 | 581 | if (forward.y == 0 && forward.x == 0) 582 | { 583 | yaw = 0; 584 | 585 | if (forward.z > 0) 586 | pitch = 270; 587 | else 588 | pitch = 90; 589 | } 590 | 591 | else 592 | { 593 | yaw = RAD2DEG(atan2f(forward.y, forward.x)); 594 | 595 | if (yaw < 0) 596 | yaw += 360; 597 | 598 | tmp = forward.Lenght2D(); 599 | pitch = RAD2DEG(atan2f(-forward.z, tmp)); 600 | 601 | if (pitch < 0) 602 | pitch += 360; 603 | } 604 | 605 | angles[0] = pitch; 606 | angles[1] = yaw; 607 | angles[2] = 0; 608 | } 609 | 610 | inline float GetFov(const Vec3& angle, const Vec3& source, const Vec3& destination) 611 | { 612 | Vec3 ang, aim; 613 | float mag, u_dot_v; 614 | ang = CalcAngle(source, destination); 615 | 616 | CreateVector(angle, aim); 617 | CreateVector(ang, ang); 618 | 619 | mag = sqrtf(pow(aim.x, 2) + pow(aim.y, 2) + pow(aim.z, 2)); 620 | u_dot_v = aim.Dot(ang); 621 | 622 | return RAD2DEG(acos(u_dot_v / (pow(mag, 2)))); 623 | } 624 | 625 | inline Vec3 NormalizedAngle(const Vec3& angles) 626 | { 627 | static float sp, sy, cp, cy; 628 | 629 | Math::SinCos(DEG2RAD(angles.x), &sp, &cp); 630 | Math::SinCos(DEG2RAD(angles.y), &sy, &cy); 631 | 632 | Vec3 forward = { cp * cy, cp * sy, -sp }; 633 | forward *= (1.f / (FLT_EPSILON + forward.Lenght())); 634 | return forward; 635 | } 636 | 637 | inline float RandFloat(float min, float max) 638 | { 639 | return (min + 1) + (((float)rand()) / (float)RAND_MAX) * (max - (min + 1)); 640 | } 641 | 642 | inline float EaseInBack(float x) 643 | { 644 | const float c1 = 1.70158f; 645 | const float c3 = c1 + 1.0f; 646 | return c3 * x * x * x - c1 * x * x; 647 | } 648 | 649 | inline float EaseInOutSine(float x) 650 | { 651 | return -(cos(PI * x) - 1.0f) / 2.0f; 652 | } 653 | 654 | inline float MapFloat(float x, float in_min, float in_max, float out_min, float out_max) { 655 | return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min; 656 | } 657 | } -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/Utils/Memory/Memory.cpp: -------------------------------------------------------------------------------- 1 | #include "Memory.h" 2 | 3 | C_Memory gMem; 4 | 5 | void C_Memory::Clear() 6 | { 7 | if (m_lpAlloc) VirtualFreeEx(m_hProcess, m_lpAlloc, 0, MEM_RELEASE); 8 | if (m_hProcess) CloseHandle(m_hProcess); 9 | } 10 | 11 | bool C_Memory::GetProcess(std::string_view szName) 12 | { 13 | if (auto hProcess = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL)) 14 | { 15 | PROCESSENTRY32 ProcEntry; 16 | ProcEntry.dwSize = sizeof(ProcEntry); 17 | 18 | while (Process32Next(hProcess, &ProcEntry)) 19 | { 20 | if (ProcEntry.szExeFile == szName) 21 | { 22 | CloseHandle(hProcess); 23 | 24 | m_dwPID = ProcEntry.th32ProcessID; 25 | m_hProcess = OpenProcess(0x38, FALSE, m_dwPID); 26 | 27 | return true; //Return success 28 | } 29 | } 30 | 31 | CloseHandle(hProcess); 32 | } 33 | 34 | return false; //Return failure 35 | } 36 | 37 | DWORD C_Memory::GetModule(std::string_view szModule) 38 | { 39 | if (auto hModule = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, m_dwPID)) 40 | { 41 | MODULEENTRY32 ModEntry; 42 | ModEntry.dwSize = sizeof(ModEntry); 43 | 44 | while (Module32Next(hModule, &ModEntry)) 45 | { 46 | if (ModEntry.szModule == szModule) 47 | { 48 | CloseHandle(hModule); 49 | return reinterpret_cast(ModEntry.modBaseAddr); 50 | } 51 | } 52 | 53 | CloseHandle(hModule); 54 | } 55 | 56 | return 0x0; 57 | } 58 | 59 | DWORD C_Memory::GetModuleSize(std::string_view szModule) 60 | { 61 | if (auto hModule = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, m_dwPID)) 62 | { 63 | MODULEENTRY32 ModEntry; 64 | ModEntry.dwSize = sizeof(ModEntry); 65 | 66 | while (Module32Next(hModule, &ModEntry)) 67 | { 68 | if (ModEntry.szModule == szModule) 69 | { 70 | CloseHandle(hModule); 71 | return ModEntry.modBaseSize; 72 | } 73 | } 74 | 75 | CloseHandle(hModule); 76 | } 77 | 78 | return 0x0; 79 | } -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/Utils/Memory/Memory.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../SDK/SDK.h" 4 | 5 | class C_Memory 6 | { 7 | public: 8 | DWORD m_dwPID = 0x0; 9 | HANDLE m_hProcess = 0; 10 | LPVOID m_lpAlloc = nullptr; 11 | 12 | public: 13 | template 14 | cDataType lpRead(LPCVOID lpBase) 15 | { 16 | cDataType Data; 17 | ReadProcessMemory(m_hProcess, lpBase, &Data, sizeof(cDataType), NULL); 18 | return Data; 19 | } 20 | 21 | template 22 | cDataType Read(DWORD dwBase) 23 | { 24 | cDataType Data; 25 | ReadProcessMemory(m_hProcess, reinterpret_cast(dwBase), &Data, sizeof(cDataType), NULL); 26 | return Data; 27 | } 28 | 29 | template 30 | void lpWrite(LPVOID lpBase, cDataType dwBuff) 31 | { 32 | WriteProcessMemory(m_hProcess, lpBase, &dwBuff, sizeof(cDataType), NULL); 33 | } 34 | 35 | template 36 | void Write(DWORD dwBase, cDataType dwBuff) 37 | { 38 | WriteProcessMemory(m_hProcess, reinterpret_cast(dwBase), &dwBuff, sizeof(cDataType), NULL); 39 | } 40 | 41 | public: 42 | void Clear(); 43 | 44 | bool GetProcess(std::string_view szName); 45 | DWORD GetModule(std::string_view szName); 46 | DWORD GetModuleSize(std::string_view szName); 47 | 48 | }; 49 | 50 | extern C_Memory gMem; -------------------------------------------------------------------------------- /CSGOIntExt/CSGO/Utils/Utils.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #pragma warning( disable : 4996 ) //smh 4 | 5 | namespace Util 6 | { 7 | inline int nConAlloc = FALSE; 8 | 9 | inline int RandInt(int nMin, int nMax) 10 | { 11 | std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<> distr(nMin, nMax); 12 | return distr(gen); 13 | } 14 | 15 | inline BOOL InitCon() 16 | { 17 | nConAlloc = AllocConsole(); 18 | 19 | if (nConAlloc) 20 | { 21 | static_cast(freopen("CONIN$", "r", stdin)); 22 | static_cast(freopen("CONOUT$", "w", stdout)); 23 | static_cast(freopen("CONOUT$", "w", stderr)); 24 | } 25 | 26 | return nConAlloc; 27 | } 28 | 29 | inline int Detach(LPVOID lpParam) 30 | { 31 | if (nConAlloc) FreeConsole(); 32 | 33 | FreeLibraryAndExitThread(static_cast(lpParam), EXIT_SUCCESS); 34 | 35 | return EXIT_SUCCESS; 36 | } 37 | 38 | inline bool ErrorBox(std::string_view szMessage) 39 | { 40 | MessageBoxA(0, szMessage.data(), "Error blyat(", MB_ICONERROR); 41 | return false; 42 | } 43 | 44 | inline void InfoBox(std::string_view szMessage) 45 | { 46 | MessageBoxA(0, szMessage.data(), "Info blyat)", MB_ICONINFORMATION); 47 | } 48 | 49 | inline bool IsKeyDown(int nKey) 50 | { 51 | return (GetAsyncKeyState(nKey) & 0x8000); 52 | } 53 | 54 | inline HWND FindWind(std::string_view szName) 55 | { 56 | std::this_thread::sleep_for(std::chrono::seconds(1)); 57 | return FindWindowA(0, szName.data()); 58 | } 59 | } -------------------------------------------------------------------------------- /CSGOIntExt/CSGOIntExt.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | Debug 14 | x64 15 | 16 | 17 | Release 18 | x64 19 | 20 | 21 | 22 | 16.0 23 | Win32Proj 24 | {61598c8a-31cd-49d9-9fb1-0f62318239a6} 25 | CSGOIntExt 26 | 10.0 27 | 28 | 29 | 30 | DynamicLibrary 31 | true 32 | v142 33 | MultiByte 34 | 35 | 36 | DynamicLibrary 37 | false 38 | v142 39 | true 40 | MultiByte 41 | 42 | 43 | DynamicLibrary 44 | true 45 | v142 46 | Unicode 47 | 48 | 49 | DynamicLibrary 50 | false 51 | v142 52 | true 53 | Unicode 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | true 75 | 76 | 77 | false 78 | 79 | 80 | true 81 | 82 | 83 | false 84 | 85 | 86 | 87 | Level3 88 | true 89 | WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) 90 | true 91 | stdcpp17 92 | 93 | 94 | Console 95 | true 96 | 97 | 98 | 99 | 100 | Level3 101 | true 102 | true 103 | true 104 | WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 105 | true 106 | stdcpp17 107 | 108 | 109 | Console 110 | true 111 | true 112 | true 113 | 114 | 115 | 116 | 117 | Level3 118 | true 119 | _DEBUG;_CONSOLE;%(PreprocessorDefinitions) 120 | true 121 | stdcpp17 122 | 123 | 124 | Console 125 | true 126 | 127 | 128 | 129 | 130 | Level3 131 | true 132 | true 133 | true 134 | NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 135 | true 136 | stdcpp17 137 | 138 | 139 | Console 140 | true 141 | true 142 | true 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | -------------------------------------------------------------------------------- /CSGOIntExt/CSGOIntExt.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {a8bdf980-eb4f-4259-b9a0-e5e57401a7d6} 6 | 7 | 8 | {c322eebb-5166-434c-8d4f-c28db8dc616c} 9 | 10 | 11 | {49486f49-da55-4407-a244-2435dc56061a} 12 | 13 | 14 | {ec50c89d-f444-4989-a702-0e8d31a3282e} 15 | 16 | 17 | {f6b76cd5-db24-41d3-823d-fb13b7cebc0b} 18 | 19 | 20 | {83417a01-33f8-4d58-8fbd-fbd92a6fc33d} 21 | 22 | 23 | {500c6df8-8553-4182-98ba-23d67494ce1d} 24 | 25 | 26 | {7187da3a-c92b-4d96-8cbc-ee0da39ef9d8} 27 | 28 | 29 | {e4a68851-c381-43b9-acef-1c5286e96667} 30 | 31 | 32 | {50c9e7c7-7caa-4ed8-9b3a-0d1116b71cf9} 33 | 34 | 35 | {f7e740ba-c55d-476a-b48d-e1b092357b98} 36 | 37 | 38 | {6247d1ea-7073-483c-a600-0e30db26eff4} 39 | 40 | 41 | {9b251b53-9705-4d52-ac10-65848f875dc6} 42 | 43 | 44 | {673e68e8-d8a4-4d5a-b583-482a70b4f60f} 45 | 46 | 47 | {dbe42cdf-f54a-486a-ae84-d75bf35f3686} 48 | 49 | 50 | {36f6e946-f234-451c-8265-ab6b5e0987d1} 51 | 52 | 53 | {435f87e5-c6aa-403e-a2f6-1e3d145c5c31} 54 | 55 | 56 | 57 | 58 | Utils 59 | 60 | 61 | Utils\Memory 62 | 63 | 64 | SDK 65 | 66 | 67 | SDK\Main\EntityCache 68 | 69 | 70 | SDK\Main\BaseEntity 71 | 72 | 73 | SDK\Includes 74 | 75 | 76 | SDK\Includes 77 | 78 | 79 | SDK\Includes 80 | 81 | 82 | Features\Misc 83 | 84 | 85 | Features\Triggerbot 86 | 87 | 88 | SDK\Includes 89 | 90 | 91 | Utils\Math 92 | 93 | 94 | SDK\Includes 95 | 96 | 97 | SDK\Main\Engine 98 | 99 | 100 | Features\Visual\Radar 101 | 102 | 103 | Features\Visual\Glow 104 | 105 | 106 | Features\Aimbot 107 | 108 | 109 | SDK\Main\ClientState 110 | 111 | 112 | 113 | 114 | Utils\Memory 115 | 116 | 117 | SDK\Main\EntityCache 118 | 119 | 120 | SDK\Main\BaseEntity 121 | 122 | 123 | Features\Misc 124 | 125 | 126 | Features\Triggerbot 127 | 128 | 129 | 130 | SDK\Main\Engine 131 | 132 | 133 | Features\Visual\Radar 134 | 135 | 136 | Features\Visual\Glow 137 | 138 | 139 | Features\Aimbot 140 | 141 | 142 | SDK\Main\ClientState 143 | 144 | 145 | -------------------------------------------------------------------------------- /CSGOIntExt/CSGOIntExt.vcxproj.user: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # CSGO-InternalExternal 2 | Training software example for CSGO. Includes entity caching and aimbot with ability to easily add new targets. 3 | --------------------------------------------------------------------------------