фыв
This commit is contained in:
Oscar
@@ -0,0 +1,71 @@
|
||||
#include "antiaim.hpp"
|
||||
#include <ctime>
|
||||
#include <cmath>
|
||||
#include "../../core/variables.h"
|
||||
|
||||
void F::ANTIAIM::RunAA(CUserCmd* pCmd)
|
||||
{
|
||||
if (!C_GET(bool, Vars.bAntiAim))
|
||||
return;
|
||||
|
||||
if (!I::Engine->IsConnected() || !I::Engine->IsInGame()) // Checking if you are connected and in game
|
||||
return;
|
||||
|
||||
if (!SDK::LocalController || !SDK::LocalController->IsPawnAlive()) // Checking if your spectating and alive
|
||||
return;
|
||||
|
||||
if (pCmd->m_nButtons.m_nValue & ECommandButtons::IN_USE || pCmd->m_nButtons.m_nValue & ECommandButtons::IN_ATTACK) // Checking if you are not pressing e or attacking
|
||||
return;
|
||||
|
||||
if (int32_t nMoveType = SDK::LocalController->GetMoveType(); nMoveType == MOVETYPE_NOCLIP || nMoveType == MOVETYPE_LADDER)
|
||||
return;
|
||||
|
||||
C_CSPlayerPawn* pLocalPawn = I::GameResourceService->pGameEntitySystem->Get<C_CSPlayerPawn>(SDK::LocalController->GetPawnHandle());
|
||||
|
||||
if (pLocalPawn == nullptr)
|
||||
return;
|
||||
|
||||
if (SDK::LocalController->IsThrowingGrenade(SDK::LocalController->GetPlayerWeapon(SDK::LocalPawn)))
|
||||
return;
|
||||
|
||||
float flPitch = 0;
|
||||
float flYaw = 0;
|
||||
|
||||
switch (C_GET(int, Vars.iBaseYawType))
|
||||
{
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
flYaw += -180.f; // Backwards
|
||||
break;
|
||||
case 2:
|
||||
flYaw += 180.f; // Forwards
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
switch (C_GET(int, Vars.iPitchType))
|
||||
{
|
||||
case 0:
|
||||
break;
|
||||
case 1: // Down
|
||||
flPitch = 120.f;
|
||||
break;
|
||||
case 2: // Up
|
||||
flPitch = -120.f;
|
||||
break;
|
||||
case 3: // Zero
|
||||
flPitch = 0.f;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue.x = flPitch;
|
||||
pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue.y += flYaw;
|
||||
|
||||
pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue.y = MATH::AngleNormalize(pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue.y);
|
||||
pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue.x = MATH::AngleNormalize(pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue.x);
|
||||
pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue.z = 0.f;
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
#pragma once
|
||||
#include "../../sdk/datatypes/qangle.h"
|
||||
#include "../../sdk/entity.h"
|
||||
#include "../../sdk/interfaces/cgameentitysystem.h"
|
||||
#include "../../sdk/interfaces/iengineclient.h"
|
||||
#include "../../sdk/interfaces/ccsgoinput.h"
|
||||
#include "../../core/sdk.h"
|
||||
#include "../../core/interfaces.h"
|
||||
#include "../../sdk/datatypes/usercmd.h"
|
||||
|
||||
namespace F::ANTIAIM
|
||||
{
|
||||
inline QAngle_t angStoredViewBackup{};
|
||||
void RunAA(CUserCmd* pCmd);
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
#include "pred.h"
|
||||
#include "../../core/config.h"
|
||||
#include "../../core/variables.h"
|
||||
#include "../../sdk/datatypes/usercmd.h"
|
||||
#include "../../core/sdk.h"
|
||||
#include "../../sdk/entity.h"
|
||||
#include "../../sdk/interfaces/iengineclient.h"
|
||||
#include "../../sdk/interfaces/iglobalvars.h"
|
||||
#include "../../sdk/interfaces/cgameentitysystem.h"
|
||||
#include "../../sdk/datatypes/qangle.h"
|
||||
#include "../../sdk/datatypes/vector.h"
|
||||
|
||||
#include "../cstrike/sdk/interfaces/ccsgoinput.h"
|
||||
#include "../cstrike/sdk/interfaces/ienginecvar.h"
|
||||
#include "../lagcomp/lagcomp.h"
|
||||
#include "../cstrike/sdk/interfaces/events.h"
|
||||
#include "../penetration/penetration.h"
|
||||
#include <mutex>
|
||||
#include <array>
|
||||
static float old_current_time = 0.f;
|
||||
static float old_frame_time = 0.f;
|
||||
static std::int32_t prediction_seed = 0;
|
||||
static std::uint32_t predicted_flags = 0;
|
||||
|
||||
void F::PREDICTION::impl::start(CUserCmd* cmd)
|
||||
{
|
||||
if (!SDK::LocalController || !SDK::LocalPawn) {
|
||||
return;
|
||||
}
|
||||
auto controller = SDK::LocalController;
|
||||
if (!controller)
|
||||
return;
|
||||
|
||||
auto local = SDK::LocalPawn;
|
||||
if (!local)
|
||||
return;
|
||||
|
||||
predicted_flags = local->GetFlags();
|
||||
|
||||
// random_seed
|
||||
|
||||
old_current_time = I::GlobalVars->flCurtime;
|
||||
old_frame_time = I::GlobalVars->flFrameTime;
|
||||
|
||||
I::GlobalVars->flCurtime = controller->m_nTickBase() * I::GlobalVars->flIntervalPerTick;
|
||||
I::GlobalVars->flCurtime2 = controller->m_nTickBase() * I::GlobalVars->flIntervalPerTick;
|
||||
|
||||
I::GlobalVars->flFrameTime = I::GlobalVars->flIntervalPerTick;
|
||||
I::GlobalVars->flFrameTime2 = I::GlobalVars->flIntervalPerTick;
|
||||
|
||||
}
|
||||
|
||||
void F::PREDICTION::impl::end()
|
||||
{
|
||||
if (!SDK::LocalController || !SDK::LocalPawn) {
|
||||
return;
|
||||
}
|
||||
auto controller = SDK::LocalController;
|
||||
if (!controller)
|
||||
return;
|
||||
|
||||
auto local = SDK::LocalPawn;
|
||||
if (!local)
|
||||
return;
|
||||
|
||||
I::GlobalVars->flCurtime = old_current_time;
|
||||
I::GlobalVars->flCurtime2 = old_current_time;
|
||||
|
||||
I::GlobalVars->flFrameTime = old_current_time;
|
||||
I::GlobalVars->flFrameTime2 = old_current_time;
|
||||
}
|
||||
|
||||
std::uint32_t F::PREDICTION::impl::Flags()
|
||||
{
|
||||
return predicted_flags;
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
#pragma once
|
||||
|
||||
#include "../../common.h"
|
||||
#include <memory>
|
||||
// used: draw system
|
||||
#include "../../utilities/draw.h"
|
||||
#include "../../sdk/datatypes/vector.h"
|
||||
#include "../../sdk/datatypes/transform.h"
|
||||
#include "../../sdk/datatypes/qangle.h"
|
||||
#include "../cstrike/core/config.h"
|
||||
class CCSPlayerController;
|
||||
class C_BaseEntity;
|
||||
class C_CSPlayerPawn;
|
||||
class CBaseHandle;
|
||||
class CEntityInstance;
|
||||
class CUserCmd;
|
||||
class CBaseUserCmdPB;
|
||||
class QAngle_t;
|
||||
class IGameEvent;
|
||||
class CCSWeaponBaseVData;
|
||||
namespace F::PREDICTION
|
||||
{
|
||||
class impl {
|
||||
public:
|
||||
|
||||
void start(CUserCmd* cmd);
|
||||
|
||||
void end();
|
||||
|
||||
std::uint32_t Flags();
|
||||
|
||||
};
|
||||
const auto prediction = std::make_unique<impl>();
|
||||
}
|
||||
@@ -0,0 +1,755 @@
|
||||
#include "legit.h"
|
||||
#include "../../core/config.h"
|
||||
#include "../../core/variables.h"
|
||||
#include "../../sdk/datatypes/usercmd.h"
|
||||
#include "../../core/sdk.h"
|
||||
#include "../../sdk/entity.h"
|
||||
#include "../../sdk/interfaces/iengineclient.h"
|
||||
#include "../../sdk/interfaces/iglobalvars.h"
|
||||
#include "../../sdk/interfaces/cgameentitysystem.h"
|
||||
#include "../../sdk/datatypes/qangle.h"
|
||||
#include "../../sdk/datatypes/vector.h"
|
||||
|
||||
#include "../cstrike/sdk/interfaces/ccsgoinput.h"
|
||||
#include "../cstrike/sdk/interfaces/ienginecvar.h"
|
||||
#include "../lagcomp/lagcomp.h"
|
||||
#include "../cstrike/sdk/interfaces/events.h"
|
||||
#include "../penetration/penetration.h"
|
||||
#include "../cstrike/sdk/interfaces/itrace.h"
|
||||
#include "../cstrike/core/spoofcall/syscall.h"
|
||||
#include <iostream>
|
||||
#include <memoryapi.h>
|
||||
#include <mutex>
|
||||
#include <array>
|
||||
#include "../../core/spoofcall/virtualization/VirtualizerSDK64.h"
|
||||
#include "../../utilities/inputsystem.h"
|
||||
float lasttargettime = 0.f;
|
||||
static std::vector <std::uint32_t> e_hitboxes;
|
||||
static ImDrawList* g_pBackgroundDrawList = nullptr;
|
||||
float kill_delay = 0.f;
|
||||
|
||||
struct LegitTarget {
|
||||
C_CSPlayerPawn* player;
|
||||
Vector_t finalPoint;
|
||||
int hitgroup;
|
||||
LegitTarget(C_CSPlayerPawn* player, const QAngle_t& finalAngle, const int hitroup)
|
||||
: player(player), finalPoint(finalPoint), hitgroup(hitroup) {}
|
||||
};
|
||||
|
||||
|
||||
std::vector<LegitTarget> sortedTargets;
|
||||
std::vector<C_CSPlayerPawn*> validTargets;
|
||||
|
||||
float get_next_primary_attack(C_CSPlayerPawn* local) noexcept {
|
||||
if (!I::GlobalVars)
|
||||
return std::numeric_limits<float>::max();
|
||||
|
||||
const auto tick = local->ActiveWeapon()->m_nNextPrimaryAttackTick();
|
||||
const auto ratio = local->ActiveWeapon()->m_nNextPrimaryAttackTick();
|
||||
return (tick + ratio) * I::GlobalVars->flIntervalPerTick;
|
||||
}
|
||||
void F::LEGIT::impl::SetupTarget(C_CSPlayerPawn* pLocal)
|
||||
{
|
||||
if (!D::pDrawListActive)
|
||||
return;
|
||||
|
||||
if (!I::Engine->IsInGame()) return;
|
||||
|
||||
CCSPlayerController* pLocalController = CCSPlayerController::GetLocalPlayerController();
|
||||
if (!pLocalController)
|
||||
return;
|
||||
|
||||
pLocal = I::GameResourceService->pGameEntitySystem->Get<C_CSPlayerPawn>(pLocalController->GetPawnHandle());
|
||||
if (!pLocal)
|
||||
return;
|
||||
VIRTUALIZER_DOLPHIN_BLACK_START
|
||||
const std::lock_guard<std::mutex> guard{ g_cachedEntitiesMutex };
|
||||
|
||||
// reset valid targets before increamenting it
|
||||
legit->Reset(reset::entity);
|
||||
|
||||
for (const auto& it : g_cachedEntities) {
|
||||
|
||||
C_BaseEntity* pEntity = I::GameResourceService->pGameEntitySystem->Get(it.m_handle);
|
||||
if (pEntity == nullptr)
|
||||
continue;
|
||||
|
||||
CBaseHandle hEntity = pEntity->GetRefEHandle();
|
||||
if (hEntity != it.m_handle) continue;
|
||||
|
||||
switch (it.m_type) {
|
||||
case CachedEntity_t::PLAYER_CONTROLLER:
|
||||
CCSPlayerController* CPlayer = I::GameResourceService->pGameEntitySystem->Get<CCSPlayerController>(hEntity);
|
||||
if (CPlayer == nullptr)
|
||||
break;
|
||||
|
||||
C_CSPlayerPawn* player = I::GameResourceService->pGameEntitySystem->Get<C_CSPlayerPawn>(CPlayer->GetPawnHandle());
|
||||
if (!player)
|
||||
continue;
|
||||
|
||||
if (player->GetHealth() <= 0 || !pLocal->IsOtherEnemy(player) || player->GetGameSceneNode()->IsDormant() || player->m_bGunGameImmunity())
|
||||
continue;
|
||||
|
||||
validTargets.push_back(player);
|
||||
|
||||
continue;
|
||||
}
|
||||
}
|
||||
VIRTUALIZER_DOLPHIN_BLACK_END
|
||||
}
|
||||
bool F::LEGIT::impl::valid(C_CSPlayerPawn* player, C_CSPlayerPawn* pLocal, bool check) {
|
||||
if (!player)
|
||||
return false;
|
||||
bool a1 = check ? true : player->Visible(pLocal, TRACE_TYPE::AIMBOT, legit_data.legit_visibility_check);
|
||||
bool Invalid = player->GetLifeState() == ELifeState::LIFE_DISCARDBODY || player->GetLifeState() == ELifeState::LIFE_DEAD || player->GetLifeState() == ELifeState::LIFE_DYING;
|
||||
if (Invalid || player->GetHealth() <= 0 || !a1 || !pLocal->IsOtherEnemy(player) || player->GetGameSceneNode()->IsDormant() || player->m_bGunGameImmunity())
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// math calculations after Quarention update and shit
|
||||
// qangle conversions are a mess here tho
|
||||
QAngle_t NormalizeAngle(QAngle_t& angle) noexcept {
|
||||
angle.Clamp();
|
||||
return angle;
|
||||
}
|
||||
|
||||
QAngle_t ToAngle(const Vector_t& vec) noexcept {
|
||||
return QAngle_t{
|
||||
M_RAD2DEG(std::atan2(-vec.z, std::hypot(vec.x, vec.y))),
|
||||
M_RAD2DEG(std::atan2(vec.y, vec.x)),
|
||||
0.00f
|
||||
}.Clamp();
|
||||
}
|
||||
|
||||
static Vector_t get_target_angle(C_CSPlayerPawn* localplayer, Vector_t position)
|
||||
{
|
||||
Vector_t eye_position = localplayer->GetEyePosition();
|
||||
Vector_t angle = position;
|
||||
|
||||
angle.x = position.x - eye_position.x;
|
||||
angle.y = position.y - eye_position.y;
|
||||
angle.z = position.z - eye_position.z;
|
||||
|
||||
angle.Normalizes();
|
||||
MATH::vec_angles(angle, &angle);
|
||||
|
||||
angle.clamp();
|
||||
return angle;
|
||||
}
|
||||
|
||||
QAngle_t CalculateRelativeAngle(const Vector_t& source, const Vector_t& dest, const QAngle_t& view_angles) noexcept {
|
||||
QAngle_t delta = ToAngle(dest - source);
|
||||
|
||||
delta -= view_angles;
|
||||
|
||||
delta = NormalizeAngle(delta);
|
||||
|
||||
return delta;
|
||||
}
|
||||
|
||||
float DistanceToCrosshair(C_CSPlayerPawn* target, const Vector_t& hitboxPos)
|
||||
{
|
||||
auto center = ImGui::GetIO().DisplaySize * 0.5f;
|
||||
ImVec2 out;
|
||||
auto screenPos = D::WorldToScreen(hitboxPos, out);
|
||||
|
||||
if (screenPos) {
|
||||
ImVec2 crosshairPos = center;
|
||||
ImVec2 hitboxScreenPos = out;
|
||||
|
||||
float deltaX = crosshairPos.x - hitboxScreenPos.x;
|
||||
float deltaY = crosshairPos.y - hitboxScreenPos.y;
|
||||
|
||||
return std::sqrt(deltaX * deltaX + deltaY * deltaY);
|
||||
}
|
||||
|
||||
return FLT_MAX;
|
||||
}
|
||||
|
||||
Vector_t CalculateHitboxAngle(Vector_t source, Vector_t destination, QAngle_t viewAngles) {
|
||||
Vector_t delta = source - destination;
|
||||
Vector_t angles;
|
||||
|
||||
angles.x = M_RAD2DEG(atanf(delta.z / std::hypotf(delta.x, delta.y))) - viewAngles.x;
|
||||
angles.y = M_RAD2DEG(atanf(delta.y / delta.x)) - viewAngles.y;
|
||||
angles.z = 0.0f;
|
||||
|
||||
return angles;
|
||||
}
|
||||
|
||||
void F::LEGIT::impl::ScanTarget(C_CSPlayerPawn* pLocal, QAngle_t viewangles)
|
||||
{
|
||||
if (!pLocal)
|
||||
return;
|
||||
|
||||
if (!I::Engine->IsConnected() || !I::Engine->IsInGame()) return;
|
||||
|
||||
// Clear sortedTarget before any interaction
|
||||
sortedTargets.clear();
|
||||
|
||||
QAngle_t final_ang;
|
||||
|
||||
// Check if there are valid targets
|
||||
if (!validTargets.empty()) {
|
||||
|
||||
if (legit_data.legit_target_selection == 0) {
|
||||
std::sort(validTargets.begin(), validTargets.end(), [this, pLocal](C_CSPlayerPawn* a, C_CSPlayerPawn* b) {
|
||||
// Calculate distances
|
||||
float distA_crosshair = DistanceToCrosshair(pLocal, a->GetEyePosition());
|
||||
float distB_crosshair = DistanceToCrosshair(pLocal, b->GetEyePosition());
|
||||
|
||||
return (distA_crosshair < distB_crosshair);
|
||||
});
|
||||
}
|
||||
else {
|
||||
std::sort(validTargets.begin(), validTargets.end(), [this, pLocal](C_CSPlayerPawn* a, C_CSPlayerPawn* b) {
|
||||
float distA_player = pLocal->GetEyePosition().DistTo(a->GetEyePosition());
|
||||
float distB_player = pLocal->GetEyePosition().DistTo(b->GetEyePosition());
|
||||
|
||||
return (distA_player < distB_player);
|
||||
});
|
||||
}
|
||||
// Add the closest visible target to sortedTarget
|
||||
for (C_CSPlayerPawn* target : validTargets) {
|
||||
if (valid(target, pLocal)) {
|
||||
sortedTargets.emplace_back(target, final_ang, 0);
|
||||
break;
|
||||
}
|
||||
else {
|
||||
sortedTargets.clear();
|
||||
continue;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
// Scan hitboxes, etc.
|
||||
if (!sortedTargets.empty()) {
|
||||
|
||||
auto target = sortedTargets.front().player;
|
||||
if (!target) {
|
||||
sortedTargets.front().finalPoint.Invalidate();
|
||||
sortedTargets.clear();
|
||||
return;
|
||||
}
|
||||
|
||||
// sanity
|
||||
if (!valid(target, pLocal)) {
|
||||
sortedTargets.front().finalPoint.Invalidate();
|
||||
sortedTargets.clear();
|
||||
return;
|
||||
}
|
||||
|
||||
int bestIndex = -1;
|
||||
float closest_dist = FLT_MAX;
|
||||
auto best_fov = legit_data.legit_fov;
|
||||
|
||||
|
||||
auto eyepos = pLocal->GetEyePosition();
|
||||
auto endeyepos = target->GetEyePosition();
|
||||
float dist = pLocal->GetEyePosition().DistTo(target->GetEyePosition());
|
||||
|
||||
float hitbox_scale = {};
|
||||
Vector_t hitbox_pos = {};
|
||||
Vector4D_t hitbox_rot = {};
|
||||
Vector_t best_point = {};
|
||||
// prefer hitbox closest to crosshair ( since we legit hacking )
|
||||
for (std::uint32_t i : e_hitboxes) {
|
||||
|
||||
target->CalculateHitboxData(i, hitbox_pos, hitbox_rot, hitbox_scale);
|
||||
float cross_dist = DistanceToCrosshair(target, hitbox_pos);
|
||||
|
||||
if (cross_dist < closest_dist) {
|
||||
closest_dist = cross_dist;
|
||||
bestIndex = i;
|
||||
continue;
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
if (bestIndex != -1) { // store best aimpoint info
|
||||
sortedTargets.front().hitgroup = target->GetHitGroup(bestIndex);
|
||||
target->CalculateHitboxData(bestIndex, sortedTargets.front().finalPoint, hitbox_rot, hitbox_scale);
|
||||
}
|
||||
}
|
||||
else
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
// setup config hitboxes
|
||||
void F::LEGIT::impl::Scan() {
|
||||
|
||||
/* emplace menu hitboxes which will be used for hitscan*/
|
||||
|
||||
if (legit_data.hitbox_head) {
|
||||
e_hitboxes.emplace_back(HEAD);
|
||||
}
|
||||
|
||||
if (legit_data.hitbox_chest) {
|
||||
e_hitboxes.emplace_back(CHEST);
|
||||
e_hitboxes.emplace_back(RIGHT_CHEST);
|
||||
e_hitboxes.emplace_back(LEFT_CHEST);
|
||||
}
|
||||
|
||||
if (legit_data.hitbox_stomach) {
|
||||
e_hitboxes.emplace_back(STOMACH);
|
||||
e_hitboxes.emplace_back(CENTER);
|
||||
e_hitboxes.emplace_back(PELVIS);
|
||||
}
|
||||
|
||||
if (legit_data.hitbox_leg_l) {
|
||||
e_hitboxes.emplace_back(L_LEG);
|
||||
}
|
||||
|
||||
if (legit_data.hitbox_leg_r) {
|
||||
e_hitboxes.emplace_back(R_LEG);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
void F::LEGIT::impl::Reset(reset type) {
|
||||
switch (type) {
|
||||
case reset::entity:
|
||||
sortedTargets.clear();
|
||||
validTargets.clear();
|
||||
break;
|
||||
case reset::aimbot:
|
||||
e_hitboxes.clear();
|
||||
break;
|
||||
}
|
||||
return;
|
||||
}
|
||||
float CalculateFactor(float distance, float maxDistance, float minFactor, float maxFactor)
|
||||
{
|
||||
// Ensure distance is within valid range
|
||||
if (distance > maxDistance)
|
||||
distance = maxDistance;
|
||||
|
||||
// Calculate the factor based on the distance
|
||||
float factor = minFactor + (maxFactor - minFactor) * (1 - distance / maxDistance);
|
||||
|
||||
return factor;
|
||||
}
|
||||
QAngle_t PerformSmooth(QAngle_t currentAngles, const QAngle_t& targetAngles, float smoothFactor, C_CSPlayerPawn* pLocal, Vector_t hitboxPos)
|
||||
{
|
||||
QAngle_t smoothedAngles;
|
||||
float effectiveSmoothFactor = 0.f;
|
||||
|
||||
if (smoothFactor == 0)
|
||||
effectiveSmoothFactor = 1 * 10.0f;
|
||||
else
|
||||
effectiveSmoothFactor = smoothFactor * 10.0f;
|
||||
|
||||
// Calculate the difference between target and current angles
|
||||
QAngle_t angleDiff = targetAngles - currentAngles;
|
||||
|
||||
// Calculate the distance between the crosshair and the final point
|
||||
float distance = DistanceToCrosshair(pLocal, hitboxPos);
|
||||
|
||||
// Calculate intelligent acceleration and deceleration factors based on distance
|
||||
float accelFactor = CalculateFactor(distance, effectiveSmoothFactor, 0.1f, 1.0f);
|
||||
float decelFactor = CalculateFactor(distance, effectiveSmoothFactor, 0.1f, 1.0f);
|
||||
|
||||
// Apply acceleration and deceleration
|
||||
smoothedAngles.x = currentAngles.x + (angleDiff.x / effectiveSmoothFactor) * (accelFactor + (1));
|
||||
smoothedAngles.y = currentAngles.y + (angleDiff.y / effectiveSmoothFactor) * (accelFactor + (1));
|
||||
|
||||
// Ensure angles are within valid range
|
||||
smoothedAngles.Clamp();
|
||||
|
||||
return smoothedAngles;
|
||||
}
|
||||
|
||||
bool F::LEGIT::impl::Ready(C_CSPlayerPawn* pLocal) {
|
||||
if (!pLocal)
|
||||
return false;
|
||||
|
||||
auto ActiveWeapon = pLocal->ActiveWeapon();
|
||||
if (!ActiveWeapon)
|
||||
return false;
|
||||
|
||||
auto data = ActiveWeapon->datawep();
|
||||
if (!data)
|
||||
return false;
|
||||
|
||||
if (ActiveWeapon->clip1() <= 0)
|
||||
return false;
|
||||
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void F::LEGIT::impl::Events(IGameEvent* ev, events type) {
|
||||
if (!C_GET(bool, Vars.legit_enable))
|
||||
return;
|
||||
|
||||
if (!I::Engine->IsConnected() || !I::Engine->IsInGame())
|
||||
return;
|
||||
|
||||
if (!SDK::LocalController)
|
||||
return;
|
||||
|
||||
switch (type) {
|
||||
case player_death: {
|
||||
auto controller = SDK::LocalController;
|
||||
if (!controller)
|
||||
break;
|
||||
|
||||
const auto event_controller = ev->get_player_controller(CS_XOR("attacker"));
|
||||
if (!event_controller)
|
||||
return;
|
||||
|
||||
|
||||
if (event_controller->GetIdentity()->GetIndex() == controller->GetIdentity()->GetIndex()) {
|
||||
const std::int64_t value{ ev->get_int(CS_XOR("dmg_health")) };
|
||||
auto delay = C_GET(int, Vars.legit_delay_aim_ms) * 50.f;
|
||||
|
||||
kill_delay = I::GlobalVars->nTickCount + delay;
|
||||
// reset targets
|
||||
sortedTargets.clear();
|
||||
}
|
||||
}
|
||||
break;
|
||||
case round_start: {
|
||||
kill_delay = 0;
|
||||
legit->Reset(reset::entity);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void F::LEGIT::impl::Triggerbot(CUserCmd* cmd, C_BaseEntity* localent, C_BaseEntity* playerent, C_CSPlayerPawn* local, C_CSPlayerPawn* player, CCSWeaponBaseVData* vdata)
|
||||
{
|
||||
VIRTUALIZER_MUTATE_ONLY_START;
|
||||
if (!legit_data.trigger_enable)
|
||||
return;
|
||||
|
||||
if (!SDK::LocalController)
|
||||
return;
|
||||
|
||||
auto weapon = local->ActiveWeapon();
|
||||
if (!weapon)
|
||||
return;
|
||||
|
||||
auto data = weapon->datawep();
|
||||
if (!data)
|
||||
return;
|
||||
|
||||
if (!cmd)
|
||||
return;
|
||||
|
||||
auto base = cmd->m_csgoUserCmd.m_pBaseCmd;
|
||||
if (!base)
|
||||
return;
|
||||
|
||||
if (C_GET(bool, Vars.trigger_on_key) && !LI_FN(GetAsyncKeyState).safe()(legit_data.legit_key))
|
||||
return;
|
||||
|
||||
bool should_trigger = player->InsideCrosshair(local, base->m_pViewangles->m_angValue, data->m_flRange());
|
||||
|
||||
if (should_trigger) {
|
||||
|
||||
if (cheat->canShot)
|
||||
cmd->m_nButtons.m_nValue |= IN_ATTACK;
|
||||
}
|
||||
//F::AUTOWALL::c_auto_wall::data_t pendata;
|
||||
//F::AUTOWALL::g_auto_wall->pen(pendata, vecStart, vecEnd, playerent, localent, local, player, vdata, pen_dmg, valid);
|
||||
// check do we can shoot
|
||||
VIRTUALIZER_MUTATE_ONLY_END;
|
||||
|
||||
}
|
||||
void adjust_recoil(C_CSPlayerPawn* player, CUserCmd* pCmd) noexcept {
|
||||
if (!player || !pCmd) return;
|
||||
|
||||
auto cache = player->m_aimPunchCache();
|
||||
static QAngle_t prev = QAngle_t(0.f, 0.f, 0.f);
|
||||
auto pred_punch = cache.m_Size < 0x81 ? cache.m_Data[cache.m_Size - 1] * 2.f : player->m_aimPunchAngle() * 2.f;
|
||||
auto delta = cache.m_Size > 0 && cache.m_Size < 0x81 ? prev - pred_punch : QAngle_t(0, 0, 0);
|
||||
|
||||
if (cache.m_Size > 0 && cache.m_Size < 0x81) {
|
||||
if (delta != QAngle_t(0, 0, 0)) {
|
||||
pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue += delta;
|
||||
pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue.Clamp();
|
||||
}
|
||||
prev = pred_punch;
|
||||
}
|
||||
|
||||
}
|
||||
void F::LEGIT::impl::Run(CUserCmd* cmd) {
|
||||
|
||||
if (!C_GET(bool, Vars.legit_enable))
|
||||
return;
|
||||
|
||||
if (!I::Engine->IsConnected() || !I::Engine->IsInGame())
|
||||
return;
|
||||
|
||||
if (!SDK::LocalController || !SDK::LocalPawn)
|
||||
return;
|
||||
|
||||
if (!cmd)
|
||||
return;
|
||||
|
||||
auto pCmd = cmd->m_csgoUserCmd.m_pBaseCmd;
|
||||
if (!pCmd)
|
||||
return;
|
||||
|
||||
/* store vars */
|
||||
pLocal = SDK::LocalPawn;
|
||||
if (!pLocal || !pCmd)
|
||||
return;
|
||||
|
||||
if (pLocal->GetHealth() <= 0)
|
||||
return;
|
||||
|
||||
auto viewangles = pCmd->m_pViewangles->m_angValue;
|
||||
|
||||
// reset hitboxes
|
||||
legit->Reset(reset::aimbot);
|
||||
|
||||
legit->SetupAdaptiveWeapon(pLocal);
|
||||
|
||||
// hitbox menu selection
|
||||
legit->Scan();
|
||||
|
||||
// run target selection
|
||||
legit->SetupTarget(pLocal);
|
||||
|
||||
// stop aimbot for now, no targets/hitboxes found
|
||||
if (validTargets.empty() || e_hitboxes.empty())
|
||||
return;
|
||||
|
||||
legit->ScanTarget(pLocal, viewangles);
|
||||
if (sortedTargets.empty() || !sortedTargets.front().finalPoint.IsValid())
|
||||
return;
|
||||
|
||||
// no ammo or not valid weapon
|
||||
if (!legit->Ready(pLocal))
|
||||
return;
|
||||
|
||||
auto weapon_data = pLocal->ActiveWeapon();
|
||||
if (!weapon_data)
|
||||
return;
|
||||
|
||||
auto vdata = weapon_data->datawep();
|
||||
if (!vdata)
|
||||
return;
|
||||
|
||||
// check if grabbed ent valid & pass this to the penetration sys
|
||||
auto entity = I::GameResourceService->pGameEntitySystem->Get(sortedTargets.front().player->GetRefEHandle());
|
||||
if (!entity)
|
||||
return;
|
||||
|
||||
auto localent = I::GameResourceService->pGameEntitySystem->Get(pLocal->GetRefEHandle());
|
||||
if (!localent)
|
||||
return;
|
||||
|
||||
// start angle calculation
|
||||
auto vec = get_target_angle(pLocal, sortedTargets.front().finalPoint);
|
||||
vec.clamp();
|
||||
QAngle_t angle; angle.ToVec3(vec);
|
||||
|
||||
// legit conditions
|
||||
if (C_GET(unsigned int, Vars.legit_conditions) & LEGIT_DELAY_SHOT && kill_delay >= I::GlobalVars->nTickCount)
|
||||
return;
|
||||
|
||||
if (C_GET(unsigned int, Vars.legit_conditions) & LEGIT_IN_AIR && (!pLocal->IsValidMoveType() || !(pLocal->GetFlags() & FL_ONGROUND)))
|
||||
return;
|
||||
|
||||
if (C_GET(unsigned int, Vars.legit_conditions) & LEGIT_FLASHED && pLocal->GetFlashDuration() > 0.f) // flashed
|
||||
return;
|
||||
|
||||
//TODO:
|
||||
//fix autowall damge when visible
|
||||
//
|
||||
// store aimbot data
|
||||
auto rcs_shots = legit_data.legit_rcs_shots_enable ? legit_data.legit_rcs_shots : 0;
|
||||
int smooth = legit_data.legit_smooth;
|
||||
auto fov = std::hypotf(viewangles.x - vec.x, viewangles.y - vec.y); //std::hypotf(viewangles->angValue.x - finalAngle.x, viewangles->angValue.y - finalAngle.y); //GetFov(a1, a2);
|
||||
const float best_fov = (float)legit_data.legit_fov;
|
||||
float server_time = (float)SDK::LocalController->m_nTickBase() * 0.015;
|
||||
bool can_shoot = (pLocal->ActiveWeapon()->m_flNextPrimaryAttackTickRatio() <= server_time);
|
||||
float pen_dmg = 0.f;
|
||||
bool can_hit = false;
|
||||
// run penetration system:
|
||||
// F::AUTOWALL::c_auto_wall::data_t data;
|
||||
// F::AUTOWALL::g_auto_wall->pen(data, vecStart, vecEnd, entity, localent, pLocal, sortedTargets.front().player, vdata, pen_dmg, can_hit);
|
||||
|
||||
legit->Triggerbot(cmd, localent, entity, pLocal, sortedTargets.front().player, vdata);
|
||||
|
||||
if (fov > best_fov)
|
||||
return;
|
||||
|
||||
// calculate aimpunch & compensate it
|
||||
static auto prev = QAngle_t(0.f, 0.f, 0.f);
|
||||
auto cache = pLocal->m_aimPunchCache();
|
||||
auto pred_punch = cache.m_Data[cache.m_Size - 1];
|
||||
auto delta = prev - pred_punch * 2.f;
|
||||
if (cache.m_Size > 0 && cache.m_Size <= 0xFFFF) {
|
||||
pred_punch = cache.m_Data[cache.m_Size - 1];
|
||||
prev = pred_punch;
|
||||
}
|
||||
// maybe peform some delta randomizations
|
||||
if (legit_data.PunchRandomization) {
|
||||
delta.x *= MATH::fnRandomFloat(0.3f, 0.7f);
|
||||
delta.y *= MATH::fnRandomFloat(0.3f, 0.7f);
|
||||
}
|
||||
// store best_point with compensated aimpunch
|
||||
auto best_point = angle + delta * 2.f;
|
||||
if (LI_FN(GetAsyncKeyState).safe()(legit_data.legit_key)) {
|
||||
// psilent
|
||||
if (C_GET(bool, Vars.legit_silent_aim) || (C_GET(bool, Vars.legit_no_scope) && vdata->m_WeaponType() == WEAPONTYPE_SNIPER_RIFLE && !pLocal->IsScoped())) {
|
||||
}
|
||||
else {
|
||||
QAngle_t smoothedAnglesRCS = PerformSmooth(viewangles, best_point, static_cast<float>(smooth), pLocal, vec);
|
||||
if (smooth == 0) {
|
||||
viewangles = best_point;
|
||||
viewangles.Clamp();
|
||||
|
||||
}
|
||||
else {
|
||||
viewangles = smoothedAnglesRCS;
|
||||
viewangles.Clamp();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
void F::LEGIT::impl::SetupAdaptiveWeapon(C_CSPlayerPawn* pLocal) {
|
||||
if (!pLocal)
|
||||
return;
|
||||
|
||||
if (!C_GET(bool, Vars.legit_enable))
|
||||
return;
|
||||
|
||||
auto ActiveWeapon = pLocal->ActiveWeapon();
|
||||
if (!ActiveWeapon)
|
||||
return;
|
||||
|
||||
auto data = ActiveWeapon->datawep();
|
||||
if (!data)
|
||||
return;
|
||||
|
||||
switch (data->m_WeaponType()) {
|
||||
|
||||
case WEAPONTYPE_PISTOL:
|
||||
legit_data.trigger_enable = C_GET(bool, Vars.trigger_enable_p);
|
||||
legit_data.trigger_hc = C_GET(int, Vars.trigger_hitchance_p);
|
||||
|
||||
legit_data.legit_fov = C_GET(int, Vars.legit_fov_pistol);
|
||||
legit_data.legit_key = C_GET(KeyBind_t, Vars.legit_key_pistol).uKey;
|
||||
legit_data.legit_key_style = 0; // You may need to set the appropriate value
|
||||
legit_data.legit_target_selection = C_GET(int, Vars.legit_target_selection);
|
||||
legit_data.legit_fov_visualize = C_GET(bool, Vars.legit_fov_visualize);
|
||||
legit_data.remove_weapon_accuracy_spread = C_GET(bool, Vars.remove_weapon_accuracy_spread);
|
||||
legit_data.legit_smooth = C_GET(int, Vars.legit_smooth_pistol);
|
||||
legit_data.legit_rcs_shots = C_GET(int, Vars.legit_rcs_shots_pistol);
|
||||
legit_data.legit_rcs = C_GET(bool, Vars.legit_rcs_pistol);
|
||||
legit_data.PunchRandomization = C_GET(bool, Vars.PunchRandomization_pistol);
|
||||
legit_data.legit_rcs_shots_enable = C_GET(bool, Vars.legit_rcs_shots_enable_pistol);
|
||||
legit_data.legit_rcs_smoothx = C_GET(float, Vars.legit_rcs_smoothx_pistol);
|
||||
legit_data.legit_rcs_smoothy = C_GET(float, Vars.legit_rcs_smoothy_pistol);
|
||||
legit_data.legit_visibility_check = C_GET(bool, Vars.legit_visibility_check_pistol);
|
||||
legit_data.hitbox_head = C_GET(bool, Vars.hitbox_head_pistol);
|
||||
legit_data.hitbox_neck = C_GET(bool, Vars.hitbox_neck_pistol);
|
||||
legit_data.hitbox_uppeer_chest = C_GET(bool, Vars.hitbox_uppeer_chest_pistol);
|
||||
legit_data.hitbox_chest = C_GET(bool, Vars.hitbox_chest_pistol);
|
||||
legit_data.hitbox_stomach = C_GET(bool, Vars.hitbox_stomach_pistol);
|
||||
legit_data.hitbox_leg_l = C_GET(bool, Vars.hitbox_leg_l_pistol);
|
||||
legit_data.hitbox_leg_r = C_GET(bool, Vars.hitbox_leg_r_pistol);
|
||||
legit_data.punch_x = C_GET(bool, Vars.punch_x_pistol);
|
||||
legit_data.punch_y = C_GET(bool, Vars.punch_y_pistol);
|
||||
break;
|
||||
|
||||
case WEAPONTYPE_MACHINEGUN:
|
||||
legit_data.trigger_enable = C_GET(bool, Vars.trigger_enable_m);
|
||||
legit_data.trigger_hc = C_GET(int, Vars.trigger_hitchance_m);
|
||||
legit_data.legit_fov = C_GET(int, Vars.legit_fov_machinegun);
|
||||
legit_data.legit_key = C_GET(KeyBind_t, Vars.legit_key_machinegun).uKey;
|
||||
legit_data.legit_key_style = 0; // Set the appropriate value
|
||||
legit_data.legit_target_selection = C_GET(int, Vars.legit_target_selection_machinegun);
|
||||
legit_data.legit_fov_visualize = C_GET(bool, Vars.legit_fov_visualize);
|
||||
legit_data.remove_weapon_accuracy_spread = C_GET(bool, Vars.remove_weapon_accuracy_spread);
|
||||
legit_data.legit_smooth = C_GET(int, Vars.legit_smooth_machinegun);
|
||||
legit_data.legit_rcs_shots = C_GET(int, Vars.legit_rcs_shots_machinegun);
|
||||
legit_data.legit_rcs = C_GET(bool, Vars.legit_rcs_machinegun);
|
||||
legit_data.PunchRandomization = C_GET(bool, Vars.PunchRandomization_machinegun);
|
||||
legit_data.legit_rcs_shots_enable = C_GET(bool, Vars.legit_rcs_shots_enable_machinegun);
|
||||
legit_data.legit_rcs_smoothx = C_GET(float, Vars.legit_rcs_smoothx_machinegun);
|
||||
legit_data.legit_rcs_smoothy = C_GET(float, Vars.legit_rcs_smoothy_machinegun);
|
||||
legit_data.legit_visibility_check = C_GET(bool, Vars.legit_visibility_check_machinegun);
|
||||
legit_data.hitbox_head = C_GET(bool, Vars.hitbox_head_machinegun);
|
||||
legit_data.hitbox_neck = C_GET(bool, Vars.hitbox_neck_machinegun);
|
||||
legit_data.hitbox_uppeer_chest = C_GET(bool, Vars.hitbox_uppeer_chest_machinegun);
|
||||
legit_data.hitbox_chest = C_GET(bool, Vars.hitbox_chest_machinegun);
|
||||
legit_data.hitbox_stomach = C_GET(bool, Vars.hitbox_stomach_machinegun);
|
||||
legit_data.hitbox_leg_l = C_GET(bool, Vars.hitbox_leg_l_machinegun);
|
||||
legit_data.hitbox_leg_r = C_GET(bool, Vars.hitbox_leg_r_machinegun);
|
||||
legit_data.punch_x = C_GET(bool, Vars.punch_x_machinegun);
|
||||
legit_data.punch_y = C_GET(bool, Vars.punch_y_machinegun);
|
||||
break;
|
||||
|
||||
case WEAPONTYPE_RIFLE:
|
||||
legit_data.trigger_enable = C_GET(bool, Vars.trigger_enable_a);
|
||||
legit_data.trigger_hc = C_GET(int, Vars.trigger_hitchance_a);
|
||||
legit_data.legit_fov = C_GET(int, Vars.legit_fov_assultrifles);
|
||||
legit_data.legit_key = C_GET(KeyBind_t, Vars.legit_key_assultrifles).uKey;
|
||||
legit_data.legit_key_style = 0; // Set the appropriate value
|
||||
legit_data.legit_target_selection = C_GET(int, Vars.legit_target_selection_assultrifles);
|
||||
legit_data.legit_fov_visualize = C_GET(bool, Vars.legit_fov_visualize);
|
||||
legit_data.remove_weapon_accuracy_spread = C_GET(bool, Vars.remove_weapon_accuracy_spread);
|
||||
legit_data.legit_smooth = C_GET(int, Vars.legit_smooth_assultrifles);
|
||||
legit_data.legit_rcs_shots = C_GET(int, Vars.legit_rcs_shots_assultrifles);
|
||||
legit_data.legit_rcs = C_GET(bool, Vars.legit_rcs_assultrifles);
|
||||
legit_data.PunchRandomization = C_GET(bool, Vars.PunchRandomization_assultrifles);
|
||||
legit_data.legit_rcs_shots_enable = C_GET(bool, Vars.legit_rcs_shots_enable_assultrifles);
|
||||
legit_data.legit_rcs_smoothx = C_GET(float, Vars.legit_rcs_smoothx_assultrifles);
|
||||
legit_data.legit_rcs_smoothy = C_GET(float, Vars.legit_rcs_smoothy_assultrifles);
|
||||
legit_data.legit_visibility_check = C_GET(bool, Vars.legit_visibility_check_assultrifles);
|
||||
legit_data.hitbox_head = C_GET(bool, Vars.hitbox_head_assultrifles);
|
||||
legit_data.hitbox_neck = C_GET(bool, Vars.hitbox_neck_assultrifles);
|
||||
legit_data.hitbox_uppeer_chest = C_GET(bool, Vars.hitbox_uppeer_chest_assultrifles);
|
||||
legit_data.hitbox_chest = C_GET(bool, Vars.hitbox_chest_assultrifles);
|
||||
legit_data.hitbox_stomach = C_GET(bool, Vars.hitbox_stomach_assultrifles);
|
||||
legit_data.hitbox_leg_l = C_GET(bool, Vars.hitbox_leg_l_assultrifles);
|
||||
legit_data.hitbox_leg_r = C_GET(bool, Vars.hitbox_leg_r_assultrifles);
|
||||
legit_data.punch_x = C_GET(bool, Vars.punch_x_assultrifles);
|
||||
legit_data.punch_y = C_GET(bool, Vars.punch_y_assultrifles);
|
||||
break;
|
||||
case WEAPONTYPE_SNIPER_RIFLE:
|
||||
legit_data.trigger_enable = C_GET(bool, Vars.trigger_enable_s);
|
||||
legit_data.trigger_hc = C_GET(int, Vars.trigger_hitchance_s);
|
||||
legit_data.legit_fov = C_GET(int, Vars.legit_fov_snipers);
|
||||
legit_data.legit_key = C_GET(KeyBind_t, Vars.legit_key_snipers).uKey;
|
||||
legit_data.legit_key_style = 0; // Set the appropriate value
|
||||
legit_data.legit_target_selection = C_GET(int, Vars.legit_target_selection_snipers);
|
||||
legit_data.legit_fov_visualize = C_GET(bool, Vars.legit_fov_visualize);
|
||||
legit_data.remove_weapon_accuracy_spread = C_GET(bool, Vars.remove_weapon_accuracy_spread);
|
||||
legit_data.legit_smooth = C_GET(int, Vars.legit_smooth_snipers);
|
||||
legit_data.legit_rcs_shots = C_GET(int, Vars.legit_rcs_shots_snipers);
|
||||
legit_data.legit_rcs = C_GET(bool, Vars.legit_rcs_snipers);
|
||||
legit_data.PunchRandomization = C_GET(bool, Vars.PunchRandomization_snipers);
|
||||
legit_data.legit_rcs_shots_enable = C_GET(bool, Vars.legit_rcs_shots_enable_snipers);
|
||||
legit_data.legit_rcs_smoothx = C_GET(float, Vars.legit_rcs_smoothx_snipers);
|
||||
legit_data.legit_rcs_smoothy = C_GET(float, Vars.legit_rcs_smoothy_snipers);
|
||||
legit_data.legit_visibility_check = C_GET(bool, Vars.legit_visibility_check_snipers);
|
||||
legit_data.hitbox_head = C_GET(bool, Vars.hitbox_head_snipers);
|
||||
legit_data.hitbox_neck = C_GET(bool, Vars.hitbox_neck_snipers);
|
||||
legit_data.hitbox_uppeer_chest = C_GET(bool, Vars.hitbox_uppeer_chest_snipers);
|
||||
legit_data.hitbox_chest = C_GET(bool, Vars.hitbox_chest_snipers);
|
||||
legit_data.hitbox_stomach = C_GET(bool, Vars.hitbox_stomach_snipers);
|
||||
legit_data.hitbox_leg_l = C_GET(bool, Vars.hitbox_leg_l_snipers);
|
||||
legit_data.hitbox_leg_r = C_GET(bool, Vars.hitbox_leg_r_snipers);
|
||||
|
||||
legit_data.punch_x = C_GET(bool, Vars.punch_x_snipers);
|
||||
legit_data.punch_y = C_GET(bool, Vars.punch_y_snipers);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
#pragma once
|
||||
|
||||
#include "../../common.h"
|
||||
#include <memory>
|
||||
// used: draw system
|
||||
#include "../../utilities/draw.h"
|
||||
#include "../../sdk/datatypes/vector.h"
|
||||
#include "../../sdk/datatypes/transform.h"
|
||||
#include "../../sdk/datatypes/qangle.h"
|
||||
#include "../cstrike/core/config.h"
|
||||
class CCSPlayerController;
|
||||
class C_BaseEntity;
|
||||
class C_CSPlayerPawn;
|
||||
class CBaseHandle;
|
||||
class CEntityInstance;
|
||||
class CUserCmd;
|
||||
class CBaseUserCmdPB;
|
||||
class QAngle_t;
|
||||
class IGameEvent;
|
||||
class C_CSWeaponBase;
|
||||
class CCSWeaponBaseVData;
|
||||
|
||||
namespace F::LEGIT
|
||||
{
|
||||
enum events {
|
||||
round_start = 1,
|
||||
player_death = 2,
|
||||
};
|
||||
|
||||
class impl {
|
||||
public:
|
||||
enum reset {
|
||||
entity,
|
||||
aimbot,
|
||||
recoil
|
||||
};
|
||||
enum scan_mode {
|
||||
single, /* only 1 hitbox */
|
||||
adaptive /* multiple bones pushed in the same time */
|
||||
};
|
||||
|
||||
enum hitboxes {
|
||||
scan_head,
|
||||
scan_neck,
|
||||
scan_chest,
|
||||
scan_pelvis
|
||||
};
|
||||
|
||||
struct aim_info {
|
||||
int legit_fov;
|
||||
int legit_key;
|
||||
int legit_key_style;
|
||||
int legit_target_selection;
|
||||
bool legit_fov_visualize;
|
||||
bool remove_weapon_accuracy_spread;
|
||||
int legit_smooth;
|
||||
int legit_rcs_shots;
|
||||
bool legit_rcs;
|
||||
bool PunchRandomization;
|
||||
bool legit_rcs_shots_enable;
|
||||
float legit_rcs_smoothx;
|
||||
float legit_rcs_smoothy;
|
||||
bool legit_enable;
|
||||
bool legit_visibility_check;
|
||||
bool hitbox_head;
|
||||
bool hitbox_neck;
|
||||
bool hitbox_uppeer_chest;
|
||||
bool hitbox_chest;
|
||||
bool hitbox_stomach;
|
||||
bool hitbox_leg_l;
|
||||
bool hitbox_leg_r;
|
||||
float punch_y;
|
||||
float punch_x;
|
||||
bool trigger_enable;
|
||||
int trigger_hc;
|
||||
|
||||
}legit_data;
|
||||
|
||||
struct target_info {
|
||||
float target_fov;
|
||||
Vector_t best_target_pos;
|
||||
C_CSPlayerPawn* m_target;
|
||||
};
|
||||
|
||||
/* void inits */
|
||||
bool valid( C_CSPlayerPawn* pawn, C_CSPlayerPawn* pLocal, bool check = false);
|
||||
|
||||
void Scan();
|
||||
void Triggerbot(CUserCmd* cmd, C_BaseEntity* localent, C_BaseEntity* playerent, C_CSPlayerPawn* local, C_CSPlayerPawn* player, CCSWeaponBaseVData* vdata);
|
||||
|
||||
void SetupTarget(C_CSPlayerPawn* pawn);
|
||||
void SetupAdaptiveWeapon(C_CSPlayerPawn* pawn);
|
||||
void ScanTarget(C_CSPlayerPawn* pLocal, QAngle_t viewangles);
|
||||
bool Hitchance(C_CSPlayerPawn* pLocal, C_CSPlayerPawn* ent, C_CSWeaponBase* weapon, QAngle_t vAimpoint, int iChance);
|
||||
|
||||
void Reset(reset type);
|
||||
void Run(CUserCmd* cmd);
|
||||
|
||||
bool Ready(C_CSPlayerPawn* pLocal);
|
||||
void Events(IGameEvent* event_listener, events type);
|
||||
/* init class */
|
||||
aim_info aimbot_info;
|
||||
target_info target_info;
|
||||
C_CSPlayerPawn* pLocal;
|
||||
|
||||
};
|
||||
const auto legit = std::make_unique<impl>();
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
#include "misc.h"
|
||||
|
||||
// used: movement callback
|
||||
#include "misc/movement.h"
|
||||
#include "legit/legit.h"
|
||||
#include "../utilities/log.h"
|
||||
#include "lagcomp/lagcomp.h"
|
||||
#include "../cstrike/sdk/datatypes/qangle.h"
|
||||
#include "../cstrike/sdk/entity.h"
|
||||
#include "../cstrike/sdk/datatypes/usercmd.h"
|
||||
#include "enginepred/pred.h"
|
||||
|
||||
#include "../sdk/interfaces/events.h"
|
||||
#include "rage/rage.h"
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
#pragma once
|
||||
class CUserCmd;
|
||||
class CCSPlayerController;
|
||||
class C_CSPlayerPawn;
|
||||
class QAngle_t;
|
||||
class CCSGOInput;
|
||||
namespace F::MISC
|
||||
{
|
||||
}
|
||||
@@ -0,0 +1,638 @@
|
||||
#include "movement.h"
|
||||
|
||||
// used: sdk
|
||||
#include <iostream>
|
||||
// used: sdk entity
|
||||
#include "../../sdk/entity.h"
|
||||
// used: cusercmd
|
||||
#include "../../sdk/datatypes/usercmd.h"
|
||||
#include "../../sdk/interfaces/ccsgoinput.h"
|
||||
#include "../../sdk/datatypes/qangle.h"
|
||||
// used: convars
|
||||
#include "../../core/convars.h"
|
||||
#include "../../sdk/interfaces/ienginecvar.h"
|
||||
#include "../cstrike/features/enginepred/pred.h"
|
||||
// used: cheat variables
|
||||
#include "../../core/variables.h"
|
||||
#include <array>
|
||||
#include "../../core/sdk.h"
|
||||
#include "../../sdk/interfaces/itrace.h"
|
||||
#include "../cstrike/sdk/interfaces/cgameentitysystem.h"
|
||||
#include "../antiaim/antiaim.hpp"
|
||||
|
||||
struct MovementData {
|
||||
QAngle_t angCorrectionView{};
|
||||
|
||||
} _move_data;
|
||||
|
||||
enum DIR : int {
|
||||
FORWARDS = 0,
|
||||
BACKWARDS = 180,
|
||||
LEFT = 90,
|
||||
RIGHT = -90
|
||||
};
|
||||
|
||||
enum MODE : int {
|
||||
legit = 0,
|
||||
rage = 1
|
||||
};
|
||||
|
||||
void AngleQangles(const QAngle_t& angles, QAngle_t* forward, QAngle_t* right, QAngle_t* up)
|
||||
{
|
||||
float angle;
|
||||
float sr, sp, sy, cr, cp, cy;
|
||||
|
||||
// Convert angles from degrees to radians
|
||||
angle = angles.y * (MATH::_PI / 180.0);
|
||||
sy = sin(angle);
|
||||
cy = cos(angle);
|
||||
angle = angles.x * (MATH::_PI / 180.0);
|
||||
sp = sin(angle);
|
||||
cp = cos(angle);
|
||||
angle = angles.z * (MATH::_PI / 180.0);
|
||||
sr = sin(angle);
|
||||
cr = cos(angle);
|
||||
|
||||
if (forward)
|
||||
{
|
||||
forward->x = cp * cy;
|
||||
forward->y = cp * sy;
|
||||
forward->z = -sp;
|
||||
}
|
||||
|
||||
if (right)
|
||||
{
|
||||
right->x = (-1 * sr * sp * cy + -1 * cr * -sy);
|
||||
right->y = (-1 * sr * sp * sy + -1 * cr * cy);
|
||||
right->z = -1 * sr * cp;
|
||||
}
|
||||
|
||||
if (up)
|
||||
{
|
||||
up->x = (cr * sp * cy + -sr * -sy);
|
||||
up->y = (cr * sp * sy + -sr * cy);
|
||||
up->z = cr * cp;
|
||||
}
|
||||
}
|
||||
|
||||
void F::MISC::MOVEMENT::movment_fix(CUserCmd* pCmd, QAngle_t angle)
|
||||
{
|
||||
QAngle_t wish_angle;
|
||||
wish_angle = pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue;
|
||||
int revers = wish_angle.x > 89.f ? -1 : 1;
|
||||
wish_angle.Clamp();
|
||||
|
||||
QAngle_t view_fwd, view_right, view_up, cmd_fwd, cmd_right, cmd_up;
|
||||
auto viewangles = angle;
|
||||
|
||||
AngleQangles(wish_angle, &view_fwd, &view_right, &view_up);
|
||||
AngleQangles(viewangles, &cmd_fwd, &cmd_right, &cmd_up);
|
||||
|
||||
const float v8 = sqrtf((view_fwd.x * view_fwd.x) + (view_fwd.y * view_fwd.y));
|
||||
const float v10 = sqrtf((view_right.x * view_right.x) + (view_right.y * view_right.y));
|
||||
const float v12 = sqrtf(view_up.z * view_up.z);
|
||||
|
||||
const Vector_t norm_view_fwd((1.f / v8) * view_fwd.x, (1.f / v8) * view_fwd.y, 0.f);
|
||||
const Vector_t norm_view_right((1.f / v10) * view_right.x, (1.f / v10) * view_right.y, 0.f);
|
||||
const Vector_t norm_view_up(0.f, 0.f, (1.f / v12) * view_up.z);
|
||||
|
||||
const float v14 = sqrtf((cmd_fwd.x * cmd_fwd.x) + (cmd_fwd.y * cmd_fwd.y));
|
||||
const float v16 = sqrtf((cmd_right.x * cmd_right.x) + (cmd_right.y * cmd_right.y));
|
||||
const float v18 = sqrtf(cmd_up.z * cmd_up.z);
|
||||
|
||||
const Vector_t norm_cmd_fwd((1.f / v14) * cmd_fwd.x, (1.f / v14) * cmd_fwd.y, 0.f);
|
||||
const Vector_t norm_cmd_right((1.f / v16) * cmd_right.x, (1.f / v16) * cmd_right.y, 0.f);
|
||||
const Vector_t norm_cmd_up(0.f, 0.f, (1.f / v18) * cmd_up.z);
|
||||
|
||||
const float v22 = norm_view_fwd.x * pCmd->m_csgoUserCmd.m_pBaseCmd->m_flForwardMove;
|
||||
const float v26 = norm_view_fwd.y * pCmd->m_csgoUserCmd.m_pBaseCmd->m_flForwardMove;
|
||||
const float v28 = norm_view_fwd.z * pCmd->m_csgoUserCmd.m_pBaseCmd->m_flForwardMove;
|
||||
const float v24 = norm_view_right.x * pCmd->m_csgoUserCmd.m_pBaseCmd->m_flSideMove;
|
||||
const float v23 = norm_view_right.y * pCmd->m_csgoUserCmd.m_pBaseCmd->m_flSideMove;
|
||||
const float v25 = norm_view_right.z * pCmd->m_csgoUserCmd.m_pBaseCmd->m_flSideMove;
|
||||
const float v30 = norm_view_up.x * pCmd->m_csgoUserCmd.m_pBaseCmd->m_flUpMove;
|
||||
const float v27 = norm_view_up.z * pCmd->m_csgoUserCmd.m_pBaseCmd->m_flUpMove;
|
||||
const float v29 = norm_view_up.y * pCmd->m_csgoUserCmd.m_pBaseCmd->m_flUpMove;
|
||||
|
||||
pCmd->m_csgoUserCmd.m_pBaseCmd->m_flForwardMove = ((((norm_cmd_fwd.x * v24) + (norm_cmd_fwd.y * v23)) + (norm_cmd_fwd.z * v25))
|
||||
+ (((norm_cmd_fwd.x * v22) + (norm_cmd_fwd.y * v26)) + (norm_cmd_fwd.z * v28)))
|
||||
+ (((norm_cmd_fwd.y * v30) + (norm_cmd_fwd.x * v29)) + (norm_cmd_fwd.z * v27));
|
||||
pCmd->m_csgoUserCmd.m_pBaseCmd->m_flSideMove = ((((norm_cmd_right.x * v24) + (norm_cmd_right.y * v23)) + (norm_cmd_right.z * v25))
|
||||
+ (((norm_cmd_right.x * v22) + (norm_cmd_right.y * v26)) + (norm_cmd_right.z * v28)))
|
||||
+ (((norm_cmd_right.x * v29) + (norm_cmd_right.y * v30)) + (norm_cmd_right.z * v27));
|
||||
pCmd->m_csgoUserCmd.m_pBaseCmd->m_flUpMove = ((((norm_cmd_up.x * v23) + (norm_cmd_up.y * v24)) + (norm_cmd_up.z * v25))
|
||||
+ (((norm_cmd_up.x * v26) + (norm_cmd_up.y * v22)) + (norm_cmd_up.z * v28)))
|
||||
+ (((norm_cmd_up.x * v30) + (norm_cmd_up.y * v29)) + (norm_cmd_up.z * v27));
|
||||
|
||||
pCmd->m_csgoUserCmd.m_pBaseCmd->m_flForwardMove = revers * ((((norm_cmd_fwd.x * v24) + (norm_cmd_fwd.y * v23)) + (norm_cmd_fwd.z * v25)) + (((norm_cmd_fwd.x * v22) + (norm_cmd_fwd.y * v26)) + (norm_cmd_fwd.z * v28)));
|
||||
|
||||
pCmd->m_csgoUserCmd.m_pBaseCmd->m_flSideMove = ((((norm_cmd_right.x * v24) + (norm_cmd_right.y * v23)) + (norm_cmd_right.z * v25)) + (((norm_cmd_right.x * v22) + (norm_cmd_right.y * v26)) + (norm_cmd_right.z * v28)));
|
||||
|
||||
pCmd->m_csgoUserCmd.m_pBaseCmd->m_flForwardMove = std::clamp(pCmd->m_csgoUserCmd.m_pBaseCmd->m_flForwardMove, -1.f, 1.f);
|
||||
|
||||
pCmd->m_csgoUserCmd.m_pBaseCmd->m_flSideMove = std::clamp(pCmd->m_csgoUserCmd.m_pBaseCmd->m_flSideMove, -1.f, 1.f);
|
||||
}
|
||||
|
||||
void F::MISC::MOVEMENT::ProcessMovement(CUserCmd* pCmd, CCSPlayerController* pLocalController, C_CSPlayerPawn* pLocalPawn)
|
||||
{
|
||||
if (!pLocalController)
|
||||
return;
|
||||
|
||||
if (!pLocalPawn)
|
||||
return;
|
||||
|
||||
if (pLocalPawn->GetHealth() <= 0)
|
||||
return;
|
||||
|
||||
if (pCmd == nullptr)
|
||||
return;
|
||||
|
||||
CBaseUserCmdPB* base = pCmd->m_csgoUserCmd.m_pBaseCmd;
|
||||
if (base == nullptr)
|
||||
return;
|
||||
|
||||
// check if player is in noclip or on ladder or in water
|
||||
if (const int32_t nMoveType = pLocalPawn->GetMoveType(); nMoveType == MOVETYPE_NOCLIP || nMoveType == MOVETYPE_LADDER || pLocalPawn->GetWaterLevel() >= WL_WAIST)
|
||||
return;
|
||||
|
||||
EdgeBug(pLocalController, pLocalPawn, pCmd);
|
||||
|
||||
if (pLocalPawn->IsValidMoveType()) {
|
||||
AutoStrafe(pCmd, base, pLocalPawn, C_GET(int, Vars.bAutostrafeMode));
|
||||
BunnyHop(pCmd, base, pLocalPawn);
|
||||
movment_fix(pCmd, F::ANTIAIM::angStoredViewBackup);
|
||||
}
|
||||
|
||||
for (int i = 0; i < pCmd->m_csgoUserCmd.m_inputHistoryField.m_pRep->m_nAllocatedSize; i++)
|
||||
{
|
||||
CCSGOInputHistoryEntryPB* pInputEntry = pCmd->GetInputHistoryEntry(i);
|
||||
if (pInputEntry == nullptr)
|
||||
continue;
|
||||
|
||||
if (pInputEntry->m_pViewCmd == nullptr)
|
||||
continue;
|
||||
|
||||
_move_data.angCorrectionView = pInputEntry->m_pViewCmd->m_angValue;
|
||||
|
||||
ValidateUserCommand(pCmd, base, pInputEntry);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
void rotate_movement(float yaw, const QAngle_t& angles, float& fmove, float& smove) {
|
||||
float rotation = M_DEG2RAD(angles.y - yaw);
|
||||
|
||||
float cos_rot = std::cos(rotation);
|
||||
float sin_rot = std::sin(rotation);
|
||||
|
||||
float new_forwardmove = (cos_rot * fmove) - (sin_rot * smove);
|
||||
float new_sidemove = (sin_rot * fmove) + (cos_rot * smove);
|
||||
|
||||
fmove = new_forwardmove;
|
||||
smove = new_sidemove;
|
||||
}
|
||||
|
||||
void F::MISC::MOVEMENT::EdgeBug(CCSPlayerController* controler, C_CSPlayerPawn* localPlayer, CUserCmd* cmd) {
|
||||
if (!C_GET(bool, Vars.edge_bug))
|
||||
return;
|
||||
|
||||
if (!controler || !localPlayer || localPlayer->GetHealth() <= 0)
|
||||
return;
|
||||
|
||||
C_CSPlayerPawn* pred = I::GameResourceService->pGameEntitySystem->Get<C_CSPlayerPawn>(controler->m_hPredictedPawn());
|
||||
if (!pred)
|
||||
return;
|
||||
|
||||
static bool bhopWasEnabled = true;
|
||||
bool JumpDone;
|
||||
|
||||
bool unduck = true;
|
||||
|
||||
float max_radius = MATH::_PI * 2;
|
||||
float step = max_radius / 128;
|
||||
float xThick = 23;
|
||||
bool valid = GetAsyncKeyState(C_GET(KeyBind_t, Vars.edge_bug_key).uKey);
|
||||
if (!valid) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (valid) {
|
||||
I::Cvar->Find(FNV1A::Hash(CS_XOR("sv_min_jump_landing_sound")))->value.fl = 63464578.f;
|
||||
}
|
||||
else {
|
||||
I::Cvar->Find(FNV1A::Hash(CS_XOR("sv_min_jump_landing_sound")))->value.fl = 260;
|
||||
}
|
||||
|
||||
static bool edgebugging = false;
|
||||
static int edgebugging_tick = 0;
|
||||
|
||||
if (!edgebugging) {
|
||||
|
||||
int flags = localPlayer->GetFlags();
|
||||
float z_velocity = floor(localPlayer->m_vecVelocity().z);
|
||||
|
||||
for (int i = 0; i < 64; i++) {
|
||||
|
||||
if (z_velocity < -7 && floor(localPlayer->m_vecVelocity().z) == -7 && !(flags & FL_ONGROUND) && localPlayer->GetMoveType() != MOVETYPE_NOCLIP) {
|
||||
edgebugging_tick = cmd->m_csgoUserCmd.m_pBaseCmd->m_nTickCount + i;
|
||||
|
||||
edgebugging = true;
|
||||
break;
|
||||
}
|
||||
else {
|
||||
z_velocity = floor(localPlayer->m_vecVelocity().z);
|
||||
flags = localPlayer->GetFlags();
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
||||
cmd->m_csgoUserCmd.m_pBaseCmd->m_flSideMove = 0.f;
|
||||
cmd->m_csgoUserCmd.m_pBaseCmd->m_flForwardMove = 0.f;
|
||||
cmd->m_csgoUserCmd.m_pBaseCmd->m_flUpMove = 0.f;
|
||||
cmd->m_csgoUserCmd.m_pBaseCmd->m_nMousedX = 0.f;
|
||||
cmd->m_nButtons.m_nValue |= IN_DUCK;
|
||||
|
||||
if ((localPlayer->GetFlags() & 0x1)) {
|
||||
cmd->m_nButtons.m_nValue &= ~IN_JUMP;
|
||||
}
|
||||
|
||||
Vector_t pos = localPlayer->GetSceneOrigin();
|
||||
|
||||
for (float a = 0.f; a < max_radius; a += step) {
|
||||
Vector_t pt;
|
||||
pt.x = (xThick * cos(a)) + pos.x;
|
||||
pt.y = (xThick * sin(a)) + pos.y;
|
||||
pt.z = pos.z;
|
||||
|
||||
Vector_t pt2 = pt;
|
||||
pt2.z -= 8192;
|
||||
trace_filter_t filter = {};
|
||||
I::Trace->Init(filter, localPlayer, 0x1400B, 3, 7);
|
||||
|
||||
game_trace_t trace = {};
|
||||
ray_t ray = {};
|
||||
|
||||
I::Trace->TraceShape(ray, &pt, &pt2, filter, trace);
|
||||
|
||||
if (trace.Fraction != 1.0f && trace.Fraction != 0.0f) {
|
||||
JumpDone = true;
|
||||
cmd->m_nButtons.m_nValue |= IN_DUCK;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (cmd->m_csgoUserCmd.m_pBaseCmd->m_nTickCount > edgebugging_tick) {
|
||||
edgebugging = false;
|
||||
edgebugging_tick = 0;
|
||||
}
|
||||
|
||||
}
|
||||
trace_filter_t filter = {};
|
||||
I::Trace->Init(filter, localPlayer, 0x1400B, 3, 7);
|
||||
|
||||
Vector_t pos = localPlayer->GetSceneOrigin();
|
||||
if (pred->m_bInLanding()) {
|
||||
|
||||
for (float a = 0.f; a < max_radius; a += step) {
|
||||
Vector_t pt;
|
||||
pt.x = (xThick * cos(a)) + pos.x;
|
||||
pt.y = (xThick * sin(a)) + pos.y;
|
||||
pt.z = pos.z;
|
||||
|
||||
Vector_t pt2 = pt;
|
||||
pt2.z -= 8192;
|
||||
|
||||
game_trace_t trace = {};
|
||||
ray_t ray = {};
|
||||
|
||||
I::Trace->TraceShape(ray, &pt, &pt2, filter, trace);
|
||||
|
||||
if (trace.Fraction != 1.0f && trace.Fraction != 0.0f) {
|
||||
JumpDone = true;
|
||||
|
||||
|
||||
cmd->m_csgoUserCmd.m_pBaseCmd->m_flSideMove = 0.f;
|
||||
cmd->m_csgoUserCmd.m_pBaseCmd->m_flForwardMove = 0.f;
|
||||
cmd->m_csgoUserCmd.m_pBaseCmd->m_flUpMove = 0.f;
|
||||
cmd->m_csgoUserCmd.m_pBaseCmd->m_nMousedX = 0.f;
|
||||
cmd->m_nButtons.m_nValue |= IN_DUCK;
|
||||
|
||||
if ((localPlayer->GetFlags() & 0x1)) {
|
||||
cmd->m_nButtons.m_nValue &= ~IN_JUMP;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
if (cmd->m_csgoUserCmd.m_pBaseCmd->m_nTickCount > edgebugging_tick) {
|
||||
edgebugging = false;
|
||||
edgebugging_tick = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void F::MISC::MOVEMENT::AutoStrafe(CUserCmd* pCmd, CBaseUserCmdPB* pUserCmd, C_CSPlayerPawn* pLocalPawn, int type)
|
||||
{
|
||||
static uint64_t last_pressed = 0;
|
||||
static uint64_t last_buttons = 0;
|
||||
|
||||
if (!C_GET(bool, Vars.bAutostrafe))
|
||||
return;
|
||||
|
||||
auto& cmd = I::Input->arrCommands[I::Input->nSequenceNumber % 150];
|
||||
bool strafe_assist = C_GET(bool, Vars.bAutostrafeAssistance);
|
||||
const auto current_buttons = cmd.m_nButtons.m_nValue;
|
||||
auto yaw = MATH::normalize_yaw(pUserCmd->m_pViewangles->m_angValue.y);
|
||||
|
||||
const auto check_button = [&](const uint64_t button)
|
||||
{
|
||||
if (current_buttons & button && (!(last_buttons & button) || button & IN_MOVELEFT && !(last_pressed & IN_MOVERIGHT) || button &
|
||||
IN_MOVERIGHT && !(last_pressed & IN_MOVELEFT) || button & IN_FORWARD && !(last_pressed & IN_BACK) ||
|
||||
button & IN_BACK && !(last_pressed & IN_FORWARD)))
|
||||
{
|
||||
if (strafe_assist)
|
||||
{
|
||||
if (button & IN_MOVELEFT)
|
||||
last_pressed &= ~IN_MOVERIGHT;
|
||||
else if (button & IN_MOVERIGHT)
|
||||
last_pressed &= ~IN_MOVELEFT;
|
||||
else if (button & IN_FORWARD)
|
||||
last_pressed &= ~IN_BACK;
|
||||
else if (button & IN_BACK)
|
||||
last_pressed &= ~IN_FORWARD;
|
||||
}
|
||||
|
||||
last_pressed |= button;
|
||||
}
|
||||
else if (!(current_buttons & button))
|
||||
last_pressed &= ~button;
|
||||
};
|
||||
|
||||
check_button(IN_MOVELEFT);
|
||||
check_button(IN_MOVERIGHT);
|
||||
check_button(IN_FORWARD);
|
||||
check_button(IN_BACK);
|
||||
|
||||
last_buttons = current_buttons;
|
||||
|
||||
const auto velocity = pLocalPawn->GetAbsVelocity();
|
||||
bool wasdstrafe = C_GET(unsigned int, Vars.bAutostrafeMode) == 0;
|
||||
bool viewanglestrafe = C_GET(unsigned int, Vars.bAutostrafeMode) == 1;
|
||||
float smoothing = C_GET(float, Vars.autostrafe_smooth);
|
||||
|
||||
/*const auto weapon = pLocalPawn->get_weapon_services_ptr()->get_h_active_weapon().get();
|
||||
const auto js = weapon && (cfg.weapon_config.is_scout && cfg.weapon_config.cur.scout_jumpshot && pLocalPawn->get_vec_abs_velocity().length_2d() < 50.f);
|
||||
const auto throwing_nade = weapon && weapon->is_grenade() && ticks_to_time(local_player->get_tickbase()) >= weapon->get_throw_time() && weapon->get_throw_time() != 0.f;
|
||||
|
||||
if (js)
|
||||
return;*/
|
||||
|
||||
if (pLocalPawn->GetFlags() & FL_ONGROUND)
|
||||
return;
|
||||
|
||||
auto rotate_movement = [](CUserCmd& cmd, float target_yaw)
|
||||
{ auto pUserCmd = cmd.m_csgoUserCmd.m_pBaseCmd;
|
||||
|
||||
const float rot = M_DEG2RAD(pUserCmd->m_pViewangles->m_angValue.y - target_yaw);
|
||||
|
||||
const float new_forward = std::cos(rot) * pUserCmd->m_flForwardMove - std::sin(rot) * pUserCmd->m_flSideMove;
|
||||
const float new_side = std::sin(rot) * pUserCmd->m_flForwardMove + std::cos(rot) * pUserCmd->m_flSideMove;
|
||||
|
||||
cmd.m_nButtons.m_nValue &= ~(IN_BACK | IN_FORWARD | IN_MOVELEFT | IN_MOVERIGHT);
|
||||
pUserCmd->m_flForwardMove = std::clamp(new_forward, -1.f, 1.f);
|
||||
pUserCmd->m_flSideMove = std::clamp(new_side * -1.f, -1.f, 1.f);
|
||||
|
||||
if (pUserCmd->m_flForwardMove > 0.f)
|
||||
cmd.m_nButtons.m_nValue |= IN_FORWARD;
|
||||
else if (pUserCmd->m_flForwardMove < 0.f)
|
||||
cmd.m_nButtons.m_nValue |= IN_BACK;
|
||||
|
||||
if (pUserCmd->m_flSideMove > 0.f)
|
||||
cmd.m_nButtons.m_nValue |= IN_MOVELEFT;
|
||||
else if (pUserCmd->m_flSideMove < 0.f)
|
||||
cmd.m_nButtons.m_nValue |= IN_MOVERIGHT;
|
||||
};
|
||||
|
||||
|
||||
if (wasdstrafe)
|
||||
{
|
||||
auto offset = 0.f;
|
||||
if (last_pressed & IN_MOVELEFT)
|
||||
offset += 90.f;
|
||||
if (last_pressed & IN_MOVERIGHT)
|
||||
offset -= 90.f;
|
||||
if (last_pressed & IN_FORWARD)
|
||||
offset *= 0.5f;
|
||||
else if (last_pressed & IN_BACK)
|
||||
offset = -offset * 0.5f + 180.f;
|
||||
|
||||
yaw += offset;
|
||||
|
||||
pUserCmd->m_flForwardMove = 0.f;
|
||||
pUserCmd->m_flSideMove = 0.f;
|
||||
|
||||
rotate_movement(cmd, MATH::normalize_yaw(yaw));
|
||||
|
||||
if (!viewanglestrafe && offset == 0.f)
|
||||
return;
|
||||
}
|
||||
|
||||
if (pUserCmd->m_flSideMove != 0.0f || pUserCmd->m_flForwardMove != 0.0f)
|
||||
return;
|
||||
|
||||
auto velocity_angle = M_RAD2DEG(std::atan2f(velocity.y, velocity.x));
|
||||
if (velocity_angle < 0.0f)
|
||||
velocity_angle += 360.0f;
|
||||
|
||||
if (velocity_angle < 0.0f)
|
||||
velocity_angle += 360.0f;
|
||||
|
||||
velocity_angle -= floorf(velocity_angle / 360.0f + 0.5f) * 360.0f;
|
||||
|
||||
const auto speed = velocity.Length2D();
|
||||
const auto ideal = std::clamp(M_RAD2DEG(std::atan2(15.f, speed)), 0.f, 45.f);
|
||||
|
||||
const auto correct = (100.f - smoothing) * 0.02f * (ideal + ideal);
|
||||
|
||||
pUserCmd->m_flForwardMove = 0.f;
|
||||
const auto velocity_delta = MATH::normalize_yaw(yaw - velocity_angle);
|
||||
|
||||
/*if (throwing_nade && fabsf(velocity_delta) <=20.f)
|
||||
{
|
||||
auto &wish_angle = antiaim::wish_angles[globals::current_cmd->command_number % 150];
|
||||
wish_angle.y = math::normalize_yaw(yaw);
|
||||
globals::current_cmd->forwardmove = 450.f;
|
||||
|
||||
antiaim::fix_movement(globals::current_cmd);
|
||||
return;
|
||||
}*/
|
||||
|
||||
if (fabsf(velocity_delta) > 170.f && speed > 80.f || velocity_delta > correct && speed > 80.f)
|
||||
{
|
||||
yaw = correct + velocity_angle;
|
||||
pUserCmd->m_flSideMove = -1.f;
|
||||
rotate_movement(cmd, MATH::normalize_yaw(yaw));
|
||||
return;
|
||||
}
|
||||
const bool side_switch = I::Input->nSequenceNumber % 2 == 0;
|
||||
|
||||
if (-correct <= velocity_delta || speed <= 80.f)
|
||||
{
|
||||
if (side_switch)
|
||||
{
|
||||
yaw = yaw - ideal;
|
||||
pUserCmd->m_flSideMove = -1.f;
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
yaw = ideal + yaw;
|
||||
pUserCmd->m_flSideMove = 1.f;
|
||||
|
||||
}
|
||||
rotate_movement(cmd, MATH::normalize_yaw(yaw));
|
||||
}
|
||||
else
|
||||
{
|
||||
yaw = velocity_angle - correct;
|
||||
pUserCmd->m_flSideMove = 1.f;
|
||||
|
||||
rotate_movement(cmd, MATH::normalize_yaw(yaw));
|
||||
}
|
||||
}
|
||||
|
||||
std::array<bool, 150> onground_tick = {};
|
||||
std::array<bool, 150> remove_tick = {};
|
||||
bool pressed_jump = false;
|
||||
|
||||
void F::MISC::MOVEMENT::BunnyHop(CUserCmd* pCmd, CBaseUserCmdPB* pUserCmd, C_CSPlayerPawn* pLocalPawn)
|
||||
{
|
||||
bool bWasLastTimeOnGround{};
|
||||
|
||||
pressed_jump = pCmd->m_nButtons.m_nValue & IN_JUMP;
|
||||
|
||||
if (!C_GET(bool, Vars.bAutoBHop) || CONVAR::sv_autobunnyhopping->value.i1)
|
||||
return;
|
||||
|
||||
if (pLocalPawn->GetFlags() & FL_ONGROUND)
|
||||
pCmd->m_nButtons.m_nValue &= ~IN_JUMP;
|
||||
|
||||
bWasLastTimeOnGround = pLocalPawn->GetFlags() & FL_ONGROUND;
|
||||
|
||||
const float velocity = pLocalPawn->m_vecVelocity().Length2D();
|
||||
|
||||
bool bShouldJump = true;
|
||||
|
||||
if (velocity > 300.f && Vars.nAutoBHopChance < 0.8) bShouldJump = false;
|
||||
|
||||
if (!pLocalPawn->GetFlags() & FL_ONGROUND && !bWasLastTimeOnGround)
|
||||
pCmd->m_nButtons.m_nValue &= ~IN_JUMP;
|
||||
|
||||
bWasLastTimeOnGround = pLocalPawn->GetFlags() & FL_ONGROUND;
|
||||
|
||||
/*CSubtickMoveStep* subtick_pressed = pUserCmd->AddSubTickMove();
|
||||
subtick_pressed->m_nCachedBits = 7;
|
||||
subtick_pressed->nButton = IN_JUMP;
|
||||
subtick_pressed->bPressed = true;
|
||||
subtick_pressed->flWhen = 0.999f;
|
||||
|
||||
CSubtickMoveStep* subtick_release = pUserCmd->AddSubTickMove();
|
||||
subtick_release->m_nCachedBits = 7;
|
||||
subtick_release->nButton = IN_JUMP;
|
||||
subtick_release->bPressed = false;
|
||||
subtick_release->flWhen = 0.999f;*/
|
||||
}
|
||||
|
||||
void F::MISC::MOVEMENT::ValidateUserCommand(CUserCmd* pCmd, CBaseUserCmdPB* pUserCmd, CCSGOInputHistoryEntryPB* pInputEntry)
|
||||
{
|
||||
if (pUserCmd == nullptr)
|
||||
return;
|
||||
|
||||
// clamp angle to avoid untrusted angle
|
||||
if (C_GET(bool, Vars.bAntiUntrusted))
|
||||
{
|
||||
if (pInputEntry->m_pViewCmd->m_angValue.IsValid())
|
||||
{
|
||||
pInputEntry->m_pViewCmd->m_angValue.Clamp();
|
||||
pInputEntry->m_pViewCmd->m_angValue.z = 0.f;
|
||||
}
|
||||
else
|
||||
{
|
||||
pInputEntry->m_pViewCmd->m_angValue = {};
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//MovementCorrection(pUserCmd, pInputEntry, _move_data.angCorrectionView);
|
||||
|
||||
// correct movement buttons while player move have different to buttons values
|
||||
// clear all of the move buttons states
|
||||
pCmd->m_nButtons.m_nValue &= (~IN_FORWARD | ~IN_BACK | ~IN_LEFT | ~IN_RIGHT);
|
||||
|
||||
// re-store buttons by active forward/side moves
|
||||
if (pUserCmd->m_flForwardMove > 0.0f)
|
||||
pCmd->m_nButtons.m_nValue |= IN_FORWARD;
|
||||
else if (pUserCmd->m_flForwardMove < 0.0f)
|
||||
pCmd->m_nButtons.m_nValue |= IN_BACK;
|
||||
|
||||
if (pUserCmd->m_flSideMove > 0.0f)
|
||||
pCmd->m_nButtons.m_nValue |= IN_RIGHT;
|
||||
else if (pUserCmd->m_flSideMove < 0.0f)
|
||||
pCmd->m_nButtons.m_nValue |= IN_LEFT;
|
||||
|
||||
|
||||
if (!pInputEntry->m_pViewCmd->m_angValue.IsZero())
|
||||
{
|
||||
float flDeltaX = std::remainderf(pInputEntry->m_pViewCmd->m_angValue.x - _move_data.angCorrectionView.x, 360.f);
|
||||
float flDeltaY = std::remainderf(pInputEntry->m_pViewCmd->m_angValue.y - _move_data.angCorrectionView.y, 360.f);
|
||||
|
||||
|
||||
float flPitch = CONVAR::m_pitch->value.fl;
|
||||
float flYaw = CONVAR::m_yaw->value.fl;
|
||||
|
||||
float flSensitivity = CONVAR::sensitivity->value.fl;
|
||||
if (flSensitivity == 0.0f)
|
||||
flSensitivity = 1.0f;
|
||||
|
||||
pUserCmd->m_nMousedX = static_cast<short>(flDeltaX / (flSensitivity * flPitch));
|
||||
pUserCmd->m_nMousedY = static_cast<short>(-flDeltaY / (flSensitivity * flYaw));
|
||||
}
|
||||
}
|
||||
|
||||
void F::MISC::MOVEMENT::MovementCorrection(CBaseUserCmdPB* pUserCmd, CCSGOInputHistoryEntryPB* pInputEntry, const QAngle_t& angDesiredViewPoint)
|
||||
{
|
||||
if (pUserCmd == nullptr)
|
||||
return;
|
||||
|
||||
Vector_t vecForward = {}, vecRight = {}, vecUp = {};
|
||||
angDesiredViewPoint.ToDirections(&vecForward, &vecRight, &vecUp);
|
||||
|
||||
// we don't attempt on forward/right roll, and on up pitch/yaw
|
||||
vecForward.z = vecRight.z = vecUp.x = vecUp.y = 0.0f;
|
||||
|
||||
vecForward.NormalizeInPlace();
|
||||
vecRight.NormalizeInPlace();
|
||||
vecUp.NormalizeInPlace();
|
||||
|
||||
Vector_t vecOldForward = {}, vecOldRight = {}, vecOldUp = {};
|
||||
pInputEntry->m_pViewCmd->m_angValue.ToDirections(&vecOldForward, &vecOldRight, &vecOldUp);
|
||||
|
||||
// we don't attempt on forward/right roll, and on up pitch/yaw
|
||||
vecOldForward.z = vecOldRight.z = vecOldUp.x = vecOldUp.y = 0.0f;
|
||||
|
||||
vecOldForward.NormalizeInPlace();
|
||||
vecOldRight.NormalizeInPlace();
|
||||
vecOldUp.NormalizeInPlace();
|
||||
|
||||
const float flPitchForward = vecForward.x * pUserCmd->m_flForwardMove;
|
||||
const float flYawForward = vecForward.y * pUserCmd->m_flForwardMove;
|
||||
const float flPitchSide = vecRight.x * pUserCmd->m_flSideMove;
|
||||
const float flYawSide = vecRight.y * pUserCmd->m_flSideMove;
|
||||
const float flRollUp = vecUp.z * pUserCmd->m_flUpMove;
|
||||
|
||||
// solve corrected movement speed
|
||||
pUserCmd->m_flForwardMove = vecOldForward.x * flPitchSide + vecOldForward.y * flYawSide + vecOldForward.x * flPitchForward + vecOldForward.y * flYawForward + vecOldForward.z * flRollUp;
|
||||
pUserCmd->m_flSideMove = vecOldRight.x * flPitchSide + vecOldRight.y * flYawSide + vecOldRight.x * flPitchForward + vecOldRight.y * flYawForward + vecOldRight.z * flRollUp;
|
||||
pUserCmd->m_flUpMove = vecOldUp.x * flYawSide + vecOldUp.y * flPitchSide + vecOldUp.x * flYawForward + vecOldUp.y * flPitchForward + vecOldUp.z * flRollUp;
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
#pragma once
|
||||
|
||||
class CUserCmd;
|
||||
class CBaseUserCmdPB;
|
||||
class CCSGOInputHistoryEntryPB;
|
||||
class CBasePlayerController;
|
||||
class CCSPlayerController;
|
||||
class C_CSPlayerPawn;
|
||||
class CSubtickMoveStep;
|
||||
class QAngle_t;
|
||||
|
||||
namespace F::MISC::MOVEMENT
|
||||
{
|
||||
|
||||
void EdgeBug(CCSPlayerController* controler, C_CSPlayerPawn* localPlayer, CUserCmd* cmd);
|
||||
|
||||
void movment_fix(CUserCmd* pCmd, QAngle_t angle);
|
||||
|
||||
void ProcessMovement(CUserCmd* pCmd, CCSPlayerController* pLocalController, C_CSPlayerPawn* pLocalPawn);
|
||||
|
||||
void BunnyHop(CUserCmd* pCmd, CBaseUserCmdPB* pUserCmd, C_CSPlayerPawn* pLocalPawn);
|
||||
void AutoStrafe(CUserCmd* pCmd, CBaseUserCmdPB* pUserCmd, C_CSPlayerPawn* pLocalPawn, int type);
|
||||
|
||||
void MovementCorrection(CBaseUserCmdPB* pUserCmd, CCSGOInputHistoryEntryPB* pInputHistory, const QAngle_t& angDesiredViewPoint);
|
||||
|
||||
// will call MovementCorrection && validate user's angView to avoid untrusted ban
|
||||
void ValidateUserCommand(CUserCmd* pCmd, CBaseUserCmdPB* pUserCmd, CCSGOInputHistoryEntryPB* pInputHistory);
|
||||
|
||||
}
|
||||
@@ -0,0 +1,392 @@
|
||||
#include "penetration.h"
|
||||
#include "../../core/variables.h"
|
||||
#include "../../sdk/datatypes/usercmd.h"
|
||||
#include "../../core/sdk.h"
|
||||
#include "../../sdk/entity.h"
|
||||
#include "../../sdk/interfaces/iengineclient.h"
|
||||
#include "../../sdk/interfaces/iglobalvars.h"
|
||||
#include "../../sdk/interfaces/cgameentitysystem.h"
|
||||
#include "../../sdk/datatypes/qangle.h"
|
||||
#include "../../sdk/datatypes/vector.h"
|
||||
#include "../../sdk/entity_handle.h"
|
||||
#include "../cstrike/sdk/interfaces/ienginecvar.h"
|
||||
|
||||
#include <mutex>
|
||||
#include <array>
|
||||
#include "../cstrike/sdk/interfaces/itrace.h"
|
||||
static constexpr std::uint32_t PENMASK = 0x1C300Bu; // mask_shot_hull | contents_hitbox?
|
||||
|
||||
namespace F::AUTOWALL {
|
||||
|
||||
|
||||
|
||||
void F::AUTOWALL::c_auto_wall::pen(data_t& data, const Vector_t local_pos, const Vector_t target_pos, C_BaseEntity* target, C_BaseEntity* local, C_CSPlayerPawn* localpawn, C_CSPlayerPawn* targetpawn,
|
||||
CCSWeaponBaseVData* wpn_data, float &dmg, bool &valid) {
|
||||
data.m_local = local;
|
||||
data.m_target = target;
|
||||
data.m_local_pawn = localpawn;
|
||||
data.m_target_pawn = targetpawn;
|
||||
data.m_wpn_data = wpn_data;
|
||||
data.m_pos.at(F::AUTOWALL::c_auto_wall::data_t::e_pos::e_local) = local_pos;
|
||||
data.m_pos.at(F::AUTOWALL::c_auto_wall::data_t::e_pos::e_target) = target_pos;
|
||||
FireBullet(data, data.m_dmg, data.m_can_hit);
|
||||
|
||||
}
|
||||
|
||||
void F::AUTOWALL::c_auto_wall::ScaleDamage(data_t& data, const int hitgroup, C_CSPlayerPawn* player)
|
||||
{
|
||||
if (!player)
|
||||
return;
|
||||
|
||||
auto WeaponServices = player->GetItemServices();
|
||||
if (!WeaponServices)
|
||||
return;
|
||||
|
||||
// ida: server.dll; 80 78 42 00 74 08 F3 0F 59 35 ?? ?? ?? ?? 80 BE 04 0D 00 00 00
|
||||
static CConVar* mp_damage_scale_ct_head = I::Cvar->Find(
|
||||
FNV1A::HashConst("mp_damage_scale_ct_head")),
|
||||
* mp_damage_scale_t_head = I::Cvar->Find(
|
||||
FNV1A::HashConst("mp_damage_scale_t_head")),
|
||||
* mp_damage_scale_ct_body = I::Cvar->Find(
|
||||
FNV1A::HashConst("mp_damage_scale_ct_body")),
|
||||
* mp_damage_scale_t_body = I::Cvar->Find(
|
||||
FNV1A::HashConst("mp_damage_scale_t_body"));
|
||||
|
||||
const auto damage_scale_ct_head = mp_damage_scale_ct_head->value.fl,
|
||||
damage_scale_t_head = mp_damage_scale_t_head->value.fl,
|
||||
damage_scale_ct_body = mp_damage_scale_ct_body->value.fl,
|
||||
damage_scale_t_body = mp_damage_scale_t_body->value.fl;
|
||||
|
||||
const bool is_ct = player->GetTeam() == 3, is_t = player->GetTeam() == 2;
|
||||
|
||||
float head_damage_scale = is_ct ? damage_scale_ct_head : is_t ? damage_scale_t_head : 1.0f;
|
||||
const float body_damage_scale = is_ct ? damage_scale_ct_body : is_t ? damage_scale_t_body : 1.0f;
|
||||
|
||||
// william: magic values u can see here: ida: server.dll; F3 0F 10 35 ?? ?? ?? ?? 0F 29 7C 24 30 44 0F 29 44 24
|
||||
// xref: mp_heavybot_damage_reduction_scale
|
||||
if (WeaponServices->m_bHasHeavyArmor()) {
|
||||
head_damage_scale *= 0.5f;
|
||||
}
|
||||
|
||||
// todo: mb missed some hitgroups, anyway this is a calculation of all important hitgroups
|
||||
switch (hitgroup) {
|
||||
case HitGroup_t::HITGROUP_HEAD:
|
||||
data.m_dmg *= data.m_wpn_data->m_flHeadshotMultiplier() * head_damage_scale;
|
||||
break;
|
||||
case HitGroup_t::HITGROUP_CHEST:
|
||||
case HitGroup_t::HITGROUP_LEFTARM:
|
||||
case HitGroup_t::HITGROUP_RIGHTARM:
|
||||
case HitGroup_t::HITGROUP_NECK:
|
||||
data.m_dmg *= body_damage_scale;
|
||||
break;
|
||||
case HitGroup_t::HITGROUP_STOMACH:
|
||||
data.m_dmg *= 1.25f * body_damage_scale;
|
||||
break;
|
||||
case HitGroup_t::HITGROUP_LEFTLEG:
|
||||
case HitGroup_t::HITGROUP_RIGHTLEG:
|
||||
data.m_dmg *= 0.75f * body_damage_scale;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (!player->hasArmour(hitgroup))
|
||||
return;
|
||||
|
||||
float heavy_armor_bonus = 1.0f, armor_bonus = 0.5f, armor_ratio = data.m_wpn_data->m_flArmorRatio() * 0.5f;
|
||||
|
||||
if (WeaponServices->m_bHasHeavyArmor()) {
|
||||
heavy_armor_bonus = 0.25f;
|
||||
armor_bonus = 0.33f;
|
||||
armor_ratio *= 0.20f;
|
||||
}
|
||||
|
||||
float damage_to_health = data.m_dmg * armor_ratio;
|
||||
const float damage_to_armor = (data.m_dmg - damage_to_health) * (heavy_armor_bonus * armor_bonus);
|
||||
|
||||
if (damage_to_armor > static_cast<float>(player->GetArmorValue())) {
|
||||
damage_to_health = data.m_dmg - static_cast<float>(player->GetArmorValue()) / armor_bonus;
|
||||
}
|
||||
|
||||
data.m_dmg = damage_to_health;
|
||||
}
|
||||
|
||||
|
||||
bool F::AUTOWALL::c_auto_wall::FireBullet(data_t& data, float &dmg, bool &valid)
|
||||
{
|
||||
// L_PRINT(LOG_INFO) << "0";
|
||||
CS_ASSERT(data.m_local != nullptr || data.m_target != nullptr || data.m_wpn_data != nullptr || data.m_local_pawn != nullptr || data.m_target_pawn != nullptr);
|
||||
if (!data.m_local || !data.m_target || !data.m_wpn_data)
|
||||
return false;
|
||||
// L_PRINT(LOG_INFO) << "1";
|
||||
|
||||
trace_data_t trace_data = { };
|
||||
trace_data.m_arr_pointer = &trace_data.m_arr;
|
||||
void* data_pointer = &trace_data;
|
||||
//L_PRINT(LOG_INFO) << "created trace_data | trace_data_pointer:" << L::AddFlags(LOG_MODE_INT_SHOWBASE | LOG_MODE_INT_FORMAT_HEX) << reinterpret_cast<uintptr_t>(data_pointer);
|
||||
//L_PRINT(LOG_INFO) << "created trace_data | pointer:" << L::AddFlags(LOG_MODE_INT_SHOWBASE | LOG_MODE_INT_FORMAT_HEX) << reinterpret_cast<uintptr_t>(trace_data.m_arr_pointer);
|
||||
|
||||
const Vector_t direction =
|
||||
data.m_pos.at(data_t::e_pos::e_target) - data.m_pos.at(data_t::e_pos::e_local),
|
||||
end_pos = direction * data.m_wpn_data->m_flRange();
|
||||
|
||||
trace_filter_t filter = {};
|
||||
I::Trace->Init(filter, data.m_local_pawn,PENMASK, 3, 7);
|
||||
void* filter_pointer = &filter;
|
||||
/* L_PRINT(LOG_INFO) << "created filter_data | filter_pointer:" << L::AddFlags(LOG_MODE_INT_SHOWBASE | LOG_MODE_INT_FORMAT_HEX) << reinterpret_cast<uintptr_t>(filter_pointer);
|
||||
|
||||
L_PRINT(LOG_INFO) << "creating trace | filter > layer:" << filter.layer << "mask:" << filter.trace_mask;
|
||||
L_PRINT(LOG_INFO) << "creating trace | endpos:" << end_pos;
|
||||
*/
|
||||
I::Trace->CreateTrace(&trace_data, data.m_pos.at(data_t::e_pos::e_local), end_pos, filter, 4);
|
||||
|
||||
struct handle_bullet_data_t {
|
||||
handle_bullet_data_t(const float dmg_mod, const float pen, const float range_mod, const float range,
|
||||
const int pen_count, const bool failed) :
|
||||
m_dmg(dmg_mod),
|
||||
m_pen(pen),
|
||||
m_range_mod(range_mod),
|
||||
m_range(range),
|
||||
m_pen_count(pen_count),
|
||||
m_failed(failed) {}
|
||||
|
||||
float m_dmg{ }, m_pen{ }, m_range_mod{ }, m_range{ };
|
||||
int m_pen_count{ };
|
||||
bool m_failed{ };
|
||||
}
|
||||
|
||||
handle_bullet_data(static_cast<float>(data.m_wpn_data->m_nDamage()), data.m_wpn_data->m_flPenetration(), data.m_wpn_data->m_flRange(),
|
||||
data.m_wpn_data->m_flRangeModifier(), 4, false);
|
||||
|
||||
// L_PRINT(LOG_INFO) << "Initialized handlebulletpen data";
|
||||
|
||||
float corrected_dmg = static_cast<float>(data.m_wpn_data->m_nDamage());
|
||||
float flTraceLength = 0.f;
|
||||
auto flMaxRange = data.m_wpn_data->m_flRange();
|
||||
if (trace_data.m_num_update > 0) {
|
||||
for (int i{ }; i < trace_data.m_num_update; i++) {
|
||||
auto* value = reinterpret_cast<UpdateValueT* const>(
|
||||
reinterpret_cast<std::uintptr_t>(trace_data.m_pointer_update_value)
|
||||
+ i * sizeof(UpdateValueT));
|
||||
|
||||
game_trace_t game_trace = { };
|
||||
I::Trace->InitializeTraceInfo(&game_trace);
|
||||
I::Trace->get_trace_info(
|
||||
&trace_data, &game_trace, 0.0f,
|
||||
reinterpret_cast<void*>(
|
||||
reinterpret_cast<std::uintptr_t>(trace_data.m_arr.data())
|
||||
+ sizeof(trace_arr_element_t) * (value->handleIdx & 0x7fffu)));
|
||||
/*
|
||||
L_PRINT(LOG_INFO) << "game_trace: entryindex:" << game_trace.HitEntity->GetRefEHandle().GetEntryIndex();
|
||||
L_PRINT(LOG_INFO) << "game_trace: m_target_pawn entryindex:" << data.m_target_pawn->GetRefEHandle().GetEntryIndex();
|
||||
L_PRINT(LOG_INFO) << "game_trace: m_target entryindex:" << data.m_target->GetRefEHandle().GetEntryIndex();
|
||||
*/
|
||||
|
||||
flMaxRange -= flTraceLength;
|
||||
|
||||
// we didn't hit anything, stop tracing shoot
|
||||
if (game_trace.Fraction == 1.0f)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
// calculate the damage based on the distance the bullet traveled
|
||||
flTraceLength += game_trace.Fraction * flMaxRange;
|
||||
corrected_dmg *= std::powf(data.m_wpn_data->m_flRangeModifier(), flTraceLength / 500.f);
|
||||
|
||||
// check is actually can shoot through
|
||||
if (flTraceLength > 3000.f)
|
||||
break;
|
||||
|
||||
if (game_trace.HitEntity && game_trace.HitEntity->GetRefEHandle().GetEntryIndex() == data.m_target_pawn->GetRefEHandle().GetEntryIndex()) {
|
||||
ScaleDamage2(game_trace.HitboxData->m_hitgroup, data.m_target_pawn, data.m_wpn_data->m_flArmorRatio(), data.m_wpn_data->m_flHeadshotMultiplier(), &corrected_dmg);
|
||||
dmg = corrected_dmg;//data.m_dmg > 0.f ? data.m_dmg : handle_bullet_data.m_dmg;
|
||||
valid = true;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
valid = false;
|
||||
|
||||
|
||||
if (I::Trace->handle_bullet_penetration(&trace_data, &handle_bullet_data, value, false))
|
||||
return false;
|
||||
|
||||
corrected_dmg = handle_bullet_data.m_dmg;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void F::AUTOWALL::c_auto_wall::ScaleDamage2(const int iHitGroup, C_CSPlayerPawn* pCSPlayer, const float flWeaponArmorRatio, const float flWeaponHeadShotMultiplier, float* pflDamageToScale)
|
||||
{
|
||||
// @ida CCSPlayer::TraceAttack(): server.dll -> "55 8B EC 83 E4 F8 81 EC ? ? ? ? 56 8B 75 08 57 8B F9 C6"
|
||||
auto WeaponServices = pCSPlayer->GetItemServices();
|
||||
if (!WeaponServices)
|
||||
return;
|
||||
|
||||
const bool bHeavyArmor = WeaponServices->m_bHasHeavyArmor();
|
||||
|
||||
// ida: server.dll; 80 78 42 00 74 08 F3 0F 59 35 ?? ?? ?? ?? 80 BE 04 0D 00 00 00
|
||||
static CConVar* mp_damage_scale_ct_head = I::Cvar->Find(
|
||||
FNV1A::HashConst("mp_damage_scale_ct_head")),
|
||||
* mp_damage_scale_t_head = I::Cvar->Find(
|
||||
FNV1A::HashConst("mp_damage_scale_t_head")),
|
||||
* mp_damage_scale_ct_body = I::Cvar->Find(
|
||||
FNV1A::HashConst("mp_damage_scale_ct_body")),
|
||||
* mp_damage_scale_t_body = I::Cvar->Find(
|
||||
FNV1A::HashConst("mp_damage_scale_t_body"));
|
||||
|
||||
const auto damage_scale_ct_head = mp_damage_scale_ct_head->value.fl,
|
||||
damage_scale_t_head = mp_damage_scale_t_head->value.fl,
|
||||
damage_scale_ct_body = mp_damage_scale_ct_body->value.fl,
|
||||
damage_scale_t_body = mp_damage_scale_t_body->value.fl;
|
||||
|
||||
float flHeadDamageScale = (pCSPlayer->GetTeam() == TEAM_CT ? damage_scale_ct_head : damage_scale_t_head);
|
||||
const float flBodyDamageScale = (pCSPlayer->GetTeam() == TEAM_CT ? damage_scale_ct_body : damage_scale_t_body);
|
||||
|
||||
if (bHeavyArmor) flHeadDamageScale *= 0.5f;
|
||||
|
||||
switch (iHitGroup)
|
||||
{
|
||||
case HITGROUP_HEAD:
|
||||
*pflDamageToScale *= flWeaponHeadShotMultiplier * flHeadDamageScale;
|
||||
break;
|
||||
case HITGROUP_CHEST:
|
||||
case HITGROUP_LEFTARM:
|
||||
|
||||
case HITGROUP_RIGHTARM:
|
||||
case HITGROUP_NECK:
|
||||
*pflDamageToScale *= flBodyDamageScale;
|
||||
break;
|
||||
case HITGROUP_STOMACH:
|
||||
*pflDamageToScale *= 1.25f * flBodyDamageScale;
|
||||
break;
|
||||
case HITGROUP_LEFTLEG:
|
||||
case HITGROUP_RIGHTLEG:
|
||||
*pflDamageToScale *= 0.75f * flBodyDamageScale;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (pCSPlayer->hasArmour(iHitGroup))
|
||||
{
|
||||
// @ida CCSPlayer::OnTakeDamage(): server.dll -> "80 BF ? ? ? ? ? F3 0F 10 5C 24 ? F3 0F 10 35"
|
||||
|
||||
const int iArmor = pCSPlayer->GetArmorValue();
|
||||
float flHeavyArmorBonus = 1.0f, flArmorBonus = 0.5f, flArmorRatio = flWeaponArmorRatio * 0.5f;
|
||||
|
||||
if (bHeavyArmor)
|
||||
{
|
||||
flHeavyArmorBonus = 0.25f;
|
||||
flArmorBonus = 0.33f;
|
||||
flArmorRatio *= 0.20f;
|
||||
}
|
||||
|
||||
float flDamageToHealth = *pflDamageToScale * flArmorRatio;
|
||||
if (const float flDamageToArmor = (*pflDamageToScale - flDamageToHealth) * (flHeavyArmorBonus * flArmorBonus); flDamageToArmor > static_cast<float>(iArmor))
|
||||
flDamageToHealth = *pflDamageToScale - static_cast<float>(iArmor) / flArmorBonus;
|
||||
|
||||
*pflDamageToScale = flDamageToHealth;
|
||||
}
|
||||
}
|
||||
/* bool F::AUTOWALL::c_auto_wall::FireBullet(data_t& data, float& dmg, bool& valid)
|
||||
{
|
||||
CS_ASSERT(data.m_local != nullptr || data.m_target != nullptr || data.m_wpn_data != nullptr || data.m_local_pawn != nullptr || data.m_target_pawn != nullptr);
|
||||
if (!data.m_local || !data.m_target || !data.m_wpn_data)
|
||||
return false;
|
||||
|
||||
trace_data_t trace_data = { };
|
||||
trace_data.m_arr_pointer = &trace_data.m_arr;
|
||||
|
||||
Vector_t direction =
|
||||
data.m_pos.at(data_t::e_pos::e_target) - data.m_pos.at(data_t::e_pos::e_local),
|
||||
end_pos = direction * data.m_wpn_data->m_flRange();
|
||||
|
||||
int pen_count = 4;
|
||||
float flTraceLength = 0.f;
|
||||
float flMaxRange = data.m_wpn_data->m_flRange();
|
||||
// set our current damage to what our gun's initial damage reports it will do
|
||||
data.m_dmg = static_cast<float>(data.m_wpn_data->m_nDamage());
|
||||
|
||||
trace_filter_t filter = {};
|
||||
I::Trace->Init(filter, data.m_local_pawn, MASK_SHOT_HULL | CONTENTS_HITBOX, 3, 7);
|
||||
I::Trace->CreateTrace(&trace_data, data.m_pos.at(data_t::e_pos::e_local), end_pos, filter, 4);
|
||||
|
||||
struct handle_bullet_data_t {
|
||||
handle_bullet_data_t(const float dmg_mod, const float pen, const float range_mod, const float range,
|
||||
const int pen_count, const bool failed) :
|
||||
m_dmg(dmg_mod),
|
||||
m_pen(pen),
|
||||
m_range_mod(range_mod),
|
||||
m_range(range),
|
||||
m_pen_count(pen_count),
|
||||
m_failed(failed) {}
|
||||
|
||||
float m_dmg{ }, m_pen{ }, m_range_mod{ }, m_range{ };
|
||||
int m_pen_count{ };
|
||||
bool m_failed{ };
|
||||
}
|
||||
|
||||
handle_bullet_data(static_cast<float>(data.m_wpn_data->m_nDamage()), data.m_wpn_data->m_flPenetration(), data.m_wpn_data->m_flRange(),
|
||||
data.m_wpn_data->m_flRangeModifier(), 4, false);
|
||||
|
||||
if (trace_data.m_num_update > 0) {
|
||||
for (int i{ }; i < trace_data.m_num_update; i++) {
|
||||
auto* value = reinterpret_cast<UpdateValueT* const>(
|
||||
reinterpret_cast<std::uintptr_t>(trace_data.m_pointer_update_value)
|
||||
+ i * sizeof(UpdateValueT));
|
||||
|
||||
game_trace_t game_trace = { };
|
||||
I::Trace->InitializeTraceInfo(&game_trace);
|
||||
I::Trace->get_trace_info(
|
||||
&trace_data, &game_trace, 0.0f,
|
||||
reinterpret_cast<void*>(
|
||||
reinterpret_cast<std::uintptr_t>(trace_data.m_arr.data())
|
||||
+ sizeof(trace_arr_element_t) * (value->handleIdx & 0x7fffu)));
|
||||
|
||||
|
||||
flMaxRange -= flTraceLength;
|
||||
|
||||
game_trace_t trace = {};
|
||||
ray_t ray = {};
|
||||
|
||||
I::Trace->TraceShape(ray, &data.m_pos.at(data_t::e_pos::e_local), &end_pos, filter, trace);
|
||||
I::Trace->ClipTraceToPlayers(data.m_pos.at(data_t::e_pos::e_local), end_pos, &filter, &trace, 0.F, 60.F, (1.F / (data.m_pos.at(data_t::e_pos::e_local) - end_pos).Length()) * (trace.m_end_pos - data.m_pos.at(data_t::e_pos::e_local)).Length());
|
||||
|
||||
if (trace.Fraction == 1.f)
|
||||
break;
|
||||
|
||||
// calculate the damage based on the distance the bullet traveled
|
||||
flTraceLength += trace.Fraction * flMaxRange;
|
||||
data.m_dmg *= std::powf(data.m_wpn_data->m_flRangeModifier(), flTraceLength / 500.f);
|
||||
|
||||
// check is actually can shoot through
|
||||
if (flTraceLength > 3000.f)
|
||||
break;
|
||||
|
||||
L_PRINT(LOG_INFO) << "idx:" << trace.HitEntity->GetRefEHandle().GetEntryIndex() << " dmg:" << data.m_dmg;
|
||||
|
||||
if (trace.HitEntity->GetRefEHandle().GetEntryIndex() == data.m_target_pawn->GetRefEHandle().GetEntryIndex())
|
||||
{
|
||||
ScaleDamage2(game_trace.HitboxData->m_hitgroup, data.m_target_pawn, data.m_wpn_data->m_flArmorRatio(), data.m_wpn_data->m_flHeadshotMultiplier(), &data.m_dmg);
|
||||
L_PRINT(LOG_INFO) << "dmg:" << data.m_dmg;
|
||||
return true;
|
||||
}
|
||||
|
||||
// check if the bullet can no longer continue penetrating materials
|
||||
if (I::Trace->handle_bullet_penetration(&trace_data, &handle_bullet_data, value, false))
|
||||
return false;
|
||||
|
||||
pen_count = handle_bullet_data.m_pen_count;
|
||||
data.m_dmg = handle_bullet_data.m_dmg;
|
||||
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}*/
|
||||
std::unique_ptr<c_auto_wall> g_auto_wall{};
|
||||
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
#pragma once
|
||||
|
||||
#include "../../common.h"
|
||||
#include <memory>
|
||||
// used: draw system
|
||||
#include "../../utilities/draw.h"
|
||||
#include "../../sdk/datatypes/vector.h"
|
||||
#include "../../sdk/datatypes/transform.h"
|
||||
#include "../../sdk/datatypes/qangle.h"
|
||||
#include "../cstrike/core/config.h"
|
||||
#include <array>
|
||||
class C_BaseEntity;
|
||||
class CCSWeaponBaseVData;
|
||||
class Vector_t;
|
||||
class C_CSPlayerPawn;
|
||||
class CCSPlayerController;
|
||||
class CBaseHandle;
|
||||
class CEntityInstance;
|
||||
class CUserCmd;
|
||||
class CBaseUserCmdPB;
|
||||
class QAngle_t;
|
||||
class IGameEvent;
|
||||
|
||||
namespace F::AUTOWALL {
|
||||
class c_auto_wall {
|
||||
public:
|
||||
struct data_t {
|
||||
enum e_pos { e_local, e_target };
|
||||
data_t() = default;
|
||||
|
||||
CS_INLINE data_t(const Vector_t local_pos, const Vector_t target_pos,
|
||||
C_BaseEntity* target,
|
||||
C_BaseEntity* local,
|
||||
C_CSPlayerPawn* localpawn, C_CSPlayerPawn* targetpawn,
|
||||
CCSWeaponBaseVData* wpn_data, const bool fire_bullet) noexcept :
|
||||
m_pos{ local_pos, target_pos },
|
||||
m_target(target),
|
||||
m_local(local),
|
||||
m_local_pawn(localpawn),
|
||||
m_target_pawn(targetpawn),
|
||||
m_wpn_data(wpn_data),
|
||||
m_can_hit(fire_bullet){}
|
||||
|
||||
|
||||
std::array< Vector_t, static_cast<int>(sizeof(e_pos)) > m_pos{ };
|
||||
C_BaseEntity* m_target{ }, * m_local{ };
|
||||
C_CSPlayerPawn* m_local_pawn{};
|
||||
C_CSPlayerPawn* m_target_pawn{};
|
||||
CCSWeaponBaseVData* m_wpn_data{ };
|
||||
|
||||
bool m_can_hit{ };
|
||||
float m_dmg{ };
|
||||
} m_data;
|
||||
void pen(data_t& data, const Vector_t local_pos, const Vector_t target_pos, C_BaseEntity* target, C_BaseEntity* local, C_CSPlayerPawn* localpawn, C_CSPlayerPawn* targetpawn,
|
||||
CCSWeaponBaseVData* wpn_data, float &dmg, bool &valid);
|
||||
void ScaleDamage(data_t& data, const int hitgroup, C_CSPlayerPawn* entity);
|
||||
bool FireBullet(data_t& data, float &dmg, bool &valid);
|
||||
void ScaleDamage2(const int iHitGroup, C_CSPlayerPawn* pCSPlayer, const float flWeaponArmorRatio, const float flWeaponHeadShotMultiplier, float* pflDamageToScale);
|
||||
public:
|
||||
[[nodiscard]] CS_INLINE auto get_data(data_t& data) const noexcept { return data; }
|
||||
};
|
||||
|
||||
extern std::unique_ptr<c_auto_wall> g_auto_wall;
|
||||
}
|
||||
@@ -0,0 +1,336 @@
|
||||
#include "post_processing.hpp"
|
||||
|
||||
// WIP
|
||||
|
||||
#define SAFE_RELEASE(p) \
|
||||
{ \
|
||||
if (p) { \
|
||||
(p)->Release(); \
|
||||
(p) = nullptr; \
|
||||
} \
|
||||
}
|
||||
|
||||
static inline ID3D11Device* pDevice; // DO NOT RELEASE!
|
||||
static inline ID3D11DeviceContext* pDeviceContext;
|
||||
static inline ID3D11RenderTargetView* pRenderTarget; // DO NOT RELEASE!
|
||||
static inline IDXGISwapChain* pSwapChain;
|
||||
|
||||
[[nodiscard]] static ID3D11Texture2D* createTexture(int width,
|
||||
int height) noexcept {
|
||||
D3D11_TEXTURE2D_DESC desc = {};
|
||||
desc.Width = width;
|
||||
desc.Height = height;
|
||||
desc.MipLevels = 1;
|
||||
desc.ArraySize = 1;
|
||||
desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
|
||||
desc.SampleDesc.Count = 1;
|
||||
desc.Usage = D3D11_USAGE_DEFAULT;
|
||||
desc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
|
||||
|
||||
ID3D11Texture2D* texture = nullptr;
|
||||
pDevice->CreateTexture2D(&desc, nullptr, &texture);
|
||||
return texture;
|
||||
}
|
||||
|
||||
static void copyBackbufferToTexture(ID3D11Texture2D* texture) noexcept {
|
||||
pSwapChain->GetBuffer(0, __uuidof(texture),
|
||||
reinterpret_cast<void**>(&texture));
|
||||
}
|
||||
|
||||
static void setRenderTarget(ID3D11Texture2D* rtTexture) noexcept {
|
||||
ID3D11RenderTargetView* rtv = nullptr;
|
||||
pDevice->CreateRenderTargetView(rtTexture, nullptr, &rtv);
|
||||
pDeviceContext->OMSetRenderTargets(1, &rtv, nullptr);
|
||||
rtv->Release();
|
||||
}
|
||||
|
||||
class ShaderProgram {
|
||||
public:
|
||||
~ShaderProgram() {
|
||||
if (pixelShader) pixelShader->Release();
|
||||
}
|
||||
|
||||
void use(float uniform, int location) const noexcept {
|
||||
pDeviceContext->PSSetShader(pixelShader, nullptr, 0);
|
||||
pDeviceContext->PSSetConstantBuffers(location, 1, &constBuffer);
|
||||
}
|
||||
|
||||
void init(const BYTE* pixelShaderSrc, size_t size) noexcept {
|
||||
if (initialized) return;
|
||||
initialized = true;
|
||||
pDevice->CreatePixelShader(pixelShaderSrc, size, nullptr, &pixelShader);
|
||||
}
|
||||
|
||||
private:
|
||||
ID3D11PixelShader* pixelShader = nullptr;
|
||||
ID3D11Buffer* constBuffer = nullptr;
|
||||
bool initialized = false;
|
||||
};
|
||||
|
||||
class BlurEffect {
|
||||
public:
|
||||
static void draw(ImDrawList* drawList, float alpha) noexcept {
|
||||
instance()._draw(drawList, alpha);
|
||||
}
|
||||
|
||||
static void draws(ImDrawList* drawList, const ImVec2& p_min,
|
||||
const ImVec2& p_max, float alpha) noexcept {
|
||||
instance()._draws(drawList, p_min, p_max, alpha);
|
||||
}
|
||||
|
||||
static void clearTextures() noexcept {
|
||||
SAFE_RELEASE(instance().pBlurTexture1);
|
||||
SAFE_RELEASE(instance().pBlurTexture2);
|
||||
}
|
||||
|
||||
private:
|
||||
ID3D11RenderTargetView* pRTBackup = nullptr;
|
||||
ID3D11Texture2D* pBlurTexture1 = nullptr;
|
||||
ID3D11Texture2D* pBlurTexture2 = nullptr;
|
||||
ID3D11RasterizerState* pRasterStateWithScissorDisabled = nullptr;
|
||||
ID3D11RasterizerState* pOriginalRasterState = nullptr;
|
||||
ID3D11RenderTargetView* pBlurTexture1RTV = nullptr;
|
||||
ID3D11RenderTargetView* pBlurTexture2RTV = nullptr;
|
||||
ID3D11Buffer* pVSConstantBuffer = nullptr;
|
||||
|
||||
ID3D11ShaderResourceView* pBlurTexture1SRV = nullptr;
|
||||
ID3D11ShaderResourceView* pBlurTexture2SRV = nullptr;
|
||||
|
||||
ShaderProgram blurShaderX;
|
||||
ShaderProgram blurShaderY;
|
||||
|
||||
int backbufferWidth = 0;
|
||||
int backbufferHeight = 0;
|
||||
static constexpr auto blurDownsample = 2;
|
||||
|
||||
BlurEffect() = default;
|
||||
BlurEffect(const BlurEffect&) = delete;
|
||||
|
||||
~BlurEffect() {
|
||||
SAFE_RELEASE(pRTBackup);
|
||||
SAFE_RELEASE(pRasterStateWithScissorDisabled);
|
||||
SAFE_RELEASE(pOriginalRasterState);
|
||||
SAFE_RELEASE(pBlurTexture1);
|
||||
SAFE_RELEASE(pBlurTexture2);
|
||||
SAFE_RELEASE(pBlurTexture1RTV);
|
||||
SAFE_RELEASE(pBlurTexture2RTV);
|
||||
SAFE_RELEASE(pBlurTexture1SRV);
|
||||
SAFE_RELEASE(pBlurTexture2SRV);
|
||||
SAFE_RELEASE(pVSConstantBuffer);
|
||||
}
|
||||
|
||||
static BlurEffect& instance() noexcept {
|
||||
static BlurEffect blurEffect;
|
||||
return blurEffect;
|
||||
}
|
||||
|
||||
static void begin(const ImDrawList*, const ImDrawCmd*) noexcept {
|
||||
instance()._begin();
|
||||
}
|
||||
|
||||
static void firstPass(const ImDrawList*, const ImDrawCmd*) noexcept {
|
||||
instance()._firstPass();
|
||||
}
|
||||
|
||||
static void secondPass(const ImDrawList*, const ImDrawCmd*) noexcept {
|
||||
instance()._secondPass();
|
||||
}
|
||||
|
||||
static void end(const ImDrawList*, const ImDrawCmd*) noexcept {
|
||||
instance()._end();
|
||||
}
|
||||
|
||||
void createTextures() noexcept {
|
||||
if (const auto [width, height] = ImGui::GetIO().DisplaySize;
|
||||
backbufferWidth != static_cast<int>(width) ||
|
||||
backbufferHeight != static_cast<int>(height)) {
|
||||
clearTextures();
|
||||
backbufferWidth = static_cast<int>(width);
|
||||
backbufferHeight = static_cast<int>(height);
|
||||
}
|
||||
|
||||
if (!pBlurTexture1)
|
||||
pBlurTexture1 = createTexture(backbufferWidth / blurDownsample,
|
||||
backbufferHeight / blurDownsample);
|
||||
if (!pBlurTexture2)
|
||||
pBlurTexture2 = createTexture(backbufferWidth / blurDownsample,
|
||||
backbufferHeight / blurDownsample);
|
||||
|
||||
D3D11_RENDER_TARGET_VIEW_DESC rtvDesc = {};
|
||||
rtvDesc.Format =
|
||||
DXGI_FORMAT_R8G8B8A8_UNORM; // Match this with your texture format.
|
||||
rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
|
||||
rtvDesc.Texture2D.MipSlice = 0;
|
||||
|
||||
pDevice->CreateRenderTargetView(pBlurTexture1, &rtvDesc, &pBlurTexture1RTV);
|
||||
pDevice->CreateRenderTargetView(pBlurTexture2, &rtvDesc, &pBlurTexture2RTV);
|
||||
}
|
||||
|
||||
void createShaders() noexcept {
|
||||
blurShaderX.init(reinterpret_cast<const BYTE*>(gaussian_blur_x),
|
||||
sizeof(gaussian_blur_x));
|
||||
blurShaderY.init(reinterpret_cast<const BYTE*>(gaussian_blur_y),
|
||||
sizeof(gaussian_blur_y));
|
||||
}
|
||||
|
||||
void _begin() noexcept {
|
||||
pDeviceContext->OMGetRenderTargets(1, &pRTBackup, nullptr);
|
||||
|
||||
copyBackbufferToTexture(pBlurTexture1);
|
||||
|
||||
D3D11_SAMPLER_DESC sampDesc = {};
|
||||
sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
|
||||
sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
|
||||
sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
|
||||
sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
|
||||
sampDesc.MaxLOD = D3D11_FLOAT32_MAX;
|
||||
ID3D11SamplerState* samplerState;
|
||||
pDevice->CreateSamplerState(&sampDesc, &samplerState);
|
||||
pDeviceContext->PSSetSamplers(0, 1, &samplerState);
|
||||
|
||||
pDeviceContext->RSGetState(&pOriginalRasterState);
|
||||
|
||||
D3D11_RASTERIZER_DESC rasterDesc = {};
|
||||
rasterDesc.FillMode = D3D11_FILL_SOLID; // Solid fill mode
|
||||
rasterDesc.CullMode = D3D11_CULL_BACK; // Cull back-facing triangles
|
||||
rasterDesc.ScissorEnable = FALSE; // Disable scissor test
|
||||
rasterDesc.DepthClipEnable = TRUE; // Enable depth clipping
|
||||
HRESULT hr = pDevice->CreateRasterizerState(
|
||||
&rasterDesc, &pRasterStateWithScissorDisabled);
|
||||
|
||||
if (FAILED(hr)) {
|
||||
printf("Failed CreateRasterizerState\n");
|
||||
}
|
||||
|
||||
pDeviceContext->RSSetState(pRasterStateWithScissorDisabled);
|
||||
|
||||
D3D11_BUFFER_DESC cbDesc = {};
|
||||
cbDesc.Usage = D3D11_USAGE_DEFAULT;
|
||||
cbDesc.ByteWidth = sizeof(VSConstants);
|
||||
cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
|
||||
|
||||
pDevice->CreateBuffer(&cbDesc, nullptr, &pVSConstantBuffer);
|
||||
|
||||
float aspectRatio = static_cast<float>(backbufferWidth) /
|
||||
static_cast<float>(backbufferHeight);
|
||||
DirectX::XMMATRIX projection = DirectX::XMMatrixOrthographicOffCenterLH(
|
||||
-1.0f / aspectRatio, 1.0f / aspectRatio, -1.0f, 1.0f, 0.0f, 1.0f);
|
||||
|
||||
VSConstants vsConsts = {};
|
||||
vsConsts.projection = XMMatrixTranspose(
|
||||
projection); // HLSL expects matrices to be transposed
|
||||
|
||||
pDeviceContext->UpdateSubresource(pVSConstantBuffer, 0, nullptr, &vsConsts,
|
||||
0, 0);
|
||||
pDeviceContext->VSSetConstantBuffers(0, 1, &pVSConstantBuffer);
|
||||
}
|
||||
|
||||
void _firstPass() noexcept {
|
||||
blurShaderX.use(2.0f / (backbufferWidth / blurDownsample), 0);
|
||||
pDeviceContext->OMSetRenderTargets(1, &pBlurTexture2RTV, nullptr);
|
||||
}
|
||||
|
||||
void _secondPass() noexcept {
|
||||
blurShaderY.use(2.0f / (backbufferHeight / blurDownsample), 0);
|
||||
pDeviceContext->OMSetRenderTargets(1, &pBlurTexture1RTV, nullptr);
|
||||
|
||||
pDevice->CreateShaderResourceView(pBlurTexture2, nullptr,
|
||||
&pBlurTexture2SRV);
|
||||
}
|
||||
|
||||
void _end() noexcept {
|
||||
pDeviceContext->OMSetRenderTargets(1, &pRTBackup, nullptr);
|
||||
pRTBackup->Release();
|
||||
pDeviceContext->PSSetShader(nullptr, nullptr, 0);
|
||||
pDeviceContext->RSSetState(pOriginalRasterState);
|
||||
|
||||
if (pRasterStateWithScissorDisabled)
|
||||
pRasterStateWithScissorDisabled->Release();
|
||||
}
|
||||
|
||||
void _draw(ImDrawList* drawList, float alpha) noexcept {
|
||||
createTextures();
|
||||
createShaders();
|
||||
|
||||
if (!pBlurTexture1RTV || !pBlurTexture2RTV) return;
|
||||
|
||||
drawList->AddCallback(&begin, nullptr);
|
||||
for (int i = 0; i < 8; ++i) {
|
||||
drawList->AddCallback(&firstPass, nullptr);
|
||||
pDevice->CreateShaderResourceView(pBlurTexture1, nullptr,
|
||||
&pBlurTexture1SRV);
|
||||
drawList->AddImage(
|
||||
(ImTextureID)pBlurTexture1SRV, ImVec2(-1.0f, -1.0f),
|
||||
ImVec2(1.0f, 1.0f)); // Assuming blurTexture1SRV is the Shader
|
||||
// Resource View for blurTexture1
|
||||
drawList->AddCallback(&secondPass, nullptr);
|
||||
drawList->AddImage((ImTextureID)pBlurTexture2SRV, ImVec2(-1.0f, -1.0f),
|
||||
ImVec2(1.0f, 1.0f)); // And similarly for blurTexture2
|
||||
}
|
||||
drawList->AddCallback(&end, nullptr);
|
||||
drawList->AddCallback(ImDrawCallback_ResetRenderState, nullptr);
|
||||
|
||||
drawList->AddImage(
|
||||
reinterpret_cast<ImTextureID>(pBlurTexture1SRV), {0.0f, 0.0f},
|
||||
{backbufferWidth * 1.0f, backbufferHeight * 1.0f}, {0.0f, 0.0f},
|
||||
{1.0f, 1.0f}, IM_COL32(255, 255, 255, 255 * alpha));
|
||||
|
||||
if (pOriginalRasterState) pOriginalRasterState->Release();
|
||||
}
|
||||
|
||||
void _draws(ImDrawList* drawList, const ImVec2& p_min, const ImVec2& p_max,
|
||||
float alpha) noexcept {
|
||||
createTextures();
|
||||
createShaders();
|
||||
|
||||
if (!pBlurTexture1RTV || !pBlurTexture2RTV) return;
|
||||
|
||||
drawList->AddCallback(&begin, nullptr);
|
||||
for (int i = 0; i < 8; ++i) {
|
||||
drawList->AddCallback(&firstPass, nullptr);
|
||||
pDevice->CreateShaderResourceView(pBlurTexture1, nullptr,
|
||||
&pBlurTexture1SRV);
|
||||
drawList->AddImage(reinterpret_cast<ImTextureID>(pBlurTexture1SRV), p_min,
|
||||
p_max, {1.0f, 1.0f});
|
||||
drawList->AddCallback(&secondPass, nullptr);
|
||||
pDevice->CreateShaderResourceView(pBlurTexture2, nullptr,
|
||||
&pBlurTexture2SRV);
|
||||
drawList->AddImage(reinterpret_cast<ImTextureID>(pBlurTexture2SRV), p_min,
|
||||
p_max, {1.0f, 1.0f});
|
||||
}
|
||||
drawList->AddCallback(&end, nullptr);
|
||||
drawList->AddCallback(ImDrawCallback_ResetRenderState, nullptr);
|
||||
|
||||
drawList->AddImage(
|
||||
reinterpret_cast<ImTextureID>(pBlurTexture2SRV), p_min, p_max,
|
||||
ImVec2((float)backbufferWidth * 1, (float)backbufferHeight * 1),
|
||||
ImVec2((float)backbufferWidth * 1, (float)backbufferHeight * 1),
|
||||
IM_COL32(255, 255, 255, 255 * alpha));
|
||||
}
|
||||
};
|
||||
|
||||
void PostProcessing::setDevice(ID3D11Device* device,
|
||||
ID3D11DeviceContext* deviceContext,
|
||||
ID3D11RenderTargetView* renderTarget,
|
||||
IDXGISwapChain* swapChain) noexcept {
|
||||
pDevice = device;
|
||||
pDeviceContext = deviceContext;
|
||||
pRenderTarget = renderTarget;
|
||||
pSwapChain = swapChain;
|
||||
}
|
||||
|
||||
void PostProcessing::clearBlurTextures() noexcept {
|
||||
BlurEffect::clearTextures();
|
||||
}
|
||||
|
||||
void PostProcessing::onDeviceReset() noexcept { BlurEffect::clearTextures(); }
|
||||
|
||||
void PostProcessing::performFullscreenBlur(ImDrawList* drawList,
|
||||
float alpha) noexcept {
|
||||
BlurEffect::draw(drawList, alpha);
|
||||
}
|
||||
|
||||
void PostProcessing::performBlur(ImDrawList* drawList, const ImVec2& p_min,
|
||||
const ImVec2& p_max, float alpha) noexcept {
|
||||
BlurEffect::draws(drawList, p_min, p_max, alpha);
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
#pragma once
|
||||
|
||||
// WIP
|
||||
|
||||
#define IMGUI_DEFINE_MATH_OPERATORS
|
||||
#include <DirectXMath.h>
|
||||
#include <d3d11.h>
|
||||
#include <dxgi1_2.h>
|
||||
#include <imgui.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <exception>
|
||||
#include <memory>
|
||||
|
||||
#include "../../sdk/shaders/build/gaussian_blur.hpp"
|
||||
|
||||
struct VSConstants {
|
||||
DirectX::XMMATRIX projection;
|
||||
};
|
||||
|
||||
namespace PostProcessing {
|
||||
void setDevice(ID3D11Device* device, ID3D11DeviceContext* deviceContext,
|
||||
ID3D11RenderTargetView* renderTarget,
|
||||
IDXGISwapChain* swapChain) noexcept;
|
||||
void clearBlurTextures() noexcept;
|
||||
void onDeviceReset() noexcept;
|
||||
void performFullscreenBlur(ImDrawList* drawList, float alpha) noexcept;
|
||||
void performBlur(ImDrawList* drawList, const ImVec2& p_min, const ImVec2& p_max,
|
||||
float alpha) noexcept;
|
||||
} // namespace PostProcessing
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,163 @@
|
||||
#pragma once
|
||||
|
||||
#include "../../common.h"
|
||||
#include <memory>
|
||||
// used: draw system
|
||||
#include "../../utilities/draw.h"
|
||||
#include "../../sdk/datatypes/vector.h"
|
||||
#include "../../sdk/datatypes/transform.h"
|
||||
#include "../../sdk/datatypes/qangle.h"
|
||||
#include "../cstrike/core/config.h"
|
||||
class CCSPlayerController;
|
||||
class C_BaseEntity;
|
||||
class C_CSPlayerPawn;
|
||||
class CBaseHandle;
|
||||
class CEntityInstance;
|
||||
class CUserCmd;
|
||||
class CBaseUserCmdPB;
|
||||
class QAngle_t;
|
||||
class CCSGOInput;
|
||||
class IGameEvent;
|
||||
class C_CSWeaponBase;
|
||||
class CCSWeaponBaseVData;
|
||||
class scan_data;
|
||||
class scan_point;
|
||||
class scanned_target;
|
||||
#define MAX_STUDIO_BONES 1024
|
||||
|
||||
#include <array>
|
||||
|
||||
namespace F::RAGE
|
||||
{
|
||||
enum events {
|
||||
round_start = 1,
|
||||
player_death = 2,
|
||||
};
|
||||
|
||||
|
||||
class impl {
|
||||
public:
|
||||
|
||||
|
||||
enum reset {
|
||||
entity,
|
||||
aimbot
|
||||
|
||||
};
|
||||
enum scan_mode {
|
||||
single, /* only 1 hitbox */
|
||||
adaptive /* multiple bones pushed in the same time */
|
||||
};
|
||||
|
||||
enum hitboxes {
|
||||
scan_head,
|
||||
scan_neck,
|
||||
scan_chest,
|
||||
scan_pelvis
|
||||
};
|
||||
|
||||
|
||||
enum stop_mode {
|
||||
slow = 0,
|
||||
early = 1
|
||||
};
|
||||
|
||||
enum silent_info {
|
||||
skipping = 0,
|
||||
on_tick = 1,
|
||||
};
|
||||
|
||||
struct aim_info {
|
||||
int minimum_damage;
|
||||
int rage_hitchance;
|
||||
int rage_target_select;
|
||||
int rage_enable;
|
||||
bool auto_stop;
|
||||
bool penetration;
|
||||
bool remove_weapon_accuracy_spread;
|
||||
bool hitbox_head;
|
||||
bool hitbox_neck;
|
||||
bool hitbox_uppeer_chest;
|
||||
bool hitbox_chest;
|
||||
bool hitbox_stomach;
|
||||
bool hitbox_legs;
|
||||
bool hitbox_feets;
|
||||
bool rapid_fire;
|
||||
bool failed_hitchance = false;
|
||||
bool do_rapid_fire;
|
||||
bool accurate;
|
||||
}rage_data;
|
||||
|
||||
enum command_msg {
|
||||
none = 0,
|
||||
rapid_fire = 1,
|
||||
teleport = 2,
|
||||
silent = 3,
|
||||
};
|
||||
enum response_msg {
|
||||
empty = 0,
|
||||
validated_view_angles = 1,
|
||||
};
|
||||
|
||||
struct SubTickData {
|
||||
QAngle_t best_point = QAngle_t(0, 0, 0);
|
||||
Vector_t best_point_vec = Vector_t(0, 0, 0);
|
||||
command_msg command = command_msg::none;
|
||||
response_msg response = response_msg::empty;
|
||||
|
||||
void reset() {
|
||||
best_point.Reset();
|
||||
best_point_vec = Vector_t(0, 0, 0);
|
||||
command = command_msg::none;
|
||||
response = response_msg::empty;
|
||||
}
|
||||
|
||||
}sub_tick_data;
|
||||
|
||||
float GetSpread(C_CSWeaponBase* weapon);
|
||||
float GetInaccuracy(C_CSPlayerPawn* pLocal, C_CSWeaponBase* weapon);
|
||||
float HitchanceFast(C_CSPlayerPawn* pLocal, C_CSWeaponBase* weapon);
|
||||
void Hitchance(C_CSPlayerPawn* pLocal, C_CSPlayerPawn* record, C_CSWeaponBase* weapon, QAngle_t vAimpoint);
|
||||
void AutomaticStop(C_CSPlayerPawn* pLocal, C_CSWeaponBase* weapon, CUserCmd* cmd, stop_mode mode = slow);
|
||||
void SortTarget();
|
||||
/* void inits */
|
||||
bool valid(C_CSPlayerPawn* pawn, C_CSPlayerPawn* pLocal, bool check = false);
|
||||
void ScanPoint(C_CSPlayerPawn* pLocal, CUserCmd* cmd, C_CSPlayerPawn* record, scan_data& data, const Vector_t& shoot_pos, bool optimized);
|
||||
std::vector <scan_point> get_points(C_CSPlayerPawn* pLocal, C_CSPlayerPawn* record, uint32_t hitbox, bool from_aim);
|
||||
void Scan();
|
||||
void Triggerbot(CUserCmd* cmd, C_BaseEntity* localent, C_BaseEntity* playerent, C_CSPlayerPawn* local, C_CSPlayerPawn* player, CCSWeaponBaseVData* vdata);
|
||||
void BuildSeed();
|
||||
void SetupTarget(C_CSPlayerPawn* pawn);
|
||||
void SetupAdaptiveWeapon(C_CSPlayerPawn* pawn);
|
||||
void ScanTarget(C_CSPlayerPawn* pLocal, CUserCmd* cmd, QAngle_t viewangles);
|
||||
Vector_t eye_pos;
|
||||
float ScaleDamage(C_CSPlayerPawn* target, C_CSPlayerPawn* pLocal, C_CSWeaponBase* weapon, Vector_t aim_point, float& dmg, bool& canHit);
|
||||
bool CanHit(Vector_t start, Vector_t end, C_CSPlayerPawn* pLocal, C_CSPlayerPawn* record, int box);
|
||||
void Reset(reset type);
|
||||
void Run(C_CSPlayerPawn* pLocal, CCSGOInput* pInput, CUserCmd* cmd);
|
||||
bool Ready(C_CSPlayerPawn* pLocal);
|
||||
void Events(IGameEvent* event_listener, events type);
|
||||
bool IsAccurate(scan_data& data, CUserCmd* cmd, C_CSPlayerPawn* local);
|
||||
bool Attack(CUserCmd* cmd, C_CSPlayerPawn* pLocal, scan_data& data);
|
||||
void AjustRecoil(C_CSPlayerPawn* player, CUserCmd* pCmd);
|
||||
/* init class */
|
||||
aim_info aimbot_info;
|
||||
silent_info silent_info;
|
||||
inline static std::vector<std::pair<float, float>> m_computed_seeds;
|
||||
|
||||
};
|
||||
const auto rage = std::make_unique<impl>();
|
||||
}
|
||||
|
||||
namespace F::LAGCOMP
|
||||
{
|
||||
|
||||
class impl {
|
||||
public:
|
||||
/* void inits */
|
||||
void Initialize();
|
||||
void Start(CUserCmd* cmd) noexcept;
|
||||
void Render() noexcept;
|
||||
};
|
||||
const auto lagcomp = std::make_unique<impl>();
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
#include "ccsinventorymanager.hpp"
|
||||
|
||||
#include "../cstrike/utilities/memory.h"
|
||||
#include "../cstrike/core/interfaces.h"
|
||||
#include "../cstrike/core/hooks.h"
|
||||
CCSInventoryManager* CCSInventoryManager::GetInstance() {
|
||||
if (!H::fnGetInventoryManager) return nullptr;
|
||||
return H::fnGetInventoryManager();
|
||||
|
||||
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
#pragma once
|
||||
|
||||
#include "../cstrike/utilities/memory.h"
|
||||
class CCSPlayerInventory;
|
||||
|
||||
class CCSInventoryManager {
|
||||
public:
|
||||
static CCSInventoryManager* GetInstance();
|
||||
|
||||
auto EquipItemInLoadout(int iTeam, int iSlot, uint64_t iItemID) {
|
||||
return MEM::CallVFunc<bool, 54u>( this, iTeam, iSlot, iItemID);
|
||||
}
|
||||
auto GetLocalInventory() {
|
||||
return MEM::CallVFunc<CCSPlayerInventory*, 57u>(this);
|
||||
}
|
||||
|
||||
};
|
||||
@@ -0,0 +1,127 @@
|
||||
#include "ccsplayerinventory.hpp"
|
||||
#include "../cstrike/sdk/entity.h"
|
||||
#include "../cstrike/utilities/memory.h"
|
||||
#include "../cstrike/core/hooks.h"
|
||||
static CGCClientSharedObjectTypeCache* CreateBaseTypeCache(
|
||||
CCSPlayerInventory* pInventory) {
|
||||
if (H::fnGetClientSystem() == nullptr) {
|
||||
L_PRINT(LOG_ERROR) << "failed to get client sys";
|
||||
return nullptr;
|
||||
}
|
||||
CGCClientSystem* pGCClientSystem = H::fnGetClientSystem();
|
||||
L_PRINT(LOG_ERROR) << "1";
|
||||
|
||||
if (!pGCClientSystem) return nullptr;
|
||||
|
||||
CGCClient* pGCClient = pGCClientSystem->GetCGCClient();
|
||||
if (!pGCClient) return nullptr;
|
||||
L_PRINT(LOG_ERROR) << "2";
|
||||
|
||||
CGCClientSharedObjectCache* pSOCache =
|
||||
pGCClient->FindSOCache(pInventory->GetOwner());
|
||||
if (!pSOCache) return nullptr;
|
||||
L_PRINT(LOG_ERROR) << "3";
|
||||
|
||||
return pSOCache->CreateBaseTypeCache(k_EEconTypeItem);
|
||||
}
|
||||
|
||||
CCSPlayerInventory* CCSPlayerInventory::GetInstance() {
|
||||
CCSInventoryManager* pInventoryManager = CCSInventoryManager::GetInstance();
|
||||
if (!pInventoryManager) return nullptr;
|
||||
|
||||
return pInventoryManager->GetLocalInventory();
|
||||
}
|
||||
|
||||
bool CCSPlayerInventory::AddEconItem(CEconItem* pItem) {
|
||||
// Helper function to aid in adding items.
|
||||
if (!pItem) return false;
|
||||
|
||||
CGCClientSharedObjectTypeCache* pSOTypeCache = ::CreateBaseTypeCache(this);
|
||||
if (!pSOTypeCache || !pSOTypeCache->AddObject((CSharedObject*)pItem))
|
||||
return false;
|
||||
|
||||
SOCreated(GetOwner(), (CSharedObject*)pItem, eSOCacheEvent_Incremental);
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCSPlayerInventory::RemoveEconItem(CEconItem* pItem) {
|
||||
// Helper function to aid in removing items.
|
||||
if (!pItem) return;
|
||||
|
||||
CGCClientSharedObjectTypeCache* pSOTypeCache = ::CreateBaseTypeCache(this);
|
||||
if (!pSOTypeCache) return;
|
||||
|
||||
const CUtlVector<CEconItem*>& pSharedObjects =
|
||||
pSOTypeCache->GetVecObjects<CEconItem*>();
|
||||
if (!pSharedObjects.Find(pItem)) return;
|
||||
|
||||
SODestroyed(GetOwner(), (CSharedObject*)pItem, eSOCacheEvent_Incremental);
|
||||
pSOTypeCache->RemoveObject((CSharedObject*)pItem);
|
||||
|
||||
pItem->Destruct();
|
||||
}
|
||||
|
||||
std::pair<uint64_t, uint32_t> CCSPlayerInventory::GetHighestIDs() {
|
||||
uint64_t maxItemID = 0;
|
||||
uint32_t maxInventoryID = 0;
|
||||
|
||||
CGCClientSharedObjectTypeCache* pSOTypeCache = ::CreateBaseTypeCache(this);
|
||||
if (pSOTypeCache) {
|
||||
const CUtlVector<CEconItem*>& vecItems =
|
||||
pSOTypeCache->GetVecObjects<CEconItem*>();
|
||||
|
||||
for (CEconItem* it : vecItems) {
|
||||
if (!it) continue;
|
||||
|
||||
// Checks if item is default.
|
||||
if ((it->m_ulID & 0xF000000000000000) != 0) continue;
|
||||
|
||||
maxItemID = std::max(maxItemID, it->m_ulID);
|
||||
maxInventoryID = std::max(maxInventoryID, it->m_unInventory);
|
||||
}
|
||||
}
|
||||
|
||||
return std::make_pair(maxItemID, maxInventoryID);
|
||||
}
|
||||
|
||||
C_EconItemView* CCSPlayerInventory::GetItemViewForItem(uint64_t itemID) {
|
||||
C_EconItemView* pEconItemView = nullptr;
|
||||
|
||||
const CUtlVector<C_EconItemView*>& pItems = GetItemVector();
|
||||
for (C_EconItemView* it : pItems) {
|
||||
if (it && it->m_iItemID() == itemID) {
|
||||
pEconItemView = it;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return pEconItemView;
|
||||
}
|
||||
|
||||
CEconItem* CCSPlayerInventory::GetSOCDataForItem(uint64_t itemID) {
|
||||
CEconItem* pSOCData = nullptr;
|
||||
L_PRINT(LOG_INFO) << "ID WE WANT: " << (int)itemID;
|
||||
|
||||
CGCClientSharedObjectTypeCache* pSOTypeCache = ::CreateBaseTypeCache(this);
|
||||
if (pSOTypeCache) {
|
||||
L_PRINT(LOG_INFO) << "got pSOTypeCache";
|
||||
|
||||
const CUtlVector<CEconItem*>& vecItems =
|
||||
pSOTypeCache->GetVecObjects<CEconItem*>();
|
||||
|
||||
for (CEconItem* it : vecItems) {
|
||||
if (it && (int)it->m_ulID == (int)itemID) {
|
||||
L_PRINT(LOG_INFO) << "got m_unDefIndex: " << it->m_unDefIndex;
|
||||
L_PRINT(LOG_INFO) << "got m_ulID: " << (int)it->m_ulID;
|
||||
L_PRINT(LOG_INFO) << "got m_ulOriginalID: " << (int)it->m_ulOriginalID;
|
||||
|
||||
pSOCData = it;
|
||||
return pSOCData;
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return pSOCData;
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
#pragma once
|
||||
|
||||
#include <utility>
|
||||
|
||||
|
||||
#include "../cstrike/sdk/entity.h"
|
||||
#include "../cstrike/sdk/datatypes/utlvector.h"
|
||||
|
||||
|
||||
#include "ccsinventorymanager.hpp"
|
||||
#include <cstdint>
|
||||
|
||||
|
||||
class CCSPlayerInventory {
|
||||
public:
|
||||
static CCSPlayerInventory* GetInstance();
|
||||
|
||||
auto SOCreated(SOID_t owner, CSharedObject* pObject, ESOCacheEvent eEvent) {
|
||||
return MEM::CallVFunc<void, 0u>(this, owner, pObject, eEvent);
|
||||
}
|
||||
|
||||
auto SOUpdated(SOID_t owner, CSharedObject* pObject, ESOCacheEvent eEvent) {
|
||||
return MEM::CallVFunc<void, 1u>(this, owner, pObject, eEvent);
|
||||
|
||||
}
|
||||
|
||||
auto SODestroyed(SOID_t owner, CSharedObject* pObject, ESOCacheEvent eEvent) {
|
||||
return MEM::CallVFunc<void, 2u>(this, owner, pObject, eEvent);
|
||||
}
|
||||
|
||||
auto GetItemInLoadout(int iClass, int iSlot) {
|
||||
return MEM::CallVFunc<C_EconItemView*,8u>(this, iClass, iSlot);
|
||||
}
|
||||
|
||||
bool AddEconItem(CEconItem* pItem);
|
||||
void RemoveEconItem(CEconItem* pItem);
|
||||
std::pair<uint64_t, uint32_t> GetHighestIDs();
|
||||
C_EconItemView* GetItemViewForItem(uint64_t itemID);
|
||||
CEconItem* GetSOCDataForItem(uint64_t itemID);
|
||||
|
||||
auto GetOwner() {
|
||||
return *reinterpret_cast<SOID_t*>((uintptr_t)(this) + 0x10);
|
||||
}
|
||||
|
||||
auto& GetItemVector() {
|
||||
return *reinterpret_cast<CUtlVector<C_EconItemView*>*>(
|
||||
(uintptr_t)(this) + 0x20);
|
||||
}
|
||||
};
|
||||
@@ -0,0 +1,482 @@
|
||||
#include <vector>
|
||||
|
||||
#include "skin_changer.hpp"
|
||||
|
||||
#include "../cstrike/sdk/interfaces/iengineclient.h"
|
||||
#include "../../core/config.h"
|
||||
#include "../../core/variables.h"
|
||||
#include "../../sdk/datatypes/usercmd.h"
|
||||
#include "../../core/sdk.h"
|
||||
#include "../../sdk/entity.h"
|
||||
#include "../../sdk/interfaces/iglobalvars.h"
|
||||
#include "../../sdk/interfaces/cgameentitysystem.h"
|
||||
#include "../cstrike/sdk/interfaces/iengineclient.h"
|
||||
#include "../../sdk/datatypes/qangle.h"
|
||||
#include "../../sdk/datatypes/vector.h"
|
||||
#include "../cstrike/sdk/interfaces/inetworkclientservice.h"
|
||||
#include "../cstrike/sdk/interfaces/ccsgoinput.h"
|
||||
#include "../misc/movement.h"
|
||||
#include "../cstrike/sdk/interfaces/ccsgoinput.h"
|
||||
#include "../cstrike/sdk/interfaces/ienginecvar.h"
|
||||
#include "../lagcomp/lagcomp.h"
|
||||
#include "../cstrike/sdk/interfaces/events.h"
|
||||
#include "../penetration/penetration.h"
|
||||
#include "../cstrike/sdk/interfaces/itrace.h"
|
||||
#include "../cstrike/core/spoofcall/syscall.h"
|
||||
#include <iostream>
|
||||
#include <memoryapi.h>
|
||||
#include <mutex>
|
||||
#include <array>
|
||||
#include "../cstrike/sdk/interfaces/iengineclient.h"
|
||||
#include "../../core/spoofcall/virtualization/VirtualizerSDK64.h"
|
||||
#include "../../utilities/inputsystem.h"
|
||||
#include "ccsinventorymanager.hpp"
|
||||
#include "ccsplayerinventory.hpp"
|
||||
#include "../cstrike/core/hooks.h"
|
||||
static std::vector<uint64_t> g_vecAddedItemsIDs;
|
||||
|
||||
static int glove_frame = 0;
|
||||
struct GloveInfo {
|
||||
int itemId;
|
||||
uint64_t itemHighId;
|
||||
uint64_t itemLowId;
|
||||
int itemDefId;
|
||||
};
|
||||
static GloveInfo addedGloves;
|
||||
|
||||
// Define a struct to hold glove information
|
||||
|
||||
|
||||
struct material_info
|
||||
{
|
||||
skin_changer::material_record* p_mat_records;
|
||||
uint32_t ui32_count;
|
||||
};
|
||||
|
||||
void invalidate_glove_material(C_BaseViewModel* viewmodel)
|
||||
{
|
||||
material_info* p_mat_info = reinterpret_cast<material_info*>(reinterpret_cast<uint8_t*>(viewmodel) + 0xf80);
|
||||
|
||||
for (uint32_t i = 0; i < p_mat_info->ui32_count; i++)
|
||||
{
|
||||
if (p_mat_info->p_mat_records[i].identifer == skin_changer::material_magic_number__gloves)
|
||||
{
|
||||
p_mat_info->p_mat_records[i].ui32_type_index = 0xffffffff;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
void skin_changer::OnGlove(CCSPlayerInventory* pInventory, C_CSPlayerPawn* pLocalPawn, C_BaseViewModel* pViewModel, C_EconItemView* GlovesItem, CEconItemDefinition* GlovesDefinition) {
|
||||
|
||||
if (!pLocalPawn) return;
|
||||
|
||||
if (pLocalPawn->GetHealth() <= 0)
|
||||
return;
|
||||
|
||||
if (!pViewModel)
|
||||
return;
|
||||
|
||||
if (!GlovesItem)
|
||||
return;
|
||||
|
||||
if (!GlovesDefinition) return;
|
||||
|
||||
if (addedGloves.itemId == 0)
|
||||
return;
|
||||
|
||||
|
||||
if (glove_frame)
|
||||
{
|
||||
invalidate_glove_material(pViewModel);
|
||||
|
||||
GlovesItem->m_bInitialized() = true;
|
||||
pLocalPawn->m_bNeedToReApplyGloves() = true;
|
||||
|
||||
glove_frame--;
|
||||
}
|
||||
|
||||
if (GlovesItem->m_iItemID() != addedGloves.itemId) {
|
||||
|
||||
glove_frame = 2;
|
||||
|
||||
GlovesItem->m_bDisallowSOC() = false;
|
||||
|
||||
GlovesItem->m_iItemID() = addedGloves.itemId;
|
||||
GlovesItem->m_iItemIDHigh() = addedGloves.itemHighId;
|
||||
GlovesItem->m_iItemIDLow() = addedGloves.itemLowId;
|
||||
GlovesItem->m_iAccountID() = uint32_t(pInventory->GetOwner().m_id);
|
||||
GlovesItem->m_iItemDefinitionIndex() = addedGloves.itemDefId;
|
||||
GlovesItem->m_bDisallowSOC() = false;
|
||||
|
||||
pViewModel->GetGameSceneNode()->SetMeshGroupMask(1);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void skin_changer::OnFrameStageNotify(int frameStage) {
|
||||
if (frameStage != 6) return;
|
||||
|
||||
|
||||
CCSPlayerInventory* pInventory = CCSPlayerInventory::GetInstance();
|
||||
if (!pInventory) return;
|
||||
|
||||
CGameEntitySystem* pEntitySystem = I::GameResourceService->pGameEntitySystem;
|
||||
if (!pEntitySystem) return;
|
||||
|
||||
const uint64_t steamID = pInventory->GetOwner().m_id;
|
||||
|
||||
CCSPlayerController* pLocalPlayerController = CCSPlayerController::GetLocalPlayerController();
|
||||
if (!pLocalPlayerController) return;
|
||||
|
||||
C_CSPlayerPawn* pLocalPawn = I::GameResourceService->pGameEntitySystem->Get<C_CSPlayerPawn>(pLocalPlayerController->GetPawnHandle());
|
||||
if (!pLocalPawn) return;
|
||||
|
||||
if (pLocalPawn->GetHealth() <= 0)
|
||||
return;
|
||||
|
||||
CCSPlayer_ViewModelServices* pViewModelServices = pLocalPawn->GetViewModelServices();
|
||||
if (!pViewModelServices) return;
|
||||
|
||||
C_CSGOViewModel* pViewModel = I::GameResourceService->pGameEntitySystem->Get<C_CSGOViewModel>(pViewModelServices->m_hViewModel());
|
||||
if (!pViewModel)
|
||||
return;
|
||||
C_EconItemView* pGloves = &pLocalPawn->m_EconGloves();
|
||||
CEconItemDefinition* pGlovesDefinition = pGloves->GetStaticData();
|
||||
|
||||
skin_changer::OnGlove(pInventory, pLocalPawn, pViewModel, pGloves, pGlovesDefinition);
|
||||
|
||||
|
||||
int highestIndex = pEntitySystem->GetHighestEntityIndex();
|
||||
for (int i = 64 + 1; i <= highestIndex; ++i) {
|
||||
C_BaseEntity* pEntity = pEntitySystem->Get(i);
|
||||
if (!pEntity || !pEntity->IsWeapon()) continue;
|
||||
|
||||
C_CSWeaponBase* pWeapon = reinterpret_cast<C_CSWeaponBase*>(pEntity);
|
||||
if (pWeapon->GetOriginalOwnerXuid() != steamID) continue;
|
||||
|
||||
CAttributeManager* pAttributeContainer = &pWeapon->m_AttributeManager();
|
||||
if (!pAttributeContainer) continue;
|
||||
|
||||
C_EconItemView* pWeaponItemView = &pAttributeContainer->m_Item();
|
||||
if (!pWeaponItemView) continue;
|
||||
|
||||
CEconItemDefinition* pWeaponDefinition =
|
||||
pWeaponItemView->GetStaticData();
|
||||
if (!pWeaponDefinition) continue;
|
||||
|
||||
CGameSceneNode* pWeaponSceneNode = pWeapon->GetGameSceneNode();
|
||||
if (!pWeaponSceneNode) continue;
|
||||
|
||||
// No idea how to check this faster with the new loadout system.
|
||||
C_EconItemView* pWeaponInLoadoutItemView = nullptr;
|
||||
|
||||
if (pWeaponDefinition->IsWeapon()) {
|
||||
for (int i = 0; i <= 56; ++i) {
|
||||
C_EconItemView* pItemView = pInventory->GetItemInLoadout(
|
||||
pWeapon->m_iOriginalTeamNumber(), i);
|
||||
if (!pItemView) continue;
|
||||
|
||||
if (pItemView->m_iItemDefinitionIndex() ==
|
||||
pWeaponDefinition->m_nDefIndex) {
|
||||
pWeaponInLoadoutItemView = pItemView;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
pWeaponInLoadoutItemView = pInventory->GetItemInLoadout(
|
||||
pWeapon->m_iOriginalTeamNumber(),
|
||||
pWeaponDefinition->GetLoadoutSlot());
|
||||
}
|
||||
|
||||
if (!pWeaponInLoadoutItemView)
|
||||
continue;
|
||||
|
||||
// Check if skin is added by us.
|
||||
auto it = std::find(g_vecAddedItemsIDs.cbegin(), g_vecAddedItemsIDs.cend(), pWeaponInLoadoutItemView->m_iItemID());
|
||||
if (it == g_vecAddedItemsIDs.cend()) continue;
|
||||
|
||||
CEconItemDefinition* pWeaponInLoadoutDefinition = pWeaponInLoadoutItemView->GetStaticData();
|
||||
if (!pWeaponInLoadoutDefinition) continue;
|
||||
|
||||
// Example: Will not equip FiveSeven skin on CZ. Not applies for knives.
|
||||
const bool isKnife = pWeaponInLoadoutDefinition->IsKnife(false, pWeaponInLoadoutDefinition->m_pszItemBaseName);
|
||||
L_PRINT(LOG_INFO) << "applying skin on:" << pWeaponInLoadoutDefinition->m_pszItemBaseName;
|
||||
pWeaponItemView->m_bDisallowSOC() = false;
|
||||
pWeaponInLoadoutItemView->m_bDisallowSOC() = false;
|
||||
|
||||
pWeaponItemView->m_iItemID() = pWeaponInLoadoutItemView->m_iItemID();
|
||||
pWeaponItemView->m_iItemIDHigh() = pWeaponInLoadoutItemView->m_iItemIDHigh();
|
||||
pWeaponItemView->m_iItemIDLow() = pWeaponInLoadoutItemView->m_iItemIDLow();
|
||||
pWeaponItemView->m_iAccountID() = uint32_t(pInventory->GetOwner().m_id);
|
||||
pWeaponItemView->m_iItemDefinitionIndex() = pWeaponInLoadoutDefinition->m_nDefIndex;
|
||||
|
||||
// pWeaponItemView->m_bIsStoreItem() = true;
|
||||
//pWeaponItemView->m_bIsTradeItem() = true;
|
||||
|
||||
|
||||
// Displays nametag and stattrak on the gun.
|
||||
// Found by: https://www.unknowncheats.me/forum/members/2377851.html
|
||||
/* if (!pWeapon->m_bUIWeapon()) {
|
||||
pWeapon->AddStattrakEntity();
|
||||
pWeapon->AddNametagEntity();
|
||||
}*/
|
||||
|
||||
CBaseHandle hWeapon = pWeapon->GetRefEHandle();
|
||||
if (isKnife) {
|
||||
if (pViewModel && (pViewModel->m_hWeapon().GetEntryIndex() == hWeapon.GetEntryIndex() || pViewModel->m_hWeapon() == hWeapon)) {
|
||||
pWeaponItemView->m_iItemDefinitionIndex() = pWeaponInLoadoutDefinition->m_nDefIndex;
|
||||
|
||||
const char* knifeModel = pWeaponInLoadoutDefinition->GetModelName();
|
||||
|
||||
CGameSceneNode* pViewModelSceneNode = pViewModel->GetGameSceneNode();
|
||||
if (pViewModelSceneNode) {
|
||||
pWeaponSceneNode->SetMeshGroupMask(2);
|
||||
pViewModelSceneNode->SetMeshGroupMask(2);
|
||||
}
|
||||
pWeapon->SetModel(knifeModel);
|
||||
pViewModel->SetModel(knifeModel);
|
||||
pViewModel->pAnimationGraphInstance->pAnimGraphNetworkedVariables = nullptr;
|
||||
}
|
||||
}
|
||||
else {
|
||||
// Use legacy weapon models only for skins that require them.
|
||||
// Probably need to cache this if you really care that much about
|
||||
// performance
|
||||
|
||||
const char* model = pWeaponInLoadoutDefinition->GetModelName();
|
||||
pWeapon->SetModel(model);
|
||||
if (pViewModel && pViewModel->m_hWeapon() == hWeapon)
|
||||
{
|
||||
pViewModel->SetModel(model);
|
||||
}
|
||||
|
||||
pWeaponSceneNode->SetMeshGroupMask(2);
|
||||
if (pViewModel && pViewModel->m_hWeapon().GetEntryIndex() == hWeapon.GetEntryIndex()) {
|
||||
CGameSceneNode* pViewModelSceneNode = pViewModel->GetGameSceneNode();
|
||||
|
||||
pViewModelSceneNode->SetMeshGroupMask(2);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#include "../cstrike/sdk/interfaces/ccsgoinput.h"
|
||||
|
||||
void skin_changer::OnEquipItemInLoadout(int team, int slot, uint64_t itemID) {
|
||||
auto it =
|
||||
std::find(g_vecAddedItemsIDs.begin(), g_vecAddedItemsIDs.end(), itemID);
|
||||
if (it == g_vecAddedItemsIDs.end()) return;
|
||||
|
||||
CCSInventoryManager* pInventoryManager = CCSInventoryManager::GetInstance();
|
||||
if (!pInventoryManager) return;
|
||||
|
||||
CCSPlayerInventory* pInventory = CCSPlayerInventory::GetInstance();
|
||||
if (!pInventory) return;
|
||||
|
||||
C_EconItemView* pItemViewToEquip = pInventory->GetItemViewForItem(*it);
|
||||
if (!pItemViewToEquip) return;
|
||||
|
||||
C_EconItemView* pItemInLoadout = pInventory->GetItemInLoadout(team, slot);
|
||||
if (!pItemInLoadout) return;
|
||||
|
||||
CEconItemDefinition* pItemInLoadoutStaticData = pItemInLoadout->GetStaticData();
|
||||
if (!pItemInLoadoutStaticData)
|
||||
return;
|
||||
|
||||
// Equip default item. If you would have bought Deagle and you previously
|
||||
// had R8 equipped it will now give you a Deagle.
|
||||
const uint64_t defaultItemID = (std::uint64_t(0xF) << 60) | pItemViewToEquip->m_iItemDefinitionIndex();
|
||||
pInventoryManager->EquipItemInLoadout(team, slot, defaultItemID);
|
||||
|
||||
CEconItem* pItemInLoadoutSOCData = pItemInLoadout->GetSOCData(nullptr);
|
||||
if (!pItemInLoadoutSOCData)
|
||||
return;
|
||||
|
||||
CEconItemDefinition* toequipdata = pItemViewToEquip->GetStaticData();
|
||||
if (!toequipdata)
|
||||
return;
|
||||
|
||||
if (toequipdata->IsWeapon() && !toequipdata->IsKnife(false, pItemInLoadoutStaticData->m_pszItemTypeName) && !toequipdata->IsGlove(false, pItemInLoadoutStaticData->m_pszItemTypeName)) {
|
||||
|
||||
pInventory->SOUpdated(pInventory->GetOwner(), (CSharedObject*)pItemInLoadoutSOCData, eSOCacheEvent_Incremental);
|
||||
return;
|
||||
}
|
||||
else if (toequipdata->IsGlove(false, pItemInLoadoutStaticData->m_pszItemTypeName)) {
|
||||
const uint64_t steamID = pInventory->GetOwner().m_id;
|
||||
|
||||
CCSPlayerController* pLocalPlayerController = CCSPlayerController::GetLocalPlayerController();
|
||||
if (!pLocalPlayerController) return;
|
||||
|
||||
C_CSPlayerPawn* pLocalPawn = I::GameResourceService->pGameEntitySystem->Get<C_CSPlayerPawn>(pLocalPlayerController->GetPawnHandle());
|
||||
if (!pLocalPawn) return;
|
||||
|
||||
if (pLocalPawn->GetHealth() <= 0)
|
||||
return;
|
||||
|
||||
CCSPlayer_ViewModelServices* pViewModelServices = pLocalPawn->GetViewModelServices();
|
||||
if (!pViewModelServices) return;
|
||||
|
||||
C_BaseViewModel* pViewModel = I::GameResourceService->pGameEntitySystem->Get<C_BaseViewModel>(pViewModelServices->m_hViewModel());
|
||||
if (!pViewModel)
|
||||
return;
|
||||
|
||||
// Create a struct to store glove information
|
||||
addedGloves.itemId = pItemViewToEquip->m_iItemID();
|
||||
addedGloves.itemHighId = pItemViewToEquip->m_iItemIDHigh();
|
||||
addedGloves.itemLowId = pItemViewToEquip->m_iItemIDLow();
|
||||
addedGloves.itemDefId = pItemViewToEquip->m_iItemDefinitionIndex();
|
||||
|
||||
C_EconItemView* pGloves = &pLocalPawn->m_EconGloves();
|
||||
if (!pGloves)
|
||||
return;
|
||||
|
||||
CEconItemDefinition* pGlovesDefinition = pGloves->GetStaticData();
|
||||
if (!pGlovesDefinition)
|
||||
return;
|
||||
|
||||
skin_changer::OnGlove(pInventory, pLocalPawn, pViewModel, pGloves, pGlovesDefinition);
|
||||
pLocalPawn->m_bNeedToReApplyGloves() = true;
|
||||
pInventory->SOUpdated(pInventory->GetOwner(), (CSharedObject*)pItemInLoadoutSOCData, eSOCacheEvent_Incremental);
|
||||
return;
|
||||
}
|
||||
else if (toequipdata->IsKnife(false, pItemInLoadoutStaticData->m_pszItemTypeName)) {
|
||||
pInventory->SOUpdated(pInventory->GetOwner(), (CSharedObject*)pItemInLoadoutSOCData, eSOCacheEvent_Incremental);
|
||||
return;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void skin_changer::OnSetModel(C_BaseModelEntity* pEntity, const char*& model) {
|
||||
// When you're lagging you may see the default knife for one second and this
|
||||
// function fixes that.
|
||||
if (!I::Engine->IsConnected() || !I::Engine->IsInGame())
|
||||
return;
|
||||
|
||||
CCSPlayerController* pLocalPlayerController = CCSPlayerController::GetLocalPlayerController();
|
||||
if (!pLocalPlayerController) return;
|
||||
|
||||
C_CSPlayerPawn* pLocalPawn = I::GameResourceService->pGameEntitySystem->Get<C_CSPlayerPawn>(pLocalPlayerController->GetPawnHandle());
|
||||
if (!pLocalPawn) return;
|
||||
|
||||
if (pLocalPawn->GetHealth() <= 0)
|
||||
return;
|
||||
|
||||
if (!pEntity || !pEntity->IsViewModel()) return;
|
||||
|
||||
C_BaseViewModel* pViewModel = (C_BaseViewModel*)pEntity;
|
||||
if (!pViewModel)
|
||||
return;
|
||||
CCSPlayerInventory* pInventory = CCSPlayerInventory::GetInstance();
|
||||
if (!pInventory) return;
|
||||
|
||||
const uint64_t steamID = pInventory->GetOwner().m_id;
|
||||
|
||||
C_CSWeaponBase* pWeapon = I::GameResourceService->pGameEntitySystem->Get<C_CSWeaponBase>(pViewModel->m_hWeapon());
|
||||
if (!pWeapon) return;
|
||||
|
||||
if (!pWeapon || !pWeapon->IsWeapon() ||
|
||||
pWeapon->GetOriginalOwnerXuid() != steamID)
|
||||
return;
|
||||
|
||||
CAttributeManager* pAttributeContainer = &pWeapon->m_AttributeManager();
|
||||
if (!pAttributeContainer) return;
|
||||
|
||||
|
||||
C_EconItemView* pWeaponItemView = &pAttributeContainer->m_Item();
|
||||
if (!pWeaponItemView) return;
|
||||
|
||||
CEconItemDefinition* pWeaponDefinition = pWeaponItemView->GetStaticData();
|
||||
if (!pWeaponDefinition) return;
|
||||
|
||||
C_EconItemView* pWeaponInLoadoutItemView = pInventory->GetItemInLoadout(
|
||||
pWeapon->m_iOriginalTeamNumber(), pWeaponDefinition->GetLoadoutSlot());
|
||||
if (!pWeaponInLoadoutItemView) return;
|
||||
|
||||
// Check if skin is added by us.
|
||||
auto it = std::find(g_vecAddedItemsIDs.cbegin(), g_vecAddedItemsIDs.cend(),
|
||||
pWeaponInLoadoutItemView->m_iItemID());
|
||||
if (it == g_vecAddedItemsIDs.cend()) return;
|
||||
|
||||
CEconItemDefinition* pWeaponInLoadoutDefinition =
|
||||
pWeaponInLoadoutItemView->GetStaticData();
|
||||
|
||||
if (!pWeaponInLoadoutDefinition)// ||
|
||||
return;
|
||||
|
||||
model = pWeaponInLoadoutDefinition->GetModelName();
|
||||
}
|
||||
|
||||
void skin_changer::AddEconItemToList(CEconItem* pItem) {
|
||||
g_vecAddedItemsIDs.emplace_back(pItem->m_ulID);
|
||||
}
|
||||
|
||||
void skin_changer::Shutdown() {
|
||||
CCSPlayerInventory* pInventory = CCSPlayerInventory::GetInstance();
|
||||
if (!pInventory) return;
|
||||
|
||||
for (uint64_t id : g_vecAddedItemsIDs) {
|
||||
pInventory->RemoveEconItem(pInventory->GetSOCDataForItem(id));
|
||||
}
|
||||
}
|
||||
|
||||
void skin_changer::OnRoundReset(IGameEvent* pEvent) {
|
||||
if (!pEvent || g_vecAddedItemsIDs.empty()) return;
|
||||
|
||||
const char* eventName = pEvent->GetName();
|
||||
if (!eventName) return;
|
||||
|
||||
CCSPlayerController* pLocalPlayerController = CCSPlayerController::GetLocalPlayerController();
|
||||
|
||||
if (!pLocalPlayerController )
|
||||
return;
|
||||
|
||||
C_CSPlayerPawn* pLocalPawn = I::GameResourceService->pGameEntitySystem->Get<C_CSPlayerPawn>(pLocalPlayerController->GetPawnHandle());
|
||||
if (!pLocalPawn) return;
|
||||
|
||||
}
|
||||
|
||||
void skin_changer::OnPreFireEvent(IGameEvent* pEvent) {
|
||||
if (!pEvent) return;
|
||||
|
||||
const char* eventName = pEvent->GetName();
|
||||
if (!eventName) return;
|
||||
|
||||
const auto pControllerWhoKilled = pEvent->get_player_controller("attacker");
|
||||
if (pControllerWhoKilled == nullptr)
|
||||
return;
|
||||
|
||||
const auto pControllerWhoDied = pEvent->get_player_controller("userid");
|
||||
if (pControllerWhoDied == nullptr)
|
||||
return;
|
||||
|
||||
if (pControllerWhoKilled->GetIdentity()->GetIndex() == pControllerWhoDied->GetIdentity()->GetIndex())
|
||||
return;
|
||||
|
||||
CCSPlayerController* pLocalPlayerController = CCSPlayerController::GetLocalPlayerController();
|
||||
|
||||
if (!pLocalPlayerController || pControllerWhoKilled->GetIdentity()->GetIndex() != pLocalPlayerController->GetIdentity()->GetIndex())
|
||||
return;
|
||||
|
||||
C_CSPlayerPawn* pLocalPawn = I::GameResourceService->pGameEntitySystem->Get<C_CSPlayerPawn>(pLocalPlayerController->GetPawnHandle());
|
||||
if (!pLocalPawn) return;
|
||||
|
||||
CPlayer_WeaponServices* pWeaponServices = pLocalPawn->GetWeaponServices();
|
||||
if (!pWeaponServices) return;
|
||||
|
||||
C_CSWeaponBase* pActiveWeapon = pLocalPawn->ActiveWeapon();
|
||||
if (!pActiveWeapon) return;
|
||||
|
||||
CAttributeManager* pAttributeContainer = &pActiveWeapon->m_AttributeManager();
|
||||
if (!pAttributeContainer) return;
|
||||
|
||||
C_EconItemView* pWeaponItemView = &pAttributeContainer->m_Item();
|
||||
if (!pWeaponItemView) return;
|
||||
|
||||
CEconItemDefinition* pWeaponDefinition = pWeaponItemView->GetStaticData();
|
||||
if (!pWeaponDefinition || !pWeaponDefinition->IsKnife(true, pWeaponDefinition->m_pszItemTypeName)) return;
|
||||
const std::string_view token_name = CS_XOR("weapon");
|
||||
CUtlStringToken token(token_name.data());
|
||||
|
||||
pEvent->SetString(token, pWeaponDefinition->GetSimpleWeaponName());
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
#pragma once
|
||||
|
||||
class IGameEvent;
|
||||
class CEconItem;
|
||||
class C_BaseModelEntity;
|
||||
class CCSPlayerInventory;
|
||||
class C_CSPlayerPawn;
|
||||
class CEconItemDefinition;
|
||||
class C_BaseViewModel;
|
||||
class C_EconItemView;
|
||||
|
||||
namespace skin_changer {
|
||||
|
||||
enum material_magic_number : uint32_t
|
||||
{
|
||||
material_magic_number__gloves = 0xf143b82a,
|
||||
material_magic_number__unknown1 = 0x1b52829c,
|
||||
material_magic_number__unknown2 = 0xa6ebe9b9,
|
||||
material_magic_number__unknown3 = 0x423b2ed4,
|
||||
material_magic_number__unknown4 = 0xc8d7255e
|
||||
};
|
||||
|
||||
struct material_record
|
||||
{
|
||||
uint32_t ui32_unknwonstatic;
|
||||
material_magic_number identifer;
|
||||
uint32_t ui32_handle;
|
||||
uint32_t ui32_type_index;
|
||||
};
|
||||
|
||||
void OnFrameStageNotify(int frameStage);
|
||||
void OnGlove(CCSPlayerInventory* pInventory, C_CSPlayerPawn* pLocalPawn, C_BaseViewModel* pViewModel, C_EconItemView* GlovesItem, CEconItemDefinition* GlovesDefinition) ;
|
||||
void OnPreFireEvent(IGameEvent* pEvent);
|
||||
void OnRoundReset(IGameEvent* pEvent);
|
||||
|
||||
void OnEquipItemInLoadout(int team, int slot, uint64_t itemID);
|
||||
void OnSetModel(C_BaseModelEntity* pEntity, const char*& model);
|
||||
|
||||
void AddEconItemToList(CEconItem* pItem);
|
||||
void Shutdown();
|
||||
} // namespace skin_changer
|
||||
@@ -0,0 +1,31 @@
|
||||
#include "visuals.h"
|
||||
|
||||
// used: source sdk
|
||||
#include "../sdk/interfaces/iengineclient.h"
|
||||
#include "../sdk/entity.h"
|
||||
|
||||
// used: overlay
|
||||
#include "visuals/overlay.h"
|
||||
#include "visuals/chams.h"
|
||||
|
||||
#include "../core/sdk.h"
|
||||
|
||||
using namespace F;
|
||||
|
||||
bool F::VISUALS::Setup()
|
||||
{
|
||||
if (!ams::chams->initialize())
|
||||
{
|
||||
L_PRINT(LOG_ERROR) << CS_XOR("failed to initialize DrawObject chams | swapping to K3V");
|
||||
return true;
|
||||
}
|
||||
L_PRINT(LOG_NONE) << L::SetColor(LOG_COLOR_FORE_GREEN | LOG_COLOR_FORE_INTENSITY) << CS_XOR("chams initialization completed");
|
||||
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool F::VISUALS::OnDrawObject(void* pAnimatableSceneObjectDesc, void* pDx11, material_data_t* arrMeshDraw, int nDataCount, void* pSceneView, void* pSceneLayer, void* pUnk, void* pUnk2)
|
||||
{
|
||||
return ams::chams->draw_object(pAnimatableSceneObjectDesc, pDx11, arrMeshDraw, nDataCount, pSceneView, pSceneLayer, pUnk, pUnk2);
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
#pragma once
|
||||
|
||||
class material_data_t;
|
||||
|
||||
namespace F::VISUALS
|
||||
{
|
||||
bool Setup();
|
||||
void OnFrame(const int nStage);
|
||||
bool OnDrawObject(void* pAnimatableSceneObjectDesc, void* pDx11, material_data_t* arrMeshDraw, int nDataCount, void* pSceneView, void* pSceneLayer, void* pUnk, void* pUnk2);
|
||||
}
|
||||
@@ -0,0 +1,500 @@
|
||||
#include "chams.h"
|
||||
|
||||
// used: game's interfaces
|
||||
#include "../../core/interfaces.h"
|
||||
#include "../../sdk/interfaces/imaterialsystem.h"
|
||||
#include "../../sdk/interfaces/igameresourceservice.h"
|
||||
#include "../../sdk/interfaces/cgameentitysystem.h"
|
||||
#include "../../core/sdk.h"
|
||||
#include "../../sdk/entity.h"
|
||||
#include "../cstrike/sdk/datatypes/resourceutils.h"
|
||||
#include "../cstrike/sdk/datatypes/buf/utlbuffer.h"
|
||||
|
||||
#include <iostream>
|
||||
// used: original call in hooked function
|
||||
#include "../../core/hooks.h"
|
||||
|
||||
// used: cheat variables
|
||||
#include"../cstrike/sdk/interfaces/imaterialsystem.h"
|
||||
#include "../../core/variables.h"
|
||||
#include <stdexcept>
|
||||
inline bool(CS_FASTCALL* fnLoadBuffer)(CUtlBuffer*) = nullptr;
|
||||
|
||||
// custom material
|
||||
struct custom_material_data_t {
|
||||
material2_t* m_material;
|
||||
material2_t* m_material_z;
|
||||
};
|
||||
|
||||
// material list.
|
||||
enum material_list_t {
|
||||
material_white,
|
||||
material_default,
|
||||
material_illum,
|
||||
material_size
|
||||
};
|
||||
|
||||
// array
|
||||
static custom_material_data_t array_materials[material_size]; // material max
|
||||
|
||||
material2_t* create_material_glow2_visible(const char* m_name) {
|
||||
const char szVmatBuffer[] = R"#(<!-- kv3 encoding:text:version{e21c7f3c-8a33-41c5-9977-a76d3a32aa0d}
|
||||
format:generic:version{7412167c-06e9-4698-aff2-e63eb59037e7} -->
|
||||
{
|
||||
shader = "solidcolor.vfx"
|
||||
F_SELF_ILLUM = 1
|
||||
F_PAINT_VERTEX_COLORS = 1
|
||||
F_TRANSLUCENT = 1
|
||||
F_IGNOREZ = 0
|
||||
F_DISABLE_Z_WRITE = 0
|
||||
F_DISABLE_Z_BUFFERING = 0
|
||||
|
||||
g_tColor = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tNormal = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tRoughness = resource:"materials/default/default_normal_tga_b3f4ec4c.vtex"
|
||||
g_tMetalness = resource:"materials/default/default_normal_tga_b3f4ec4c.vtex"
|
||||
g_tSelfIllumMask = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
TextureAmbientOcclusion = resource:"materials/debug/particleerror.vtex"
|
||||
g_tAmbientOcclusion = resource:"materials/debug/particleerror.vtex"
|
||||
|
||||
g_vColorTint = [ 20.000000, 20.000000, 20.000000, 20.000000 ]
|
||||
g_flSelfIllumScale = [ 5.000000, 5.000000, 5.000000, 5.000000 ]
|
||||
g_flSelfIllumBrightness = [ 5.000000, 5.000000, 5.000000, 5.000000 ]
|
||||
g_vSelfIllumTint = [ 10.000000, 10.000000, 10.000000, 10.000000 ]
|
||||
} )#";
|
||||
|
||||
auto buffer = new unsigned char[0x100 + sizeof(CKeyValues3)];
|
||||
CRT::MemorySet(buffer, 0, sizeof(buffer));
|
||||
CKeyValues3* kv3 = (CKeyValues3*)(buffer + 0x100);
|
||||
|
||||
KV3IVD_t kv3ID;
|
||||
kv3ID.szName = m_name;
|
||||
kv3ID.unk0 = 0x469806E97412167C;
|
||||
kv3ID.unk1 = 0xE73790B53EE6F2AF;
|
||||
|
||||
if (!MEM::load_key_value(kv3, nullptr, szVmatBuffer, &kv3ID, nullptr))
|
||||
throw;
|
||||
|
||||
material2_t** custom_material;
|
||||
MEM::fnCreateMaterial(nullptr, &custom_material, m_name, kv3, 0, 1);
|
||||
|
||||
return *custom_material;
|
||||
}
|
||||
|
||||
material2_t* create_material_glow2_invisible(const char* m_name) {
|
||||
const char szVmatBuffer[] = R"#(<!-- kv3 encoding:text:version{e21c7f3c-8a33-41c5-9977-a76d3a32aa0d}
|
||||
format:generic:version{7412167c-06e9-4698-aff2-e63eb59037e7} -->
|
||||
{
|
||||
shader = "solidcolor.vfx"
|
||||
F_SELF_ILLUM = 1
|
||||
F_PAINT_VERTEX_COLORS = 1
|
||||
F_TRANSLUCENT = 1
|
||||
F_IGNOREZ = 1
|
||||
F_DISABLE_Z_WRITE = 1
|
||||
F_DISABLE_Z_BUFFERING = 1
|
||||
|
||||
g_tColor = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tNormal = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tRoughness = resource:"materials/default/default_normal_tga_b3f4ec4c.vtex"
|
||||
g_tMetalness = resource:"materials/default/default_normal_tga_b3f4ec4c.vtex"
|
||||
g_tSelfIllumMask = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
TextureAmbientOcclusion = resource:"materials/debug/particleerror.vtex"
|
||||
g_tAmbientOcclusion = resource:"materials/debug/particleerror.vtex"
|
||||
|
||||
g_vColorTint = [ 20.000000, 20.000000, 20.000000, 20.000000 ]
|
||||
g_flSelfIllumScale = [ 5.000000, 5.000000, 5.000000, 5.000000 ]
|
||||
g_flSelfIllumBrightness = [ 5.000000, 5.000000, 5.000000, 5.000000 ]
|
||||
g_vSelfIllumTint = [ 10.000000, 10.000000, 10.000000, 10.000000 ]
|
||||
} )#";
|
||||
|
||||
auto buffer = new unsigned char[0x100 + sizeof(CKeyValues3)];
|
||||
CRT::MemorySet(buffer, 0, sizeof(buffer));
|
||||
CKeyValues3* kv3 = (CKeyValues3*)(buffer + 0x100);
|
||||
|
||||
KV3IVD_t kv3ID;
|
||||
kv3ID.szName = m_name;
|
||||
kv3ID.unk0 = 0x469806E97412167C;
|
||||
kv3ID.unk1 = 0xE73790B53EE6F2AF;
|
||||
|
||||
if (!MEM::load_key_value(kv3, nullptr, szVmatBuffer, &kv3ID, nullptr))
|
||||
throw;
|
||||
|
||||
material2_t** custom_material;
|
||||
MEM::fnCreateMaterial(nullptr, &custom_material, m_name, kv3, 0, 1);
|
||||
|
||||
return *custom_material;
|
||||
}
|
||||
|
||||
material2_t* create_material_default_visible(const char* m_name) {
|
||||
const char szVmatBuffer[] = R"(<!-- kv3 encoding:text:version{e21c7f3c-8a33-41c5-9977-a76d3a32aa0d} format:generic:version{7412167c-06e9-4698-aff2-e63eb59037e7} -->
|
||||
{
|
||||
shader = "csgo_complex.vfx"
|
||||
F_PAINT_VERTEX_COLORS = 1
|
||||
F_TRANSLUCENT = 1
|
||||
|
||||
g_vColorTint = [1, 1, 1, 1]
|
||||
TextureAmbientOcclusion = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tAmbientOcclusion = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tColor = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tNormal = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tTintMask = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
|
||||
})";
|
||||
|
||||
auto buffer = new unsigned char[0x100 + sizeof(CKeyValues3)];
|
||||
CRT::MemorySet(buffer, 0, sizeof(buffer));
|
||||
CKeyValues3* kv3 = (CKeyValues3*)(buffer + 0x100);
|
||||
|
||||
KV3IVD_t kv3ID;
|
||||
kv3ID.szName = m_name;
|
||||
kv3ID.unk0 = 0x469806E97412167C;
|
||||
kv3ID.unk1 = 0xE73790B53EE6F2AF;
|
||||
|
||||
if (!MEM::load_key_value(kv3, nullptr, szVmatBuffer, &kv3ID, nullptr))
|
||||
throw;
|
||||
|
||||
material2_t** custom_material;
|
||||
MEM::fnCreateMaterial(nullptr, &custom_material, m_name, kv3, 0, 1);
|
||||
|
||||
return *custom_material;
|
||||
}
|
||||
material2_t* create_material_default_invisible(const char* m_name) {
|
||||
const char szVmatBuffer[] = R"(<!-- kv3 encoding:text:version{e21c7f3c-8a33-41c5-9977-a76d3a32aa0d} format:generic:version{7412167c-06e9-4698-aff2-e63eb59037e7} -->
|
||||
{
|
||||
shader = "csgo_complex.vfx"
|
||||
F_PAINT_VERTEX_COLORS = 1
|
||||
F_TRANSLUCENT = 1
|
||||
F_DISABLE_Z_BUFFERING = 1
|
||||
|
||||
g_vColorTint = [1, 1, 1, 1]
|
||||
TextureAmbientOcclusion = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tAmbientOcclusion = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tColor = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tNormal = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tTintMask = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
|
||||
})";
|
||||
|
||||
auto buffer = new unsigned char[0x100 + sizeof(CKeyValues3)];
|
||||
CRT::MemorySet(buffer, 0, sizeof(buffer));
|
||||
CKeyValues3* kv3 = (CKeyValues3*)(buffer + 0x100);
|
||||
|
||||
KV3IVD_t kv3ID;
|
||||
kv3ID.szName = m_name;
|
||||
kv3ID.unk0 = 0x469806E97412167C;
|
||||
kv3ID.unk1 = 0xE73790B53EE6F2AF;
|
||||
|
||||
if (!MEM::load_key_value(kv3, nullptr, szVmatBuffer, &kv3ID, nullptr))
|
||||
throw;
|
||||
|
||||
material2_t** custom_material;
|
||||
MEM::fnCreateMaterial(nullptr, &custom_material, m_name, kv3, 0, 1);
|
||||
|
||||
return *custom_material;
|
||||
}
|
||||
material2_t* create_material_flat_visible(const char* m_name) {
|
||||
const char szVmatBuffer[] = R"(<!-- kv3 encoding:text:version{e21c7f3c-8a33-41c5-9977-a76d3a32aa0d} format:generic:version{7412167c-06e9-4698-aff2-e63eb59037e7} -->
|
||||
{
|
||||
shader = "csgo_unlitgeneric.vfx"
|
||||
F_PAINT_VERTEX_COLORS = 1
|
||||
F_TRANSLUCENT = 1
|
||||
F_BLEND_MODE = 1
|
||||
|
||||
g_vColorTint = [1, 1, 1, 1]
|
||||
TextureAmbientOcclusion = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tAmbientOcclusion = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tColor = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tNormal = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tTintMask = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
|
||||
})";
|
||||
|
||||
auto buffer = new unsigned char[0x100 + sizeof(CKeyValues3)];
|
||||
CRT::MemorySet(buffer, 0, sizeof(buffer));
|
||||
CKeyValues3* kv3 = (CKeyValues3*)(buffer + 0x100);
|
||||
|
||||
KV3IVD_t kv3ID;
|
||||
kv3ID.szName = m_name;
|
||||
kv3ID.unk0 = 0x469806E97412167C;
|
||||
kv3ID.unk1 = 0xE73790B53EE6F2AF;
|
||||
|
||||
if (!MEM::load_key_value(kv3, nullptr, szVmatBuffer, &kv3ID, nullptr))
|
||||
throw;
|
||||
|
||||
material2_t** custom_material;
|
||||
MEM::fnCreateMaterial(nullptr, &custom_material, m_name, kv3, 0, 1);
|
||||
|
||||
return *custom_material;
|
||||
}
|
||||
material2_t* create_material_flat_invisible(const char* m_name) {
|
||||
const char szVmatBuffer[] = R"(<!-- kv3 encoding:text:version{e21c7f3c-8a33-41c5-9977-a76d3a32aa0d} format:generic:version{7412167c-06e9-4698-aff2-e63eb59037e7} -->
|
||||
{
|
||||
shader = "csgo_unlitgeneric.vfx"
|
||||
F_PAINT_VERTEX_COLORS = 1
|
||||
F_TRANSLUCENT = 1
|
||||
F_BLEND_MODE = 1
|
||||
F_DISABLE_Z_BUFFERING = 1
|
||||
|
||||
g_vColorTint = [1, 1, 1, 1]
|
||||
TextureAmbientOcclusion = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tAmbientOcclusion = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tColor = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tNormal = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tTintMask = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
|
||||
})";
|
||||
|
||||
auto buffer = new unsigned char[0x100 + sizeof(CKeyValues3)];
|
||||
CRT::MemorySet(buffer, 0, sizeof(buffer));
|
||||
CKeyValues3* kv3 = (CKeyValues3*)(buffer + 0x100);
|
||||
|
||||
KV3IVD_t kv3ID;
|
||||
kv3ID.szName = m_name;
|
||||
kv3ID.unk0 = 0x469806E97412167C;
|
||||
kv3ID.unk1 = 0xE73790B53EE6F2AF;
|
||||
|
||||
if (!MEM::load_key_value(kv3, nullptr, szVmatBuffer, &kv3ID, nullptr))
|
||||
throw;
|
||||
|
||||
material2_t** custom_material;
|
||||
MEM::fnCreateMaterial(nullptr, &custom_material, m_name, kv3, 0, 1);
|
||||
|
||||
return *custom_material;
|
||||
}
|
||||
material2_t* create_material_illum_visible(const char* m_name) {
|
||||
const char szVmatBuffer[] = R"(<!-- kv3 encoding:text:version{e21c7f3c-8a33-41c5-9977-a76d3a32aa0d} format:generic:version{7412167c-06e9-4698-aff2-e63eb59037e7} -->
|
||||
{
|
||||
shader = "csgo_complex.vfx"
|
||||
|
||||
g_tColor = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tNormal = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tSelfIllumMask = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
TextureAmbientOcclusion = resource:"materials/debug/particleerror.vtex"
|
||||
g_tAmbientOcclusion = resource:"materials/debug/particleerror.vtex"
|
||||
|
||||
g_vColorTint = [ 20.000000, 20.000000, 20.000000, 20.000000 ]
|
||||
g_flSelfIllumScale = [ 5.000000, 5.000000, 5.000000, 5.000000 ]
|
||||
g_flSelfIllumBrightness = [ 5.000000, 5.000000, 5.000000, 5.000000 ]
|
||||
g_vSelfIllumTint = [ 10.000000, 10.000000, 10.000000, 10.000000 ]
|
||||
|
||||
F_SELF_ILLUM = 1
|
||||
|
||||
F_PAINT_VERTEX_COLORS = 1
|
||||
|
||||
F_TRANSLUCENT = 1
|
||||
|
||||
})";
|
||||
|
||||
auto buffer = new unsigned char[0x100 + sizeof(CKeyValues3)];
|
||||
CRT::MemorySet(buffer, 0, sizeof(buffer));
|
||||
CKeyValues3* kv3 = (CKeyValues3*)(buffer + 0x100);
|
||||
|
||||
KV3IVD_t kv3ID;
|
||||
kv3ID.szName = m_name;
|
||||
kv3ID.unk0 = 0x469806E97412167C;
|
||||
kv3ID.unk1 = 0xE73790B53EE6F2AF;
|
||||
|
||||
if (!MEM::load_key_value(kv3, nullptr, szVmatBuffer, &kv3ID, nullptr))
|
||||
throw;
|
||||
|
||||
material2_t** custom_material;
|
||||
MEM::fnCreateMaterial(nullptr, &custom_material, m_name, kv3, 0, 1);
|
||||
|
||||
return *custom_material;
|
||||
}
|
||||
material2_t* create_material_illum_invisible(const char* m_name) {
|
||||
const char szVmatBuffer[] = R"(<!-- kv3 encoding:text:version{e21c7f3c-8a33-41c5-9977-a76d3a32aa0d} format:generic:version{7412167c-06e9-4698-aff2-e63eb59037e7} -->
|
||||
{
|
||||
shader = "csgo_complex.vfx"
|
||||
|
||||
g_tColor = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tNormal = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
g_tSelfIllumMask = resource:"materials/default/default_mask_tga_fde710a5.vtex"
|
||||
TextureAmbientOcclusion = resource:"materials/debug/particleerror.vtex"
|
||||
g_tAmbientOcclusion = resource:"materials/debug/particleerror.vtex"
|
||||
|
||||
g_vColorTint = [ 20.000000, 20.000000, 20.000000, 20.000000 ]
|
||||
g_flSelfIllumScale = [ 5.000000, 5.000000, 5.000000, 5.000000 ]
|
||||
g_flSelfIllumBrightness = [ 5.000000, 5.000000, 5.000000, 5.000000 ]
|
||||
g_vSelfIllumTint = [ 10.000000, 10.000000, 10.000000, 10.000000 ]
|
||||
|
||||
F_SELF_ILLUM = 1
|
||||
|
||||
F_PAINT_VERTEX_COLORS = 1
|
||||
|
||||
F_TRANSLUCENT = 1
|
||||
|
||||
F_DISABLE_Z_BUFFERING = 1
|
||||
|
||||
})";
|
||||
|
||||
auto buffer = new unsigned char[0x100 + sizeof(CKeyValues3)];
|
||||
CRT::MemorySet(buffer, 0, sizeof(buffer));
|
||||
CKeyValues3* kv3 = (CKeyValues3*)(buffer + 0x100);
|
||||
|
||||
KV3IVD_t kv3ID;
|
||||
kv3ID.szName = m_name;
|
||||
kv3ID.unk0 = 0x469806E97412167C;
|
||||
kv3ID.unk1 = 0xE73790B53EE6F2AF;
|
||||
|
||||
if (!MEM::load_key_value(kv3, nullptr, szVmatBuffer, &kv3ID, nullptr))
|
||||
throw;
|
||||
|
||||
material2_t** custom_material;
|
||||
MEM::fnCreateMaterial(nullptr, &custom_material, m_name, kv3, 0, 1);
|
||||
|
||||
return *custom_material;
|
||||
}
|
||||
// other functions.
|
||||
bool ams::chams_t::initialize() {
|
||||
// first we have to check if this shit is alr initialized
|
||||
if (this->m_initialized) {
|
||||
return this->m_initialized;
|
||||
}
|
||||
|
||||
// only initialize this for moment, later we're gonna init more
|
||||
array_materials[material_list_t::material_white] = custom_material_data_t{
|
||||
.m_material = CreateMaterial(CS_XOR("primary_white"), CS_XOR("materials/dev/primary_white.vmat"), CS_XOR("csgo_unlitgeneric.vfx"), true, true, false),
|
||||
.m_material_z = CreateMaterial(CS_XOR("primary_white_invisible"), CS_XOR("materials/dev/primary_white.vmat"), CS_XOR("csgo_unlitgeneric.vfx"), true, true, true)
|
||||
};
|
||||
|
||||
array_materials[material_list_t::material_default] = custom_material_data_t{
|
||||
.m_material = CreateMaterial(CS_XOR("primary_white"), CS_XOR("materials/dev/primary_white.vmat"), CS_XOR("csgo_unlitgeneric.vfx"), true, true, false),
|
||||
.m_material_z = CreateMaterial(CS_XOR("primary_white_invisible"), CS_XOR("materials/dev/primary_white.vmat"), CS_XOR("csgo_unlitgeneric.vfx"), true, true, true)
|
||||
};
|
||||
|
||||
array_materials[material_list_t::material_illum] = custom_material_data_t{
|
||||
.m_material = CreateMaterial(CS_XOR("primary_white"), CS_XOR("materials/dev/primary_white.vmat"), CS_XOR("csgo_unlitgeneric.vfx"), true, true, false),
|
||||
.m_material_z = CreateMaterial(CS_XOR("primary_white_invisible"), CS_XOR("materials/dev/primary_white.vmat"), CS_XOR("csgo_unlitgeneric.vfx"), true, true, true)
|
||||
};
|
||||
|
||||
// we initialized by now
|
||||
this->m_initialized = true;
|
||||
|
||||
// iterate.
|
||||
for (auto& [m_visible, m_invisible] : array_materials) {
|
||||
if (m_visible == nullptr || m_invisible == nullptr)
|
||||
this->m_initialized = false;
|
||||
}
|
||||
|
||||
// finish and return value
|
||||
return this->m_initialized;
|
||||
}
|
||||
|
||||
void ams::chams_t::destroy() {
|
||||
// nothing to destroy boss
|
||||
}
|
||||
|
||||
bool ams::chams_t::draw_object(void* animatable_object, void* dx11, material_data_t* arr_material_data, int data_count,
|
||||
void* scene_view, void* scene_layer, void* unk1, void* unk2) {
|
||||
// check if we initialized.
|
||||
if (!this->m_initialized) {
|
||||
return false;
|
||||
}
|
||||
if (!C_GET(bool, Vars.bVisualChams))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (!SDK::LocalPawn)
|
||||
return false;
|
||||
// no chams enable.
|
||||
// return false
|
||||
|
||||
// no data on material
|
||||
if (arr_material_data == nullptr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// no data on scene object.
|
||||
if (arr_material_data->m_scene_animable == nullptr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// owner.
|
||||
CBaseHandle m_owner = arr_material_data->m_scene_animable->m_owner;
|
||||
|
||||
// get entity.
|
||||
auto m_entity = I::GameResourceService->pGameEntitySystem ->Get< C_BaseEntity >(m_owner);
|
||||
if (m_entity == nullptr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// schema info
|
||||
SchemaClassInfoData_t* m_class_info;
|
||||
m_entity->GetSchemaClassInfo(&m_class_info);
|
||||
if (m_class_info == nullptr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// compare string.
|
||||
if (CRT::StringCompare(m_class_info->szName, CS_XOR("C_CSPlayerPawn")) != 0)
|
||||
return false;
|
||||
|
||||
// get pawn.
|
||||
auto m_pawn = I::GameResourceService->pGameEntitySystem->Get< C_CSPlayerPawn>(m_owner);
|
||||
if (m_pawn == nullptr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// other entity
|
||||
if (!m_pawn->IsOtherEnemy(SDK::LocalPawn)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// it is alive
|
||||
if (m_pawn->GetHealth() <= 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// we passed to everythign.
|
||||
// please render material.
|
||||
return this->override_material(animatable_object, dx11, arr_material_data, data_count,
|
||||
scene_view, scene_layer, unk1, unk2);
|
||||
}
|
||||
|
||||
material2_t* ams::chams_t::CreateMaterial(const char* szName, const char* szMaterialVMAT, const char* szShaderType, bool bBlendMode, bool bTranslucent, bool bDisableZBuffering)
|
||||
{
|
||||
material_data_t* pData = reinterpret_cast<material_data_t*>(static_cast<std::byte*>(MEM_STACKALLOC(0x200)) + 0x50);
|
||||
material2_t** pMatPrototype;
|
||||
|
||||
I::MaterialSystem2->find_or_create_from_resource(&pMatPrototype, szMaterialVMAT);
|
||||
if (pMatPrototype == nullptr)
|
||||
return nullptr;
|
||||
// @note: SetCreateDataByMaterial failed on release build idk why
|
||||
#ifdef _DEBUG
|
||||
I::MaterialSystem2->set_create_data_by_material(pData, &pMatPrototype);
|
||||
pData->set_shader_type(szShaderType);
|
||||
|
||||
pData->set_material_function(CS_XOR("F_DISABLE_Z_BUFFERING"), bDisableZBuffering ? 1 : 0);
|
||||
pData->set_material_function(CS_XOR("F_BLEND_MODE"), bBlendMode ? 1 : 0);
|
||||
pData->set_material_function(CS_XOR("F_TRANSLUCENT"), bTranslucent ? 1 : 0);
|
||||
|
||||
material2_t** pMaterial;
|
||||
I::MaterialSystem2->create_material(&pMaterial, szName, pData);
|
||||
return *pMaterial;
|
||||
#endif
|
||||
return *pMatPrototype;
|
||||
}
|
||||
|
||||
bool ams::chams_t::override_material(void* animatable_object, void* dx11, material_data_t* arr_material_data, int data_count,
|
||||
void* scene_view, void* scene_layer, void* unk1, void* unk2) {
|
||||
|
||||
const auto original = H::hkDrawObject.GetOriginal();
|
||||
const custom_material_data_t customMaterial = array_materials[C_GET(int, Vars.nVisualChamMaterial)];
|
||||
|
||||
if (C_GET(bool, Vars.bVisualChamsIgnoreZ))
|
||||
{
|
||||
arr_material_data->m_material = customMaterial.m_material_z;
|
||||
arr_material_data->m_color = C_GET(ColorPickerVar_t, Vars.colVisualChamsIgnoreZ).colValue;
|
||||
I::MaterialSystem2->set_color(arr_material_data, C_GET(ColorPickerVar_t, Vars.colVisualChamsIgnoreZ).colValue);
|
||||
|
||||
original(animatable_object, dx11, arr_material_data, data_count, scene_view, scene_layer, unk1, unk2);
|
||||
}
|
||||
|
||||
arr_material_data->m_material = customMaterial.m_material;
|
||||
arr_material_data->m_color = C_GET(ColorPickerVar_t, Vars.colVisualChams).colValue;
|
||||
I::MaterialSystem2->set_color(arr_material_data, C_GET(ColorPickerVar_t, Vars.colVisualChams).colValue);
|
||||
original(animatable_object, dx11, arr_material_data, data_count, scene_view, scene_layer, unk1, unk2);
|
||||
|
||||
return true;
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
#pragma once
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "../../common.h"
|
||||
#include <memory>
|
||||
#include "../cstrike/sdk/datatypes/stronghandle.hpp"
|
||||
#pragma once
|
||||
class material_data_t;
|
||||
class material2_t;
|
||||
namespace ams {
|
||||
class chams_t {
|
||||
public:
|
||||
bool initialize();
|
||||
void destroy();
|
||||
public:
|
||||
bool draw_object(void* animatable_object, void* dx11, material_data_t* arr_material_data, int data_count,
|
||||
void* scene_view, void* scene_layer, void* unk1, void* unk2);
|
||||
|
||||
bool override_material(void* animatable_object, void* dx11, material_data_t* arr_material_data, int data_count,
|
||||
void* scene_view, void* scene_layer, void* unk1, void* unk2);
|
||||
public:
|
||||
material2_t* CreateMaterial(const char* szName, const char* szMaterialVMAT, const char* szShaderType, bool bBlendMode, bool bTranslucent, bool bDisableZBuffering);
|
||||
|
||||
material2_t* create_material(const char* m_name, const char* material_vmat, const char* shader_type, bool blend_mode,
|
||||
bool transfluscent, bool disable_buffering);
|
||||
private:
|
||||
bool m_initialized = false;
|
||||
};
|
||||
const auto chams = std::make_unique<chams_t>();
|
||||
|
||||
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,183 @@
|
||||
#pragma once
|
||||
|
||||
#include "../../common.h"
|
||||
|
||||
// used: draw system
|
||||
#include "../../utilities/draw.h"
|
||||
#include "../../sdk/datatypes/vector.h"
|
||||
#include "../../sdk/datatypes/transform.h"
|
||||
|
||||
class CCSPlayerController;
|
||||
class C_BaseEntity;
|
||||
class C_CSPlayerPawn;
|
||||
class CBaseHandle;
|
||||
class CEntityInstance;
|
||||
|
||||
namespace F::VISUALS::OVERLAY
|
||||
{
|
||||
enum EAlignSide : std::uint8_t
|
||||
{
|
||||
SIDE_LEFT = 0U,
|
||||
SIDE_TOP,
|
||||
SIDE_RIGHT,
|
||||
SIDE_BOTTOM,
|
||||
SIDE_MAX
|
||||
};
|
||||
|
||||
enum EAlignDirection : std::uint8_t
|
||||
{
|
||||
DIR_LEFT = 0U,
|
||||
DIR_TOP,
|
||||
DIR_RIGHT,
|
||||
DIR_BOTTOM,
|
||||
DIR_MAX = 4U // @todo: rework stuff based on this cuz one component can have only 3 possible directions at same time. vertical side: left & right + top | bottom, horizontal side: top & bottom + left | right
|
||||
};
|
||||
|
||||
class CBaseComponent
|
||||
{
|
||||
public:
|
||||
[[nodiscard]] virtual ImVec2 GetBasePosition(const ImVec4& box) const;
|
||||
|
||||
[[nodiscard]] virtual bool IsDirectional() const
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
virtual void Render(ImDrawList* pDrawList, const ImVec2& vecPosition) = 0;
|
||||
|
||||
EAlignSide nSide = SIDE_TOP;
|
||||
ImVec2 vecOffset = {};
|
||||
ImVec2 vecSize = {};
|
||||
};
|
||||
|
||||
class CBaseDirectionalComponent : public CBaseComponent
|
||||
{
|
||||
public:
|
||||
[[nodiscard]] ImVec2 GetBasePosition(const ImVec4& box) const final;
|
||||
|
||||
[[nodiscard]] bool IsDirectional() const final
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
EAlignDirection nDirection = DIR_TOP;
|
||||
};
|
||||
|
||||
class CBarComponent : public CBaseComponent
|
||||
{
|
||||
public:
|
||||
CBarComponent(const bool bIsMenuItem, const EAlignSide nAlignSide, const ImVec4& vecBox, const float max_limit, const float flProgressFactor, const std::size_t uOverlayVarIndex, const float alphaMultiplier = 1.f);
|
||||
|
||||
void Render(ImDrawList* pDrawList, const ImVec2& vecPosition) final;
|
||||
|
||||
private:
|
||||
bool bIsMenuItem = false;
|
||||
float alphaMultiplier = 1.f;
|
||||
// bar progress
|
||||
float flProgressFactor = 0.0f;
|
||||
|
||||
//maxlimit
|
||||
float max_limit = 0.0f;
|
||||
|
||||
std::string value_sz;
|
||||
int value;
|
||||
// hovered state for context menu
|
||||
bool bIsHovered = false;
|
||||
// config variables
|
||||
std::size_t uOverlayVarIndex = 0ULL;
|
||||
};
|
||||
|
||||
class CTextComponent : public CBaseDirectionalComponent
|
||||
{
|
||||
public:
|
||||
CTextComponent(const bool bIsMenuItem, const bool bIcon, const EAlignSide nAlignSide, const EAlignDirection nAlignDirection, const ImFont* pFont, const char* szText, const std::size_t uOverlayVarIndex, const float alphaM = 1.f);
|
||||
~CTextComponent();
|
||||
|
||||
void Render(ImDrawList* pDrawList, const ImVec2& vecPosition) final;
|
||||
|
||||
private:
|
||||
float alphaMultiplier = 1.f;
|
||||
bool bIsMenuItem = false;
|
||||
bool bIcon = false;
|
||||
// font & text for displaying
|
||||
const ImFont* pFont = nullptr;
|
||||
char* szText = nullptr;
|
||||
// hovered state for context menu
|
||||
bool bIsHovered = false;
|
||||
// config variables
|
||||
std::size_t uOverlayVarIndex = 0ULL;
|
||||
};
|
||||
|
||||
/*
|
||||
* overlay component auto-positioning system
|
||||
* @note: was designed to support the reordering of components that can be implemented with minimal effort
|
||||
*
|
||||
* currently supported next sides and sub-directions:
|
||||
*
|
||||
* DIR_TOP
|
||||
* ^
|
||||
* |
|
||||
* DIR_LEFT <-o-> DIR_RIGHT
|
||||
* DIR_LEFT <-o *---------* o-> DIR_RIGHT
|
||||
* | | | |
|
||||
* v | | v
|
||||
* DIR_BOTTOM | | DIR_BOTTOM
|
||||
* | |
|
||||
* DIR_TOP | | DIR_TOP
|
||||
* ^ | | ^
|
||||
* | | | |
|
||||
* o *---------* o
|
||||
* DIR_LEFT <-o-> DIR_RIGHT
|
||||
* |
|
||||
* v
|
||||
* DIR_BOTTOM
|
||||
*/
|
||||
struct Context_t
|
||||
{
|
||||
/* @section: special case components */
|
||||
/// add the box component to overlay
|
||||
/// @remarks: current implementation expects this to be first component, it's an immediate rendering component
|
||||
/// @return: if the box component is hovered
|
||||
bool AddBoxComponent(ImDrawList* pDrawList, const ImVec4& vecBox, const int nType, float flThickness, float flRounding, const Color_t& colPrimary, const Color_t& colOutline , const float alpha = 1.f);
|
||||
/// add the frame component to overlay
|
||||
/// @remarks: current implementation expects this to be added after components that should be inside it, it's an immediate rendering component
|
||||
/// @returns: size constraints of the added frame
|
||||
ImVec4 AddFrameComponent(ImDrawList* pDrawList, const ImVec2& vecScreen, const EAlignSide nSide, const Color_t& colBackground, const float flRounding, const ImDrawFlags nRoundingCorners);
|
||||
|
||||
/* @section: common components */
|
||||
/// add new component to overlay
|
||||
/// @param[in] pComponent pointer to the one of supported component types
|
||||
void AddComponent(CBaseComponent* pComponent);
|
||||
|
||||
/* @section: get */
|
||||
/// @returns: size of the all directional components currently assigned to @a'nSide'
|
||||
[[nodiscard]] ImVec2 GetTotalDirectionalSize(const EAlignSide nSide) const;
|
||||
|
||||
// calculate final position of components and render them
|
||||
void Render(ImDrawList* pDrawList, const ImVec4& vecBox) const;
|
||||
|
||||
private:
|
||||
// storage of all components
|
||||
std::vector<CBaseComponent*> vecComponents = {};
|
||||
// additional spacing between components
|
||||
float flComponentSpacing = 1.0f;
|
||||
// summary padding of all align sides
|
||||
float arrSidePaddings[SIDE_MAX] = {};
|
||||
// summary padding for all align directions of all align sides
|
||||
float arrSideDirectionPaddings[SIDE_MAX][DIR_MAX] = {};
|
||||
};
|
||||
|
||||
/* @section: callbacks */
|
||||
void OnFrameStageNotify(CCSPlayerController* pLocalController);
|
||||
|
||||
/* @section: main */
|
||||
// draw box, bars, text infos, etc at player position
|
||||
|
||||
void Render();
|
||||
void CalculateBoundingBoxes();
|
||||
void CalculateSkeleton(Context_t ctx, CCSPlayerController* pPlayerController, C_CSPlayerPawn* pPlayer, const ImVec4& out);
|
||||
void OnPlayer(CCSPlayerController* pEntity, const ImVec4& out);
|
||||
bool IsValid(CCSPlayerController* pEntity);
|
||||
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user