304 lines
8.1 KiB
C++
304 lines
8.1 KiB
C++
#include "Hooks.h"
|
|
#include "W2S.h"
|
|
#include "CRC.h"
|
|
extern Vector4D_t Get2DBox(Vector_t WorldPosition, const float Height);
|
|
extern VOID Recoil(CCSGOInput* Input);
|
|
extern VOID TriggerBot(CCSGOInput* pInput);
|
|
|
|
static const std::unordered_map<std::string, size_t> ClassTrimMap =
|
|
{
|
|
{"C_Knife", 2},
|
|
{"C_Weapon", 8},
|
|
{"C_DEagle", 2},
|
|
{"C_Flashbang", 2},
|
|
{"C_SmokeGrenade", 2},
|
|
{"C_HEGrenade", 2},
|
|
{"C_IncendiaryGrenade", 2},
|
|
{"C_DecoyGrenade", 2},
|
|
{"C_WeaponSCAR20", 8},
|
|
{"C_C4", 2},
|
|
{"C_AK47", 2},
|
|
{"C_MolotovGrenade", 2},
|
|
{"C_PlantedC4", 9},
|
|
{"CBaseAnimGraph", 0}
|
|
|
|
};
|
|
|
|
inline void PlayerEntities(C_BaseEntity* pEntity, SchemaClassInfoData_t* pClassInfo, CCSGOInput* pInput)
|
|
{
|
|
if (FNV1A::Hash(pClassInfo->szName) != FNV1A::HashConst("CCSPlayerController"))
|
|
return;
|
|
|
|
CCSPlayerController* Controller = reinterpret_cast<CCSPlayerController*>(pEntity);
|
|
|
|
if (Controller == nullptr || Controller->IsLocalPlayerController())
|
|
return;
|
|
|
|
C_CSPlayerPawn* Pawn = I::GameResourceService->pGameEntitySystem->Get<C_CSPlayerPawn>(Controller->GetPawnHandle());
|
|
|
|
if (Pawn == nullptr)
|
|
return;
|
|
|
|
if (Pawn->GetHealth() == 0 && !Controller->IsPawnAlive())
|
|
return;
|
|
|
|
if (!Pawn->IsOtherEnemy())
|
|
return;
|
|
|
|
CGameSceneNode* GameSceneNode = Pawn->GetGameSceneNode();
|
|
if (GameSceneNode == nullptr)
|
|
return;
|
|
|
|
CSkeletonInstance* Skeleton = GameSceneNode->GetSkeletonInstance();
|
|
if (Skeleton == nullptr)
|
|
return;
|
|
|
|
C_CSWeaponBase* CSWeaponBase = Pawn->CSWeaponBase();
|
|
|
|
if (CSWeaponBase == nullptr)
|
|
return;
|
|
|
|
CBoneData Bones;
|
|
PlayerEntity Entity;
|
|
|
|
Entity.Controller.m_sSanitizedPlayerName = Controller->GetPlayerName();
|
|
Entity.Pawn.Health = Pawn->GetHealth();
|
|
Entity.Pawn.m_vOldOrigin = Pawn->GetOrigin();
|
|
Entity.Pawn.isVisible = Pawn->EyeVisible(SDK::LocalPawn, Pawn);
|
|
Entity.Pawn.CSWeaponBase = CSWeaponBase;
|
|
|
|
Entity.Pawn.Rectangle = Get2DBox(Entity.Pawn.m_vOldOrigin, 75.0f);
|
|
Entity.Pawn.BoneData.BonePositions.clear();
|
|
Entity.Pawn.BoneData.BonePositions.resize(104);
|
|
|
|
for (const auto& BoneList : BoneJointList::List)
|
|
{
|
|
for (const auto& BoneIndex : BoneList)
|
|
{
|
|
if (BoneIndex >= Entity.Pawn.BoneData.BonePositions.size())
|
|
continue;
|
|
|
|
GetBone(Skeleton, Bones, BoneIndex);
|
|
BonePosition Position;
|
|
Position.Location = Bones.Location;
|
|
Position.WorldVisible = View.WorldToScreen(Bones.Location, Position.ScreenPosition);
|
|
Position.RayTraceVisible = Pawn->BoneVisible(SDK::LocalPawn, Pawn, Position.Location);
|
|
Entity.Pawn.BoneData.BonePositions[BoneIndex] = Position;
|
|
}
|
|
}
|
|
|
|
Entity.CanHit = Pawn->TriggerHit(SDK::LocalPawn, Pawn, pInput, Entity.Pawn.BoneData);
|
|
|
|
NextPlayerList->push_back(Entity);
|
|
}
|
|
|
|
|
|
inline VOID WeaponEntities(C_BaseEntity* pEntity, SchemaClassInfoData_t* pClassInfo)
|
|
{
|
|
|
|
std::string ClassName = pClassInfo->szName;
|
|
|
|
for (const auto& [key, trimLength] : ClassTrimMap)
|
|
{
|
|
if (ClassName.find(key) != std::string::npos)
|
|
{
|
|
ClassName = ClassName.substr(trimLength);
|
|
cWeaponEntity->Name = ClassName;
|
|
|
|
C_CSWeaponBase* CSWeaponBase = reinterpret_cast<C_CSWeaponBase*>(pEntity);
|
|
|
|
if (CSWeaponBase == nullptr)
|
|
return;
|
|
|
|
CGameSceneNode* GameSceneNode = CSWeaponBase->GetGameSceneNode();
|
|
|
|
if (GameSceneNode == nullptr)
|
|
return;
|
|
|
|
cWeaponEntity->isWeapon = CSWeaponBase->IsWeapon();
|
|
cWeaponEntity->WorldPosition = GameSceneNode->GetOrigin();
|
|
cWeaponEntity->CSWeaponBase = CSWeaponBase;
|
|
|
|
NextWeaponList->push_back(*cWeaponEntity);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
inline VOID ChickenEntities(C_BaseEntity* pEntity, SchemaClassInfoData_t* pClassInfo)
|
|
{
|
|
|
|
if (FNV1A::Hash(pClassInfo->szName) != FNV1A::HashConst("C_Chicken"))
|
|
return;
|
|
|
|
C_Chicken* CChicken = reinterpret_cast<C_Chicken*>(pEntity);
|
|
|
|
if (CChicken == nullptr)
|
|
return;
|
|
|
|
CGameSceneNode* GameSceneNode = CChicken->GetGameSceneNode();
|
|
|
|
if (GameSceneNode == nullptr)
|
|
return;
|
|
|
|
CurrentChickenEntity->Chicken.Name = "Chicken";
|
|
CurrentChickenEntity->Chicken.WorldPosition = GameSceneNode->GetOrigin();
|
|
CurrentChickenEntity->Chicken.isVisible = CChicken->ChickenVisible(SDK::LocalPawn, CChicken);
|
|
CurrentChickenEntity->Chicken.Rectangle = Get2DBox(CurrentChickenEntity->Chicken.WorldPosition, 25.0f);
|
|
|
|
NextChickenList->push_back(*CurrentChickenEntity);
|
|
}
|
|
|
|
|
|
inline VOID InfernoEntities(C_BaseEntity* pEntity, SchemaClassInfoData_t* pClassInfo)
|
|
{
|
|
if (FNV1A::Hash(pClassInfo->szName) != FNV1A::HashConst("C_Inferno"))
|
|
return;
|
|
|
|
C_Inferno* Molotov = reinterpret_cast<C_Inferno*>(pEntity);
|
|
|
|
if (Molotov == nullptr)
|
|
return;
|
|
|
|
int EntityID = reinterpret_cast<int>(pEntity);
|
|
|
|
if (Molotov->IsBurning())
|
|
{
|
|
auto& Entity = ActiveInfernoEntities[EntityID];
|
|
Entity.Inferno.WorldPosition = Molotov->GetFirePositions();
|
|
Entity.Inferno.Base = Molotov;
|
|
|
|
if (Entity.StartTime == std::chrono::steady_clock::time_point())
|
|
{
|
|
Entity.StartTime = std::chrono::steady_clock::now();
|
|
Entity.UniqueInfernoID = NextInfernoID++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ActiveInfernoEntities.erase(EntityID);
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
VOID SkyBox(C_EnvSky* eSky)
|
|
{
|
|
if (MenuConfig::LightChanger == false || eSky == nullptr)
|
|
return;
|
|
|
|
eSky->m_vTintColorLightingOnly() = Color_t(
|
|
MenuConfig::g_SkyboxColor.x * 255.f,
|
|
MenuConfig::g_SkyboxColor.y * 255.f,
|
|
MenuConfig::g_SkyboxColor.z * 255.f,
|
|
MenuConfig::g_SkyboxColor.w * 255.f
|
|
);
|
|
|
|
eSky->m_vTintColor() = Color_t(
|
|
MenuConfig::g_SkyboxColor.x * 255.f,
|
|
MenuConfig::g_SkyboxColor.y * 255.f,
|
|
MenuConfig::g_SkyboxColor.z * 255.f,
|
|
MenuConfig::g_SkyboxColor.w * 255.f
|
|
);
|
|
|
|
OriginalUpdateSkybox(eSky);
|
|
}
|
|
|
|
VOID SmokeColor(C_SmokeGrenadeProjectile* Smoke)
|
|
{
|
|
if (MenuConfig::EnableSmokeColor && Smoke != nullptr)
|
|
Smoke->m_vSmokeColor() = MenuConfig::SmokeColorPicker;
|
|
|
|
}
|
|
|
|
bool __fastcall hkCreateMove(CCSGOInput* pInput, int nSlot, bool bActive)
|
|
{
|
|
NextPlayerList->clear(), NextWeaponList->clear(), NextChickenList->clear();
|
|
|
|
const bool bResult = FakeReturnAddress(Offsets->GameData.ReturnAddress, CreateMove, pInput, nSlot, bActive);
|
|
|
|
if (!I::Engine->IsConnected() || !I::Engine->IsInGame())
|
|
return bResult;
|
|
|
|
SDK::LocalController = CCSPlayerController::GetLocalPlayerController();
|
|
|
|
if (SDK::LocalController == nullptr)
|
|
return bResult;
|
|
|
|
SDK::LocalPawn = I::GameResourceService->pGameEntitySystem->Get<C_CSPlayerPawn>(SDK::LocalController->GetPawnHandle());
|
|
|
|
if (SDK::LocalPawn == nullptr)
|
|
return bResult;
|
|
|
|
CUserCmd* pCmd = pInput->GetUserCmd();
|
|
|
|
if (pCmd == nullptr)
|
|
return bResult;
|
|
|
|
SDK::Cmd = pCmd;
|
|
|
|
CBaseUserCmdPB* pBaseCmd = pCmd->csgoUserCmd.pBaseCmd;
|
|
|
|
if (pBaseCmd == nullptr)
|
|
return bResult;
|
|
|
|
for (int nIndex = 1; nIndex <= I::GameResourceService->pGameEntitySystem->GetHighestEntityIndex(); nIndex++)
|
|
{
|
|
|
|
C_BaseEntity* pEntity = I::GameResourceService->pGameEntitySystem->Get(nIndex);
|
|
|
|
if (pEntity == nullptr)
|
|
continue;
|
|
|
|
pEntity->GetSchemaClassInfo(&pClassInfo);
|
|
|
|
if (pClassInfo == nullptr)
|
|
continue;
|
|
|
|
PlayerEntities(pEntity, pClassInfo, pInput);
|
|
WeaponEntities(pEntity, pClassInfo);
|
|
ChickenEntities(pEntity, pClassInfo);
|
|
InfernoEntities(pEntity, pClassInfo);
|
|
|
|
if (FNV1A::Hash(pClassInfo->szName) == FNV1A::HashConst("C_EnvSky"))
|
|
g_pEnvSky = reinterpret_cast<C_EnvSky*>(pEntity);
|
|
|
|
if (FNV1A::Hash(pClassInfo->szName) == FNV1A::HashConst("C_SmokeGrenadeProjectile"))
|
|
g_pSmokeGrenadeProjectile = reinterpret_cast<C_SmokeGrenadeProjectile*>(pEntity);
|
|
|
|
}
|
|
|
|
std::swap(CurrentPlayerList, NextPlayerList), std::swap(CurrentWeaponList, NextWeaponList), std::swap(CurrentChickenList, NextChickenList);
|
|
|
|
SkyBox(g_pEnvSky);
|
|
SmokeColor(g_pSmokeGrenadeProjectile);
|
|
|
|
if (SDK::LocalPawn->GetHealth() > 0 && SDK::LocalController->IsPawnAlive())
|
|
{
|
|
SilentAim(pCmd);
|
|
Aimbot(pInput);
|
|
Recoil(pInput);
|
|
TriggerBot(pInput);
|
|
}
|
|
|
|
CRC::Save(SDK::Cmd->csgoUserCmd.pBaseCmd);
|
|
|
|
if (CRC::CalculateCRC(SDK::Cmd->csgoUserCmd.pBaseCmd) == true)
|
|
CRC::Apply(SDK::Cmd);
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
|
|
void __fastcall hkLightingModulation(__int64 a1, cAggregateSceneObject* SceneObject, __int64 a3)
|
|
{
|
|
|
|
SceneObject->R = MenuConfig::wModulation.LightingColor.x * MenuConfig::wModulation.LightingIntensity;
|
|
SceneObject->G = MenuConfig::wModulation.LightingColor.y * MenuConfig::wModulation.LightingIntensity;
|
|
SceneObject->B = MenuConfig::wModulation.LightingColor.z * MenuConfig::wModulation.LightingIntensity;
|
|
|
|
return oLightingModulation(a1, SceneObject, a3);
|
|
}
|