hemp/CS2Cheat
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

good

Browse Source
This commit is contained in:
Oscar
2025-07-22 22:06:34 +03:00
parent d3c189f949
commit f892794557
780 changed files with 436498 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
TempleWare-CS2/source/templeware/features/aim/CUserCmd.h Normal file
View File

@@ -0,0 +1,29 @@
#pragma once
#include <cstdint>
#include <array>
#include "../../../templeware/utils/math/vector/vector.h"
struct CCmdQAngle {
QAngle_t angValue;
};
class CBaseUserCmdPB {
public:
char pad_0x00[0x40];
CCmdQAngle* pViewangles; // 0x40
// ... другие поля не нужны для silent aim
};
class CCSGOUserCmdPB {
public:
char pad_0x00[0x18];
CBaseUserCmdPB* pBase; // 0x18
// ... другие поля не нужны для silent aim
};
class CUserCmd {
public:
char pad_0x00[0x18];
CCSGOUserCmdPB pBase; // 0x18
// ... другие поля не нужны для silent aim
};

344
TempleWare-CS2/source/templeware/features/aim/aim.cpp
View File

@@ -4,13 +4,33 @@
#include "../../../templeware/hooks/hooks.h"
#include "../../../templeware/config/config.h"
#include "../../utils/memory/patternscan/patternscan.h"
#include "../visuals/visuals.h"
#include "CUserCmd.h"
#include "../../../templeware/utils/schema/schema.h"
#include <chrono>
#include <Windows.h>
#include "../../menu/hud.h"
#include "../../menu/menu.h"
#include <array>
#include <cmath>
#include <Psapi.h>
#include "../../menu/hud.h"
#include "../../menu/menu.h"
// Адреса из дампа (актуально для 2024-07-18)
#define DW_SENSITIVITY 0x1A6A9D8
#define DW_SENSITIVITY_SENS 0x40
float GetGameSensitivity() {
static float fallback = 2.0f;
HMODULE hClient = GetModuleHandleA("client.dll");
if (!hClient) return fallback;
uintptr_t sensBase = reinterpret_cast<uintptr_t>(hClient) + DW_SENSITIVITY;
uintptr_t sensPtr = *reinterpret_cast<uintptr_t*>(sensBase);
if (!sensPtr) return fallback;
float sens = *reinterpret_cast<float*>(sensPtr + DW_SENSITIVITY_SENS);
if (sens < 0.01f || sens > 20.0f) return fallback;
return sens;
}
// Индексы костей (актуально для CS2)
constexpr int BONE_INDEX_HEAD = 6; // Head
@@ -107,25 +127,30 @@ Vector_t GetEntityEyePos(const C_CSPlayerPawn* Entity) {
return Result;
}
// Удаляем все вспомогательные функции инкапсуляции
void Aimbot() {
static C_CSPlayerPawn* lockedTarget = nullptr;
static bool prevAimbotState = false;
static bool targetWasLost = false;
static QAngle_t last_punch_angle = {0,0,0};
static int shotCount = 0;
float sensitivity = GetGameSensitivity();
bool aimbotActive = Config::always_on_aimbot ? true : Config::aimbot;
// --- shooterAfterAim + triggerbot_key ---
if (Config::shooterAfterAim && (GetAsyncKeyState(Config::triggerbot_key) & 0x8000)) {
aimbotActive = true;
}
C_CSPlayerPawn* lp = H::oGetLocalPlayer(0);
if (cached_players.empty() || !lp || !lp->handle().valid() || lp->getHealth() <= 0)
return;
Vector_t lep = GetEntityEyePos(lp);
QAngle_t* viewangles = (QAngle_t*)(modules.getModule("client") + 0x1A78650);
bool isShooting = (GetAsyncKeyState(Config::triggerbot_key) & 0x8000) || (GetAsyncKeyState(VK_LBUTTON) & 0x8000);
int shotsFired = lp ? lp->getShotsFired() : 0;
shotCount = shotsFired;
g_DebugString = "debug: " + std::to_string(shotsFired);
//g_DebugString = "debug: " + std::to_string(shotsFired) + "Sens: " + std::to_string(sensitivity);
if (Config::aimbot_on_lmb && !Config::always_on_aimbot) {
aimbotActive = isShooting;
@@ -141,77 +166,54 @@ void Aimbot() {
// --- Новый режим: always_on_aimbot ---
if (Config::always_on_aimbot) {
int nMaxHighestEntity = I::GameEntity->Instance->GetHighestEntityIndex();
float bestFov = Config::aimbot_fov;
C_CSPlayerPawn* bestTarget = nullptr;
PlayerCache* bestTarget = nullptr;
QAngle_t bestAngle = { 0, 0, 0 };
for (int i = 1; i <= nMaxHighestEntity; i++) {
auto Entity = I::GameEntity->Instance->Get(i);
if (!Entity)
for (auto& Player : cached_players) {
if (!Player.handle.valid() || Player.health <= 0 || Player.handle.index() == INVALID_EHANDLE_INDEX)
continue;
if (!Entity->handle().valid())
if (Config::teamCheck && (Player.team_num == cached_local.team))
continue;
SchemaClassInfoData_t* _class = nullptr;
Entity->dump_class_info(&_class);
if (!_class)
continue;
const uint32_t hash = HASH(_class->szName);
if (hash == HASH("C_CSPlayerPawn")) {
C_CSPlayerPawn* pawn = (C_CSPlayerPawn*)Entity;
if (pawn->get_entity_by_handle() == lp->get_entity_by_handle())
continue;
if (pawn->getHealth() <= 0)
continue;
if (Config::team_check && pawn->getTeam() == lp->getTeam())
continue;
Vector_t target_pos = GetEntityEyePos(pawn);//GetAimbotTargetPos(pawn, lep);
QAngle_t angle = CalcAngles(target_pos, lep);
angle.x *= -1.f;
angle.y += 180.f;
const float fov = GetFov(*viewangles, angle);
if (!std::isfinite(fov) || fov > bestFov)
continue;
bestFov = fov;
bestTarget = pawn;
bestAngle = angle;
}
}
if (bestTarget) {
Vector_t target_pos = GetAimbotTargetPos(bestTarget, lep, *viewangles);
//Vector_t target_pos = GetEntityEyePos(bestTarget);
Vector_t target_pos = Player.position + Player.viewOffset;
QAngle_t angle = CalcAngles(target_pos, lep);
angle.x *= -1.f;
angle.y += 180.f;
QAngle_t ang_punch_angle = *(QAngle_t*)((uintptr_t)lp + SchemaFinder::Get(hash_32_fnv1a_const("C_CSPlayerPawn->m_aimPunchAngle")));
if (isShooting) {
last_punch_angle = ang_punch_angle;
const float fov = GetFov(*viewangles, angle);
if (!std::isfinite(fov) || fov > bestFov)
continue;
bestFov = fov;
bestTarget = &Player;
bestAngle = angle;
}
if (bestTarget) {
Vector_t target_pos = bestTarget->position + bestTarget->viewOffset;
QAngle_t angle = CalcAngles(target_pos, lep);
angle.x *= -1.f;
angle.y += 180.f;
QAngle_t cur_punch_angle = *(QAngle_t*)((uintptr_t)lp + SchemaFinder::Get(hash_32_fnv1a_const("C_CSPlayerPawn->m_aimPunchAngle")));
// --- RCS ---
bool rcsActive = false;
if (Config::shooterAfterAim && (GetAsyncKeyState(Config::triggerbot_key) & 0x8000)) {
rcsActive = (Config::rcs || Config::shooterAfterAim) && (shotCount > Config::rcsActivationShots);
} else {
rcsActive = (Config::rcs || Config::shooterAfterAim) && (shotCount > Config::rcsActivationShots);
}
if (rcsActive && shotsFired > 1) {
// Для прямого изменения viewangles: делить НЕ нужно
//QAngle_t punchDelta = cur_punch_angle - last_punch_angle;
//g_DebugString = "debug: " + std::to_string(punchDelta.x);
angle -= cur_punch_angle * 2.f;
last_punch_angle = cur_punch_angle;
} else {
last_punch_angle = {0,0,0};
}
// --- RCS ---
bool rcsActive = (Config::rcs || Config::shooterAfterAim) && (shotCount > 1);
if (rcsActive)
angle -= last_punch_angle * 2.f;
angle.z = 0.f;
angle = angle.Normalize();
// --- RCS ---
QAngle_t delta = (angle - *viewangles).Normalize();
if (rcsActive) {
float smooth_rcs = Config::aimbot_smooth;
if (Config::aimbot_dynamic_smooth) {
float fov = sqrtf(delta.x * delta.x + delta.y * delta.y);
float maxFov = Config::aimbot_fov;
float factor = (maxFov > 0.01f) ? (fov / maxFov) : 0.f;
smooth_rcs = Config::aimbot_smooth + (Config::aimbot_smooth * factor * Config::aimbot_dynamic_smooth_factor);
}
smooth_rcs = std::fmax(smooth_rcs / 10.f, 1.0f);
angle -= last_punch_angle * 2.f * smooth_rcs;
}
// --- Smooth ---
QAngle_t delta = (angle - *viewangles).Normalize();
if (Config::aimbot_smooth > 0.f) {
QAngle_t cur = *viewangles;
QAngle_t delta = (angle - cur).Normalize();
float smooth = Config::aimbot_smooth;
if (Config::aimbot_dynamic_smooth) {
float fov = sqrtf(delta.x * delta.x + delta.y * delta.y);
@@ -251,12 +253,10 @@ void Aimbot() {
const uint32_t hash = HASH(_class->szName);
if (hash == HASH("C_CSPlayerPawn")) {
C_CSPlayerPawn* pawn = (C_CSPlayerPawn*)Entity;
if (pawn->get_entity_by_handle() == lp->get_entity_by_handle())
continue;
if (pawn->getHealth() <= 0)
continue;
if (Config::team_check && pawn->getTeam() == lp->getTeam())
continue;
if (!pawn) continue;
if (pawn->get_entity_by_handle() == lp->get_entity_by_handle()) continue;
if (pawn->getHealth() <= 0) continue;
if (Config::team_check && pawn->getTeam() == lp->getTeam()) continue;
Vector_t target_pos = GetEntityEyePos(pawn);//GetAimbotTargetPos(pawn, lep);
QAngle_t angle = CalcAngles(target_pos, lep);
angle.x *= -1.f;
@@ -287,10 +287,19 @@ void Aimbot() {
// Если есть захваченная цель и кнопка удерживается
if (aimbotActive && lockedTarget) {
// Проверяем, что цель всё ещё валидна
if (!lockedTarget->handle().valid() || lockedTarget->getHealth() <= 0) {
if (!lp || !lp->handle().valid() || lp->getHealth() <= 0) {
lockedTarget = nullptr;
targetWasLost = false;
last_punch_angle = {0,0,0};
return;
}
if (
lockedTarget->get_entity_by_handle() == lp->get_entity_by_handle() ||
lockedTarget->getHealth() <= 0 ||
!lockedTarget->handle().valid()
) {
lockedTarget = nullptr;
targetWasLost = true;
// Не ищем новую цель до повторного нажатия!
last_punch_angle = {0,0,0}; // сброс rcs
}
else {
@@ -298,31 +307,25 @@ void Aimbot() {
QAngle_t angle = CalcAngles(target_pos, lep);
angle.x *= -1.f;
angle.y += 180.f;
QAngle_t ang_punch_angle = *(QAngle_t*)((uintptr_t)lp + SchemaFinder::Get(hash_32_fnv1a_const("C_CSPlayerPawn->m_aimPunchAngle")));
if (isShooting) {
last_punch_angle = ang_punch_angle;
QAngle_t cur_punch_angle = *(QAngle_t*)((uintptr_t)lp + SchemaFinder::Get(hash_32_fnv1a_const("C_CSPlayerPawn->m_aimPunchAngle")));
// --- RCS ---
bool rcsActive = false;
if (Config::shooterAfterAim && (GetAsyncKeyState(Config::triggerbot_key) & 0x8000)) {
rcsActive = (Config::rcs || Config::shooterAfterAim) && (shotCount > Config::rcsActivationShots);
} else {
rcsActive = (Config::rcs || Config::shooterAfterAim) && (shotCount > Config::rcsActivationShots);
}
if (rcsActive && shotCount > 1) {
// Для прямого изменения viewangles: делить НЕ нужно
//QAngle_t punchDelta = cur_punch_angle - last_punch_angle;
//g_DebugString = "debug: " + std::to_string(punchDelta.x);
angle -= cur_punch_angle * 2.f;
last_punch_angle = cur_punch_angle;
} else {
last_punch_angle = {0,0,0};
}
// --- RCS ---
bool rcsActive = (Config::rcs || Config::shooterAfterAim) && (shotCount > 1);
if (rcsActive)
angle -= last_punch_angle * 2.f;
angle.z = 0.f;
angle = angle.Normalize();
// --- RCS ---
QAngle_t delta = (angle - *viewangles).Normalize();
if (rcsActive) {
float smooth_rcs = Config::aimbot_smooth;
if (Config::aimbot_dynamic_smooth) {
float fov = sqrtf(delta.x * delta.x + delta.y * delta.y);
float maxFov = Config::aimbot_fov;
float factor = (maxFov > 0.01f) ? (fov / maxFov) : 0.f;
smooth_rcs = Config::aimbot_smooth + (Config::aimbot_smooth * factor * Config::aimbot_dynamic_smooth_factor);
}
smooth_rcs = std::fmax(smooth_rcs / 10.f, 1.0f);
angle -= last_punch_angle * 2.f * smooth_rcs;
}
// --- Smooth ---
if (Config::aimbot_smooth > 0.f) {
QAngle_t cur = *viewangles;
@@ -363,12 +366,10 @@ void Aimbot() {
const uint32_t hash = HASH(_class->szName);
if (hash == HASH("C_CSPlayerPawn")) {
C_CSPlayerPawn* pawn = (C_CSPlayerPawn*)Entity;
if (pawn->get_entity_by_handle() == lp->get_entity_by_handle())
continue;
if (pawn->getHealth() <= 0)
continue;
if (Config::team_check && pawn->getTeam() == lp->getTeam())
continue;
if (!pawn) continue;
if (pawn->get_entity_by_handle() == lp->get_entity_by_handle()) continue;
if (pawn->getHealth() <= 0) continue;
if (Config::team_check && pawn->getTeam() == lp->getTeam()) continue;
Vector_t target_pos = GetEntityEyePos(pawn);//GetAimbotTargetPos(pawn, lep);
QAngle_t angle = CalcAngles(target_pos, lep);
angle.x *= -1.f;
@@ -387,26 +388,139 @@ void Aimbot() {
}
prevAimbotState = aimbotActive;
//if (Config::shooterAfterAim) {
// if (g_ShowMenu) return;
// C_CSPlayerPawn* lp = H::oGetLocalPlayer(0);
// bool onEnemy = false;
// if (lp) {
// int crosshairIdx = *(int*)((uintptr_t)lp + 0x1458); // m_iIDEntIndex
// if (crosshairIdx > 0) {
// auto target = I::GameEntity->Instance->Get<C_CSPlayerPawn>(crosshairIdx);
// if (target && target->getHealth() > 0 && (!Config::team_check || target->getTeam() != lp->getTeam()))
// onEnemy = true;
// }
// }
// // Если врага нет под прицелом — всегда блокируем ЛКМ
// if (!onEnemy && (GetAsyncKeyState(VK_LBUTTON) & 0x8000)) {
// INPUT input = { 0 };
// input.type = INPUT_MOUSE;
// input.mi.dwFlags = MOUSEEVENTF_LEFTUP;
// SendInput(1, &input, sizeof(INPUT));
// }
// // return; // Не делаем return, чтобы аимбот работал всегда
//}
}
void SilentAimbot(CUserCmd* pCmd) {
if (!Config::silent_aim || !pCmd) return;
static C_CSPlayerPawn* lockedTarget = nullptr;
static bool prevSilentState = false;
static QAngle_t last_punch_angle = {0,0,0};
static int shotCount = 0;
C_CSPlayerPawn* lp = H::oGetLocalPlayer(0);
if (!lp || !lp->handle().valid() || lp->getHealth() <= 0) return;
Vector_t lep = GetEntityEyePos(lp);
QAngle_t* cur = (QAngle_t*)(modules.getModule("client") + 0x1A78650);
if (!cur) return;
bool silentActive = Config::always_on_silent_aim ? true : (GetAsyncKeyState(Config::silent_aim_key) & 0x8000);
// --- shooterAfterAim + triggerbot_key для сайлент аимбота ---
if (Config::silent_shooterAfterAim && (GetAsyncKeyState(Config::triggerbot_key) & 0x8000)) {
silentActive = true;
}
int shotsFired = lp ? lp->getShotsFired() : 0;
shotCount = shotsFired;
// Если кнопка только что нажата — ищем новую цель
if (silentActive && !prevSilentState) {
int nMaxHighestEntity = I::GameEntity->Instance->GetHighestEntityIndex();
float bestFov = Config::aimbot_fov;
C_CSPlayerPawn* bestTarget = nullptr;
QAngle_t bestAngle = { 0, 0, 0 };
for (int i = 1; i <= nMaxHighestEntity; i++) {
auto Entity = I::GameEntity->Instance->Get(i);
if (!Entity) continue;
if (!Entity->handle().valid()) continue;
SchemaClassInfoData_t* _class = nullptr;
Entity->dump_class_info(&_class);
if (!_class) continue;
const uint32_t hash = HASH(_class->szName);
if (hash == HASH("C_CSPlayerPawn")) {
C_CSPlayerPawn* pawn = (C_CSPlayerPawn*)Entity;
if (!pawn) continue;
if (pawn->get_entity_by_handle() == lp->get_entity_by_handle()) continue;
if (pawn->getHealth() <= 0) continue;
if (Config::team_check && pawn->getTeam() == lp->getTeam()) continue;
Vector_t target_pos = GetAimbotTargetPos(pawn, lep, *cur);
QAngle_t angle = CalcAngles(target_pos, lep);
angle.x *= -1.f;
angle.y += 180.f;
float fov = GetFov(*cur, angle);
if (!std::isfinite(fov) || fov > bestFov) continue;
bestFov = fov;
bestTarget = pawn;
bestAngle = angle;
}
}
lockedTarget = bestTarget;
last_punch_angle = {0,0,0};
}
// Если кнопка зажата, цели нет — постоянный поиск цели
if (silentActive && !lockedTarget) {
int nMaxHighestEntity = I::GameEntity->Instance->GetHighestEntityIndex();
float bestFov = Config::aimbot_fov;
C_CSPlayerPawn* bestTarget = nullptr;
QAngle_t bestAngle = { 0, 0, 0 };
for (int i = 1; i <= nMaxHighestEntity; i++) {
auto Entity = I::GameEntity->Instance->Get(i);
if (!Entity) continue;
if (!Entity->handle().valid()) continue;
SchemaClassInfoData_t* _class = nullptr;
Entity->dump_class_info(&_class);
if (!_class) continue;
const uint32_t hash = HASH(_class->szName);
if (hash == HASH("C_CSPlayerPawn")) {
C_CSPlayerPawn* pawn = (C_CSPlayerPawn*)Entity;
if (!pawn) continue;
if (pawn->get_entity_by_handle() == lp->get_entity_by_handle()) continue;
if (pawn->getHealth() <= 0) continue;
if (Config::team_check && pawn->getTeam() == lp->getTeam()) continue;
Vector_t target_pos = GetAimbotTargetPos(pawn, lep, *cur);
QAngle_t angle = CalcAngles(target_pos, lep);
angle.x *= -1.f;
angle.y += 180.f;
float fov = GetFov(*cur, angle);
if (!std::isfinite(fov) || fov > bestFov) continue;
bestFov = fov;
bestTarget = pawn;
bestAngle = angle;
}
}
lockedTarget = bestTarget;
last_punch_angle = {0,0,0};
}
// Если кнопка отпущена — сбрасываем захват
if (!silentActive) {
lockedTarget = nullptr;
last_punch_angle = {0,0,0};
}
// Если есть захваченная цель и кнопка удерживается
if (silentActive && lockedTarget) {
// Проверяем, что цель всё ещё валидна
if (!lp || !lp->handle().valid() || lp->getHealth() <= 0 ||
lockedTarget->get_entity_by_handle() == lp->get_entity_by_handle() ||
lockedTarget->getHealth() <= 0 ||
!lockedTarget->handle().valid() ||
(Config::team_check && lockedTarget->getTeam() == lp->getTeam())) {
lockedTarget = nullptr;
last_punch_angle = {0,0,0};
prevSilentState = silentActive;
return;
}
Vector_t target_pos = GetAimbotTargetPos(lockedTarget, lep, *cur);
QAngle_t angle = CalcAngles(target_pos, lep);
angle.x *= -1.f;
angle.y += 180.f;
//QAngle_t cur_punch_angle = *(QAngle_t*)((uintptr_t)lp + SchemaFinder::Get(hash_32_fnv1a_const("C_CSPlayerPawn->m_aimPunchAngle")));
//// --- RCS ---
//bool rcsActive = (Config::rcs || Config::silent_shooterAfterAim) && (shotCount > Config::rcsActivationShots);
//if (rcsActive && shotCount > 1) {
// angle -= cur_punch_angle * 2.f;
// last_punch_angle = cur_punch_angle;
//} else {
// last_punch_angle = {0,0,0};
//}
//angle.z = 0.f;
//angle = angle.Normalize();
// --- Smooth ---
if (Config::silent_aim_smooth > 0.f) {
QAngle_t delta = (angle - *cur).Normalize();
float smooth = Config::silent_aim_smooth;
angle = *cur + delta * (1.f / smooth);
angle = angle.Normalize();
}
*cur = angle;
}
prevSilentState = silentActive;
}

3
TempleWare-CS2/source/templeware/features/aim/aim.h
View File

@@ -1,3 +1,6 @@
#pragma once
#include "CUserCmd.h"
void Aimbot();
void SilentAimbot(CUserCmd* pCmd);

120
TempleWare-CS2/source/templeware/features/spectators/spectators.cpp Normal file
View File

@@ -0,0 +1,120 @@
#include "spectators.h"
#include "../../interfaces/interfaces.h"
#include "../../hooks/hooks.h"
#include "../../../../external/imgui/imgui.h"
#include "../../../cs2/entity/CCSPlayerController/CCSPlayerController.h"
#include "../visuals/visuals.h"
#include "../../menu/hud.h"
#include <vector>
#include <string>
#include "../../players/players.h"
#include "../../../cs2/entity/C_CSPlayerPawn/C_CSPlayerPawn.h"
namespace Spectators {
bool IsPlayerSpectatingYou(CCSPlayerController* controller, C_CSPlayerPawn* localPlayer) {
if (!controller || !localPlayer) return false;
if (controller->IsLocalPlayer()) return false;
uintptr_t pObserverServices = *reinterpret_cast<uintptr_t*>(
reinterpret_cast<uintptr_t>(controller) +
SchemaFinder::Get(hash_32_fnv1a_const("CCSPlayerController->m_pObserverServices"))
);
if (!pObserverServices) return false;
CBaseHandle hObserverTarget = *reinterpret_cast<CBaseHandle*>(
pObserverServices +
SchemaFinder::Get(hash_32_fnv1a_const("CPlayer_ObserverServices->m_hObserverTarget"))
);
if (!hObserverTarget.valid()) return false;
g_DebugString = "pObserverServices";
// Получаем указатель на pawn, за которым наблюдают
auto* observerPawn = reinterpret_cast<C_CSPlayerPawn*>(
I::GameEntity->Instance->Get(hObserverTarget.index())
);
if (!observerPawn) return false;
g_DebugString = "pObserverServices";
g_DebugString = observerPawn->handle().index() + " " + localPlayer->handle().index();
// Сравниваем указатели
return observerPawn->handle().index() == localPlayer->handle().index();
}
std::vector<SpectatorInfo> GetSpectators() {
std::vector<SpectatorInfo> spectators;
if (!H::oGetLocalPlayer || !I::GameEntity || !I::GameEntity->Instance) {
g_DebugString = "[Spectators] Не инициализированы (GetSpectators): "
+ std::string(!H::oGetLocalPlayer ? "oGetLocalPlayer " : "")
+ std::string(!I::GameEntity ? "GameEntity " : "")
+ std::string((I::GameEntity && !I::GameEntity->Instance) ? "GameEntity->Instance " : "");
return spectators;
}
C_CSPlayerPawn* localPlayer = H::oGetLocalPlayer(0);
if (!localPlayer) {
g_DebugString = "[Spectators] localPlayer nullptr (GetSpectators)";
return spectators;
}
int maxIdx = I::GameEntity->Instance->GetHighestEntityIndex();
for (int i = 1; i <= maxIdx; ++i) {
auto* entity = I::GameEntity->Instance->Get(i);
if (!entity) continue;
SchemaClassInfoData_t* classInfo = nullptr;
entity->dump_class_info(&classInfo);
if (!classInfo || strcmp(classInfo->szName, "CCSPlayerController") != 0)
continue;
auto* controller = reinterpret_cast<CCSPlayerController*>(entity);
if (!controller) continue;
if (!controller->m_hPawn().valid()) continue;
if (!IsPlayerSpectatingYou(controller, localPlayer))
continue;
const char* nameStr = controller->m_sSanitizedPlayerName();
std::string name = (nameStr && strlen(nameStr) > 0) ? nameStr : "Unknown";
spectators.emplace_back(name, false, 0, 0);
}
return spectators;
}
void RenderPlayersDebugList() {
ImGui::Begin("Players Debug List", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
if (!H::oGetLocalPlayer) {
ImGui::TextColored(ImVec4(1, 0, 0, 1), "[Spectators] oGetLocalPlayer не инициализирован");
ImGui::End();
return;
}
if (!I::GameEntity) {
ImGui::TextColored(ImVec4(1, 0, 0, 1), "[Spectators] GameEntity не инициализирован");
ImGui::End();
return;
}
if (!I::GameEntity->Instance) {
ImGui::TextColored(ImVec4(1, 0, 0, 1), "[Spectators] GameEntity->Instance не инициализирован");
ImGui::End();
return;
}
//if (!g_DebugString.empty()) {
// ImGui::TextColored(ImVec4(1, 0, 0, 1), "%s", g_DebugString.c_str());
// ImGui::End();
// return;
//}
ImGui::Text("Name | Team | Alive | Spectating You");
ImGui::Separator();
auto spectators = GetSpectators();
for (const auto& spectator : spectators) {
ImGui::Text("%-20s | %4d | %5s | %s",
spectator.name.c_str(),
spectator.team,
spectator.isAlive ? "yes" : "no",
"yes"); // Все из GetSpectators наблюдают за вами
}
ImGui::End();
}
} // namespace Spectators

23
TempleWare-CS2/source/templeware/features/spectators/spectators.h Normal file
View File

@@ -0,0 +1,23 @@
#pragma once
#include "../../../../external/imgui/imgui.h"
#include "../../../cs2/entity/C_CSPlayerPawn/C_CSPlayerPawn.h"
#include "../../../cs2/entity/C_BaseEntity/C_BaseEntity.h"
#include "../../config/config.h"
#include "../../../cs2/entity/CCSPlayerController/CCSPlayerController.h"
struct SpectatorInfo {
std::string name;
bool isLocalPlayer;
int team;
bool isAlive;
SpectatorInfo(const std::string& n, bool local, int t, bool alive)
: name(n), isLocalPlayer(local), team(t), isAlive(alive) {}
};
namespace Spectators {
void RenderSpectatorList();
std::vector<SpectatorInfo> GetSpectators();
bool IsPlayerSpectatingYou(CCSPlayerController* controller, C_CSPlayerPawn* localPlayer);
void RenderPlayersDebugList();
}

133
TempleWare-CS2/source/templeware/features/triggerbot/triggerbot.cpp
View File

@@ -32,67 +32,137 @@ void SimulateLMBUp() {
SendInput(1, &input, sizeof(INPUT));
}
// Управление удержанием ЛКМ
void SetLMBHeld(bool held) {
static bool lmbHeld = false;
if (held && !lmbHeld) {
SimulateLMBDown();
lmbHeld = true;
} else if (!held && lmbHeld) {
SimulateLMBUp();
lmbHeld = false;
}
}
static DWORD lastShotTime = 0;
void Triggerbot() {
static DWORD lastShotTime = 0;
static bool lmbHeld = false;
static bool firstShot = true;
// --- Альтернативная кнопка: триггербот по наведению на врага с задержкой ---
if (Config::triggerbot_alt_key && (GetAsyncKeyState(Config::triggerbot_alt_key) & 0x8000)) {
C_CSPlayerPawn* lp = H::oGetLocalPlayer(0);
if (!lp || lp->getHealth() <= 0) { SetLMBHeld(false); return; }
int crosshairIdx = *(int*)((uintptr_t)lp + 0x1458); // m_iIDEntIndex
if (crosshairIdx <= 0) { SetLMBHeld(false); return; }
auto target = I::GameEntity->Instance->Get<C_CSPlayerPawn>(crosshairIdx);
if (!target) { SetLMBHeld(false); return; }
if (target->getHealth() <= 0) { SetLMBHeld(false); return; }
if (Config::team_check && target->getTeam() == lp->getTeam()) { SetLMBHeld(false); return; }
DWORD64 now = GetTickCount64();
static DWORD64 lastAltShotTime = 0;
if (now - lastAltShotTime < static_cast<DWORD64>(Config::triggerbot_delay)) {
SetLMBHeld(false);
return;
}
SimulateLMBClick();
lastAltShotTime = now;
return;
}
if (!Config::triggerbot)
return;
if (!Config::always_on_triggerbot && Config::triggerbot_key && !(GetAsyncKeyState(Config::triggerbot_key) & 0x8000))
if (!Config::always_on_triggerbot && Config::triggerbot_key && !(GetAsyncKeyState(Config::triggerbot_key) & 0x8000)) {
SetLMBHeld(false);
firstShot = true;
return;
}
if (GetAsyncKeyState(VK_LBUTTON) & 0x8000) {
if (lmbHeld) {
SimulateLMBUp();
lmbHeld = false;
}
SetLMBHeld(false);
firstShot = true;
return;
}
C_CSPlayerPawn* lp = H::oGetLocalPlayer(0);
if (!lp || lp->getHealth() <= 0) { firstShot = true; return; }
if (!lp || lp->getHealth() <= 0) { firstShot = true; SetLMBHeld(false); return; }
int crosshairIdx = *(int*)((uintptr_t)lp + 0x1458); // m_iIDEntIndex
//g_DebugString = "debug: " + std::to_string(crosshairIdx);
if (crosshairIdx <= 0) {
if (lmbHeld) {
SimulateLMBUp();
lmbHeld = false;
int shotsFired = lp ? lp->getShotsFired() : 0;
DWORD64 now = GetTickCount64();
if (Config::shooterAfterAim) {
if (shotsFired > 0) {
// После первого выстрела просто удерживаем ЛКМ, игнорируя все условия
SetLMBHeld(true);
return;
} else {
// До первого выстрела — обычная логика триггербота
if (crosshairIdx <= 0) {
SetLMBHeld(false);
firstShot = true;
return;
}
auto target = I::GameEntity->Instance->Get<C_CSPlayerPawn>(crosshairIdx);
if (!target) {
SetLMBHeld(false);
firstShot = true;
return;
}
if (target->getHealth() <= 0) {
SetLMBHeld(false);
firstShot = true;
return;
}
if (Config::team_check && target->getTeam() == lp->getTeam()) {
SetLMBHeld(false);
firstShot = true;
return;
}
if (!Config::triggerbot_hold_lmb) {
if (now - lastShotTime < static_cast<DWORD64>(Config::triggerbot_delay)) {
SetLMBHeld(false);
firstShot = true;
return;
}
}
if (Config::triggerbot_hold_lmb) {
if (firstShot) {
SimulateLMBClick();
firstShot = false;
lastShotTime = now;
return;
} else {
SetLMBHeld(true);
}
lastShotTime = now;
return;
}
SimulateLMBClick();
lastShotTime = now;
firstShot = true;
return;
}
}
// --- Обычная логика триггербота, если shooterAfterAim выключен ---
if (crosshairIdx <= 0) {
SetLMBHeld(false);
firstShot = true;
return;
}
auto target = I::GameEntity->Instance->Get<C_CSPlayerPawn>(crosshairIdx);
if (!target) {
if (lmbHeld) {
SimulateLMBUp();
lmbHeld = false;
}
SetLMBHeld(false);
firstShot = true;
return;
}
if (target->getHealth() <= 0) {
if (lmbHeld) {
SimulateLMBUp();
lmbHeld = false;
}
SetLMBHeld(false);
firstShot = true;
return;
}
if (Config::team_check && target->getTeam() == lp->getTeam()) {
if (lmbHeld) {
SimulateLMBUp();
lmbHeld = false;
}
SetLMBHeld(false);
firstShot = true;
return;
}
DWORD64 now = GetTickCount64();
if (!Config::triggerbot_hold_lmb) {
if (now - lastShotTime < static_cast<DWORD64>(Config::triggerbot_delay)) {
if (lmbHeld) {
SimulateLMBUp();
lmbHeld = false;
}
SetLMBHeld(false);
firstShot = true;
return;
}
@@ -103,9 +173,8 @@ void Triggerbot() {
firstShot = false;
lastShotTime = now;
return;
} else if (!lmbHeld) {
SimulateLMBDown();
lmbHeld = true;
} else {
SetLMBHeld(true);
}
lastShotTime = now;
return;

12
TempleWare-CS2/source/templeware/features/visuals/visuals.cpp
View File

@@ -40,20 +40,16 @@ void Esp::cache()
if (!entityInfo) continue;
if (strcmp(entityInfo->szName, "C_CSPlayerPawn") == 0) {
bool exists = std::any_of(Players::pawns.begin(), Players::pawns.end(),
[&](const C_CSPlayerPawn& pawn) { return pawn.getAddress() == entityPointer; });
if (!exists) {
Players::pawns.emplace_back(entityPointer);
if (!Players::pawns.contains(entityPointer)) {
Players::pawns.insert(entityPointer);
std::cout << "Added pawn " << Players::pawns.size() << "\n";
}
continue;
}
if (strcmp(entityInfo->szName, "CCSPlayerController") == 0) {
bool exists = std::any_of(Players::controllers.begin(), Players::controllers.end(),
[&](const CCSPlayerController& controller) { return controller.getAddress() == entityPointer; });
if (!exists) {
Players::controllers.emplace_back(entityPointer);
if (!Players::controllers.contains(entityPointer)) {
Players::controllers.insert(entityPointer);
}
continue;
}