kal

TempleWare-CS2/TempleWare-CS2.vcxproj

@@ -171,6 +171,7 @@
     <ClCompile Include="source\cs2\entity\C_CSWeaponBase\C_CSWeaponBase.cpp" />
     <ClCompile Include="source\templeware\features\aim\aim.cpp" />
     <ClCompile Include="source\templeware\features\chams\chams.cpp" />
+    <ClCompile Include="source\templeware\features\spectators\spectators.cpp" />
     <ClCompile Include="source\templeware\features\triggerbot\triggerbot.cpp" />
     <ClCompile Include="source\templeware\features\visuals\antiflash\antiflash.cpp" />
     <ClCompile Include="source\templeware\features\visuals\fov\fov.cpp" />
@@ -228,6 +229,7 @@
     <ClInclude Include="source\cs2\entity\handle.h" />
     <ClInclude Include="source\templeware\features\aim\aim.h" />
     <ClInclude Include="source\templeware\features\chams\chams.h" />
+    <ClInclude Include="source\templeware\features\spectators\spectators.h" />
     <ClInclude Include="source\templeware\features\triggerbot\triggerbot.h" />
     <ClInclude Include="source\templeware\interfaces\CGameEntitySystem\CGameEntitySystem.h" />
     <ClInclude Include="source\templeware\interfaces\IEngineClient\IEngineClient.h" />

TempleWare-CS2/source/cs2/datatypes/keyvalues/keyvalues.cpp

@@ -34,7 +34,6 @@ CKeyValues3* CKeyValues3::create_material_from_resource()
 	using fnSetTypeKV3 = CKeyValues3 * (__fastcall*)(CKeyValues3*, unsigned int, unsigned int);
 	static const fnSetTypeKV3 oSetTypeKV3 = reinterpret_cast<fnSetTypeKV3>(M::FindPattern("tier0.dll", ("40 53 48 83 EC 30 48 8B D9 49")));
 
-
+	CKeyValues3* pKeyValue = new CKeyValues3;
-	CKeyValues3* pKeyValue = new CKeyValues3[0x10];
 	return oSetTypeKV3(pKeyValue, 1U, 6U);
 }

TempleWare-CS2/source/cs2/entity/CCSPlayerController/CCSPlayerController.h

@@ -1,6 +1,6 @@
 #pragma once
 #include <cstdint>
-#pragma once
+#include "../handle.h"
 #include "../../../templeware/utils/memory/memorycommon.h"
 #include "../../../templeware/utils/math/vector/vector.h"
 #include "../../../templeware/utils/schema/schema.h"
@@ -14,6 +14,7 @@ public:
 
 	SCHEMA_ADD_OFFSET(bool, IsLocalPlayer, 0x6F0);
 	SCHEMA_ADD_OFFSET(CBaseHandle, m_hPawn, 0x62C);
+	SCHEMA_ADD_OFFSET(CBaseHandle, m_hObserverPawn, 0x48);
 	SCHEMA_ADD_OFFSET(const char*, m_sSanitizedPlayerName, 0x778);
 
 private:

TempleWare-CS2/source/cs2/entity/C_CSPlayerPawn/C_CSPlayerPawn.h

@@ -12,6 +12,7 @@ public:
 	SCHEMA_ADD_OFFSET(Vector_t, m_vOldOrigin, 0x1324);
 	SCHEMA_ADD_OFFSET(Vector_t, m_vecViewOffset, 0xCB0);
 	SCHEMA_ADD_OFFSET(CCSPlayer_WeaponServices*, m_pWeaponServices, 0x11A8);
+	SCHEMA_ADD_OFFSET(CBaseHandle, m_hController, 0x133C);
 	C_CSPlayerPawn(uintptr_t address);
 
 	C_CSWeaponBase* GetActiveWeapon()const;

TempleWare-CS2/source/includes.h

@@ -6,6 +6,7 @@
 #include "../external/imgui/imgui.h"
 #include "../external/imgui/imgui_impl_win32.h"
 #include "../external/imgui/imgui_impl_dx11.h"
+#include "cs2/entity/handle.h"
 
 typedef HRESULT(__stdcall* Present) (IDXGISwapChain* pSwapChain, UINT SyncInterval, UINT Flags);
 typedef LRESULT(CALLBACK* WNDPROC)(HWND, UINT, WPARAM, LPARAM);

TempleWare-CS2/source/templeware/config/config.cpp

@@ -63,5 +63,23 @@ namespace Config {
 	bool triggerbot = false;
 	bool always_on_triggerbot = false;
 	int triggerbot_key = 0x05; // Например, VK_X или другой
+	int triggerbot_alt_key = 0x06; // Альтернативная кнопка по умолчанию (например, VK_Y)
 	float triggerbot_delay = 0.0f;
+	int rcsActivationShots = 1;
+
+	// --- Для отображения наблюдателей ---
+	bool showSpectators = true;
+	ImVec4 spectatorListColor = ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
+	ImVec4 spectatorListBgColor = ImVec4(0.0f, 0.0f, 0.0f, 0.7f);
+	float spectatorListOpacity = 0.8f;
+
+	bool silent_aim = true;
+	float silent_aim_fov = 90.0f;
+	float silent_aim_smooth = 0.0f;
+	int silent_aim_bone = Config::BONE_HEAD;
+	int silent_aim_key = 0x12; // VK_DELETE по умолчанию
+	bool always_on_silent_aim = false;
+	float silent_aim_smooth_slider = 0.0f; // Новый параметр для ползунка смуза
+	bool silent_shooterAfterAim = false; // Аналог shooterAfterAim для сайлент аимбота
+	bool silent_rage = false; // По умолчанию выключен
 }

TempleWare-CS2/source/templeware/config/config.h

@@ -70,5 +70,23 @@ namespace Config {
 	extern bool triggerbot;
 	extern bool always_on_triggerbot;
 	extern int triggerbot_key;
+	extern int triggerbot_alt_key; // Альтернативная кнопка для триггербота
 	extern float triggerbot_delay;
+	extern int rcsActivationShots;
+
+	// --- Для отображения наблюдателей ---
+	extern bool showSpectators;
+	extern ImVec4 spectatorListColor;
+	extern ImVec4 spectatorListBgColor;
+	extern float spectatorListOpacity;
+
+	extern bool silent_aim;
+	extern float silent_aim_fov;
+	extern float silent_aim_smooth;
+	extern int silent_aim_bone;
+	extern int silent_aim_key;
+	extern bool always_on_silent_aim;
+	extern float silent_aim_smooth_slider; // Новый параметр для ползунка смуза
+	extern bool silent_shooterAfterAim; // Аналог shooterAfterAim для сайлент аимбота
+	extern bool silent_rage; // Включает постоянный поиск цели (rage-режим)
 }

TempleWare-CS2/source/templeware/config/configmanager.h

@@ -130,10 +130,13 @@ namespace internal_config
             j["showNameTags"] = Config::showNameTags;
             j["triggerbot_hold_lmb"] = Config::triggerbot_hold_lmb;
             j["shooterAfterAim"] = Config::shooterAfterAim;
+            j["silent_shooterAfterAim"] = Config::silent_shooterAfterAim;
             j["always_on_triggerbot"] = Config::always_on_triggerbot;
             j["triggerbot"] = Config::triggerbot;
             j["triggerbot_key"] = Config::triggerbot_key;
+            j["triggerbot_alt_key"] = Config::triggerbot_alt_key;
             j["triggerbot_delay"] = Config::triggerbot_delay;
+            j["silent_rage"] = Config::silent_rage;
 
             j["enemyChamsInvisible"] = Config::enemyChamsInvisible;
             j["enemyChams"] = Config::enemyChams;
@@ -170,6 +173,7 @@ namespace internal_config
                 Config::fovCircleColor.z,
                 Config::fovCircleColor.w
             };
+            j["rcsActivationShots"] = Config::rcsActivationShots;
 
             auto filePath = GetConfigPath(configName);
             std::ofstream ofs(filePath);
@@ -243,10 +247,13 @@ namespace internal_config
             Config::showNameTags = j.value("showNameTags", false);
             Config::triggerbot_hold_lmb = j.value("triggerbot_hold_lmb", false);
             Config::shooterAfterAim = j.value("shooterAfterAim", false);
+            Config::silent_shooterAfterAim = j.value("silent_shooterAfterAim", false);
             Config::always_on_triggerbot = j.value("always_on_triggerbot", false);
             Config::triggerbot = j.value("triggerbot", false);
             Config::triggerbot_key = j.value("triggerbot_key", 0x05);
+            Config::triggerbot_alt_key = j.value("triggerbot_alt_key", 0x06);
             Config::triggerbot_delay = j.value("triggerbot_delay", 0.0f);
+            Config::silent_rage = j.value("silent_rage", false);
 
             Config::antiflash = j.value("antiflash", false);
 
@@ -315,6 +322,8 @@ namespace internal_config
                 Config::fovCircleColor.w = arr[3].get<float>();
             }
 
+            Config::rcsActivationShots = j.value("rcsActivationShots", 1);
+
             ifs.close();
         }
 

TempleWare-CS2/source/templeware/features/aim/CUserCmd.h

@@ -0,0 +1,139 @@
+#pragma once
+#include <cstdint>
+#include "../../../templeware/utils/math/vector/vector.h"
+
+#define MEM_PAD(size) char _pad##__LINE__[size]
+
+template <typename T>
+struct RepeatedPtrField_t {
+    struct Rep_t {
+        int nAllocatedSize;
+        T* tElements[(std::numeric_limits<int>::max() - 2 * sizeof(int)) / sizeof(void*)];
+    };
+    void* pArena;
+    int nCurrentSize;
+    int nTotalSize;
+    Rep_t* pRep;
+};
+
+class CBasePB {
+public:
+    MEM_PAD(0x8); // 0x0 VTABLE
+    std::uint32_t nHasBits; // 0x8
+    std::uint64_t nCachedBits; // 0xC
+    void SetBits(std::uint64_t nBits) { nCachedBits |= nBits; }
+};
+static_assert(sizeof(CBasePB) == 0x18);
+
+class CMsgQAngle : public CBasePB {
+public:
+    QAngle_t angValue; // 0x18
+};
+static_assert(sizeof(CMsgQAngle) == 0x28);
+
+class CMsgVector : public CBasePB {
+public:
+    Vector_t vecValue; // 0x18
+};
+static_assert(sizeof(CMsgVector) == 0x28);
+
+class CCSGOInterpolationInfoPB : public CBasePB {
+public:
+    float flFraction; // 0x18
+    int nSrcTick; // 0x1C
+    int nDstTick; // 0x20
+};
+static_assert(sizeof(CCSGOInterpolationInfoPB) == 0x28);
+
+class CCSGOInputHistoryEntryPB : public CBasePB {
+public:
+    CMsgQAngle* pViewAngles; // 0x18
+    CMsgVector* pShootPosition; // 0x20
+    CMsgVector* pTargetHeadPositionCheck; // 0x28
+    CMsgVector* pTargetAbsPositionCheck; // 0x30
+    CMsgQAngle* pTargetAngPositionCheck; // 0x38
+    CCSGOInterpolationInfoPB* cl_interp; // 0x40
+    CCSGOInterpolationInfoPB* sv_interp0; // 0x48
+    CCSGOInterpolationInfoPB* sv_interp1; // 0x50
+    CCSGOInterpolationInfoPB* player_interp; // 0x58
+    int nRenderTickCount; // 0x60
+    float flRenderTickFraction; // 0x64
+    int nPlayerTickCount; // 0x68
+    float flPlayerTickFraction; // 0x6C
+    int nFrameNumber; // 0x70
+    int nTargetEntIndex; // 0x74
+};
+static_assert(sizeof(CCSGOInputHistoryEntryPB) == 0x78);
+
+struct CInButtonState {
+    MEM_PAD(0x8); // 0x0 VTABLE
+    std::uint64_t nValue; // 0x8
+    std::uint64_t nValueChanged; // 0x10
+    std::uint64_t nValueScroll; // 0x18
+};
+static_assert(sizeof(CInButtonState) == 0x20);
+
+class CBaseUserCmdPB : public CBasePB {
+public:
+    RepeatedPtrField_t<void*> subtickMovesField;
+    std::string* strMoveCrc;
+    CInButtonState* pInButtonState; // 0x20
+    CMsgQAngle* pViewAngles; // 0x28
+    std::int32_t nLegacyCommandNumber;
+    std::int32_t nClientTick;
+    float flForwardMove;
+    float flSideMove;
+    float flUpMove;
+    std::int32_t nImpulse;
+    std::int32_t nWeaponSelect;
+    std::int32_t nRandomSeed;
+    std::int32_t nMousedX;
+    std::int32_t nMousedY;
+    std::uint32_t nConsumedServerAngleChanges;
+    std::int32_t nCmdFlags;
+    std::uint32_t nPawnEntityHandle;
+};
+static_assert(sizeof(CBaseUserCmdPB) == 0x80);
+
+class CCSGOUserCmdPB {
+public:
+    std::uint32_t nHasBits;
+    std::uint64_t nCachedSize;
+    RepeatedPtrField_t<CCSGOInputHistoryEntryPB> inputHistoryField;
+    CBaseUserCmdPB* pBaseCmd;
+    bool bLeftHandDesired;
+    std::int32_t nAttack3StartHistoryIndex;
+    std::int32_t nAttack1StartHistoryIndex;
+    std::int32_t nAttack2StartHistoryIndex;
+    void CheckAndSetBits(std::uint32_t nBits) {
+        if (!(nHasBits & nBits))
+            nHasBits |= nBits;
+    }
+};
+static_assert(sizeof(CCSGOUserCmdPB) == 0x40);
+
+class CUserCmd {
+public:
+    MEM_PAD(0x8); // 0x0 VTABLE
+    MEM_PAD(0x10); // 0x8
+    CCSGOUserCmdPB csgoUserCmd; // 0x18
+    CInButtonState nButtons; // 0x58
+    MEM_PAD(0x20); // 0x78
+
+    CCSGOInputHistoryEntryPB* GetInputHistoryEntry(int nIndex) {
+        if (nIndex >= csgoUserCmd.inputHistoryField.pRep->nAllocatedSize || nIndex >= csgoUserCmd.inputHistoryField.nCurrentSize)
+            return nullptr;
+        return csgoUserCmd.inputHistoryField.pRep->tElements[nIndex];
+    }
+
+    void SetSubTickAngle(const QAngle_t& angView) {
+        for (int i = 0; i < this->csgoUserCmd.inputHistoryField.pRep->nAllocatedSize; i++) {
+            CCSGOInputHistoryEntryPB* pInputEntry = this->GetInputHistoryEntry(i);
+            if (!pInputEntry || !pInputEntry->pViewAngles)
+                continue;
+            pInputEntry->pViewAngles->angValue = angView;
+            pInputEntry->SetBits(0x1U); // INPUT_HISTORY_BITS_VIEWANGLES
+        }
+    }
+};
+static_assert(sizeof(CUserCmd) == 0x98); 

TempleWare-CS2/source/templeware/features/aim/aim.cpp

@@ -4,13 +4,34 @@
 #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"
+#include <iostream>
+
+// Адреса из дампа (актуально для 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
@@ -22,21 +43,21 @@ static int lastBoneIdx = -1;
 
 inline QAngle_t CalcAngles(Vector_t viewPos, Vector_t aimPos)
 {
-    QAngle_t angle = { 0, 0, 0 };
+	QAngle_t angle = { 0, 0, 0 };
 
-    Vector_t delta = aimPos - viewPos;
+	Vector_t delta = aimPos - viewPos;
 
-    angle.x = -asin(delta.z / delta.Length()) * (180.0f / 3.141592654f);
+	angle.x = -asin(delta.z / delta.Length()) * (180.0f / 3.141592654f);
-    angle.y = atan2(delta.y, delta.x) * (180.0f / 3.141592654f);
+	angle.y = atan2(delta.y, delta.x) * (180.0f / 3.141592654f);
 
-    return angle;
+	return angle;
 }
 
 inline float GetFov(const QAngle_t& viewAngle, const QAngle_t& aimAngle)
 {
-    QAngle_t delta = (aimAngle - viewAngle).Normalize();
+	QAngle_t delta = (aimAngle - viewAngle).Normalize();
 
-    return sqrtf(powf(delta.x, 2.0f) + powf(delta.y, 2.0f));
+	return sqrtf(powf(delta.x, 2.0f) + powf(delta.y, 2.0f));
 }
 
 // // Сигнатура функции GetBonePosition (актуально для client.dll):
@@ -52,42 +73,42 @@ inline float GetFov(const QAngle_t& viewAngle, const QAngle_t& aimAngle)
 // }
 
 Vector_t GetBonePosition(const C_CSPlayerPawn* Entity, int boneIdx) {
-    if (!Entity) return {};
+	if (!Entity) return {};
-    // Внешний способ: читаем Vector3 по адресу boneMatrix + boneIdx * 0x20
+	// Внешний способ: читаем Vector3 по адресу boneMatrix + boneIdx * 0x20
-    uintptr_t pGameSceneNode = *reinterpret_cast<uintptr_t*>((uintptr_t)Entity + 0x328);
+	uintptr_t pGameSceneNode = *reinterpret_cast<uintptr_t*>((uintptr_t)Entity + 0x328);
-    if (!pGameSceneNode) return {};
+	if (!pGameSceneNode) return {};
-    uintptr_t pBoneMatrix = *reinterpret_cast<uintptr_t*>(pGameSceneNode + 0x1F0);
+	uintptr_t pBoneMatrix = *reinterpret_cast<uintptr_t*>(pGameSceneNode + 0x1F0);
-    if (!pBoneMatrix) return {};
+	if (!pBoneMatrix) return {};
-    return *reinterpret_cast<Vector_t*>(pBoneMatrix + boneIdx * 0x20);
+	return *reinterpret_cast<Vector_t*>(pBoneMatrix + boneIdx * 0x20);
 }
 
 // Получить позицию для аимбота в зависимости от выбора пользователя
 Vector_t GetAimbotTargetPos(const C_CSPlayerPawn* Entity, const Vector_t& from, const QAngle_t& viewAngles) {
-    switch (Config::aimbot_bone) {
+	switch (Config::aimbot_bone) {
-        case Config::BONE_HEAD:
+	case Config::BONE_HEAD:
-            return GetBonePosition(Entity, BONE_INDEX_HEAD);
+		return GetBonePosition(Entity, BONE_INDEX_HEAD);
-        case Config::BONE_NECK:
+	case Config::BONE_NECK:
-            return GetBonePosition(Entity, BONE_INDEX_NECK);
+		return GetBonePosition(Entity, BONE_INDEX_NECK);
-        case Config::BONE_BODY:
+	case Config::BONE_BODY:
-            return GetBonePosition(Entity, BONE_INDEX_BODY);
+		return GetBonePosition(Entity, BONE_INDEX_BODY);
-        case Config::BONE_NEAREST:
+	case Config::BONE_NEAREST:
-        default: {
+	default: {
-            // Каждый раз ищем ближайшую кость по FOV
+		// Каждый раз ищем ближайшую кость по FOV
-            std::array<int, 2> bones = {BONE_INDEX_HEAD, BONE_INDEX_BODY};
+		std::array<int, 2> bones = { BONE_INDEX_HEAD, BONE_INDEX_BODY };
-            float bestFov = FLT_MAX;
+		float bestFov = FLT_MAX;
-            int bestIdx = BONE_INDEX_HEAD;
+		int bestIdx = BONE_INDEX_HEAD;
-            for (int idx : bones) {
+		for (int idx : bones) {
-                Vector_t pos = GetBonePosition(Entity, idx);
+			Vector_t pos = GetBonePosition(Entity, idx);
-                QAngle_t ang = CalcAngles(from, pos); // <-- Исправлено!
+			QAngle_t ang = CalcAngles(from, pos); // <-- Исправлено!
-                float fov = GetFov(viewAngles, ang);
+			float fov = GetFov(viewAngles, ang);
-                if (fov < bestFov && std::isfinite(fov)) {
+			if (fov < bestFov && std::isfinite(fov)) {
-                    bestFov = fov;
+				bestFov = fov;
-                    bestIdx = idx;
+				bestIdx = idx;
-                }
+			}
-            }
+		}
-            return GetBonePosition(Entity, bestIdx);
+		return GetBonePosition(Entity, bestIdx);
-        }
+	}
-    }
+	}
 }
 
 
@@ -107,306 +128,480 @@ Vector_t GetEntityEyePos(const C_CSPlayerPawn* Entity) {
 	return Result;
 }
 
+// Удаляем все вспомогательные функции инкапсуляции
+
 void Aimbot() {
-    static C_CSPlayerPawn* lockedTarget = nullptr;
+	static C_CSPlayerPawn* lockedTarget = nullptr;
-    static bool prevAimbotState = false;
+	static bool prevAimbotState = false;
-    static bool targetWasLost = false;
+	static bool targetWasLost = false;
-    static QAngle_t last_punch_angle = {0,0,0};
+	static QAngle_t last_punch_angle = { 0,0,0 };
-    static int shotCount = 0;
+	static int shotCount = 0;
-    bool aimbotActive = Config::always_on_aimbot ? true : Config::aimbot;
+	float sensitivity = GetGameSensitivity();
-    // --- shooterAfterAim + triggerbot_key ---
+	bool aimbotActive = Config::always_on_aimbot ? true : Config::aimbot;
-    if (Config::shooterAfterAim && (GetAsyncKeyState(Config::triggerbot_key) & 0x8000)) {
+	// --- shooterAfterAim + triggerbot_key ---
-        aimbotActive = true;
+	if (Config::shooterAfterAim && (GetAsyncKeyState(Config::triggerbot_key) & 0x8000)) {
-    }
+		aimbotActive = true;
-    C_CSPlayerPawn* lp = H::oGetLocalPlayer(0);
+	}
-    Vector_t lep = GetEntityEyePos(lp);
+	C_CSPlayerPawn* lp = H::oGetLocalPlayer(0);
-    QAngle_t* viewangles = (QAngle_t*)(modules.getModule("client") + 0x1A78650);
+	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;
+	int shotsFired = lp ? lp->getShotsFired() : 0;
-    shotCount = shotsFired;
+	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;
-    }
 
-    // Получаем локального игрока и viewangles всегда, чтобы не дублировать код
+	if (Config::aimbot_on_lmb && !Config::always_on_aimbot) {
-    // C_CSPlayerPawn* lp = H::oGetLocalPlayer(0);
+		aimbotActive = isShooting;
-    // Vector_t lep = GetEntityEyePos(lp);
+	}
-    // QAngle_t* viewangles = (QAngle_t*)(modules.getModule("client") + 0x1A78650);
 
-    // Проверка: стреляет ли игрок (LMB)
+	// Получаем локального игрока и viewangles всегда, чтобы не дублировать код
-    // bool isShooting = (GetAsyncKeyState(VK_LBUTTON) & 0x8000);
+	// C_CSPlayerPawn* lp = H::oGetLocalPlayer(0);
+	// Vector_t lep = GetEntityEyePos(lp);
+	// QAngle_t* viewangles = (QAngle_t*)(modules.getModule("client") + 0x1A78650);
 
-    // --- Новый режим: always_on_aimbot ---
+	// Проверка: стреляет ли игрок (LMB)
-    if (Config::always_on_aimbot) {
+	// bool isShooting = (GetAsyncKeyState(VK_LBUTTON) & 0x8000);
-        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++) {
+	// --- Новый режим: always_on_aimbot ---
-            auto Entity = I::GameEntity->Instance->Get(i);
+	if (Config::always_on_aimbot) {
-            if (!Entity)
+		float bestFov = Config::aimbot_fov;
-                continue;
+		PlayerCache* bestTarget = nullptr;
-            if (!Entity->handle().valid())
+		QAngle_t bestAngle = { 0, 0, 0 };
-                continue;
+		for (auto& Player : cached_players) {
-            SchemaClassInfoData_t* _class = nullptr;
+			if (!Player.handle.valid() || Player.health <= 0 || Player.handle.index() == INVALID_EHANDLE_INDEX)
-            Entity->dump_class_info(&_class);
+				continue;
-            if (!_class)
+			if (Config::teamCheck && (Player.team_num == cached_local.team))
-                continue;
+				continue;
-            const uint32_t hash = HASH(_class->szName);
+			Vector_t target_pos = Player.position + Player.viewOffset;
-            if (hash == HASH("C_CSPlayerPawn")) {
+			QAngle_t angle = CalcAngles(target_pos, lep);
-                C_CSPlayerPawn* pawn = (C_CSPlayerPawn*)Entity;
+			angle.x *= -1.f;
-                if (pawn->get_entity_by_handle() == lp->get_entity_by_handle())
+			angle.y += 180.f;
-                    continue;
+			const float fov = GetFov(*viewangles, angle);
-                if (pawn->getHealth() <= 0)
+			if (!std::isfinite(fov) || fov > bestFov)
-                    continue;
+				continue;
-                if (Config::team_check && pawn->getTeam() == lp->getTeam())
+			bestFov = fov;
-                    continue;
+			bestTarget = &Player;
-                Vector_t target_pos = GetEntityEyePos(pawn);//GetAimbotTargetPos(pawn, lep);
+			bestAngle = angle;
-                QAngle_t angle = CalcAngles(target_pos, lep);
+		}
-                angle.x *= -1.f;
+		if (bestTarget) {
-                angle.y += 180.f;
+			Vector_t target_pos = bestTarget->position + bestTarget->viewOffset;
-                const float fov = GetFov(*viewangles, angle);
+			QAngle_t angle = CalcAngles(target_pos, lep);
-                if (!std::isfinite(fov) || fov > bestFov)
+			angle.x *= -1.f;
-                    continue;
+			angle.y += 180.f;
-                bestFov = fov;
+			QAngle_t cur_punch_angle = *(QAngle_t*)((uintptr_t)lp + SchemaFinder::Get(hash_32_fnv1a_const("C_CSPlayerPawn->m_aimPunchAngle")));
-                bestTarget = pawn;
+			// --- RCS ---
-                bestAngle = angle;
+			bool rcsActive = false;
-            }
+			if (Config::shooterAfterAim && (GetAsyncKeyState(Config::triggerbot_key) & 0x8000)) {
-        }
+				rcsActive = (Config::rcs || Config::shooterAfterAim) && (shotCount > Config::rcsActivationShots);
-        if (bestTarget) {
+			}
-            Vector_t target_pos = GetAimbotTargetPos(bestTarget, lep, *viewangles);
+			else {
-            //Vector_t target_pos = GetEntityEyePos(bestTarget);
+				rcsActive = (Config::rcs || Config::shooterAfterAim) && (shotCount > Config::rcsActivationShots);
-            QAngle_t angle = CalcAngles(target_pos, lep);
+			}
-            angle.x *= -1.f;
+			if (rcsActive && shotsFired > 1) {
-            angle.y += 180.f;
+				// Для прямого изменения viewangles: делить НЕ нужно
-            QAngle_t ang_punch_angle = *(QAngle_t*)((uintptr_t)lp + SchemaFinder::Get(hash_32_fnv1a_const("C_CSPlayerPawn->m_aimPunchAngle")));
+				//QAngle_t punchDelta = cur_punch_angle - last_punch_angle;
-            if (isShooting) {
+				//g_DebugString = "debug: " + std::to_string(punchDelta.x);
-                last_punch_angle = ang_punch_angle;
+				angle -= cur_punch_angle * 2.f;
-            } else {
+				last_punch_angle = cur_punch_angle;
-                last_punch_angle = {0,0,0};
+			}
-            }
+			else {
-            // --- RCS ---
+				last_punch_angle = { 0,0,0 };
-            bool rcsActive = (Config::rcs || Config::shooterAfterAim) && (shotCount > 1);
+			}
-            if (rcsActive)
+			angle.z = 0.f;
-                angle -= last_punch_angle * 2.f;
+			angle = angle.Normalize();
-            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;
-                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);
-                    float maxFov = Config::aimbot_fov;
-                    float factor = (maxFov > 0.01f) ? (fov / maxFov) : 0.f;
-                    smooth = smooth + (smooth * factor * Config::aimbot_dynamic_smooth_factor);
-                }
-                angle = cur + delta * (1.f / smooth);
-                angle = angle.Normalize();
-                *viewangles = angle;
-            } else {
-                *viewangles = angle;
-            }
-        }
-        // В этом режиме не используем lockedTarget и не трогаем targetWasLost/prevAimbotState
-        return;
-    }
 
-    // Если кнопка только что нажата (переход с false на true) — ищем новую цель
+			// --- Smooth ---
-    if (aimbotActive && !prevAimbotState) {
+			QAngle_t delta = (angle - *viewangles).Normalize();
-        lastBoneIdx = -1; // Сброс при новой активации
+			if (Config::aimbot_smooth > 0.f) {
-        int nMaxHighestEntity = I::GameEntity->Instance->GetHighestEntityIndex();
+				QAngle_t cur = *viewangles;
-        float bestFov = Config::aimbot_fov;
+				float smooth = Config::aimbot_smooth;
-        C_CSPlayerPawn* bestTarget = nullptr;
+				if (Config::aimbot_dynamic_smooth) {
-        QAngle_t bestAngle = { 0, 0, 0 };
+					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 = smooth + (smooth * factor * Config::aimbot_dynamic_smooth_factor);
+				}
+				angle = cur + delta * (1.f / smooth);
+				angle = angle.Normalize();
+				*viewangles = angle;
+			}
+			else {
+				*viewangles = angle;
+			}
+		}
+		// В этом режиме не используем lockedTarget и не трогаем targetWasLost/prevAimbotState
+		return;
+	}
 
-        for (int i = 1; i <= nMaxHighestEntity; i++) {
+	// Если кнопка только что нажата (переход с false на true) — ищем новую цель
-            auto Entity = I::GameEntity->Instance->Get(i);
+	if (aimbotActive && !prevAimbotState) {
-            if (!Entity)
+		lastBoneIdx = -1; // Сброс при новой активации
-                continue;
+		int nMaxHighestEntity = I::GameEntity->Instance->GetHighestEntityIndex();
-            if (!Entity->handle().valid())
+		float bestFov = Config::aimbot_fov;
-                continue;
+		C_CSPlayerPawn* bestTarget = nullptr;
-            SchemaClassInfoData_t* _class = nullptr;
+		QAngle_t bestAngle = { 0, 0, 0 };
-            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;
-            }
-        }
-        lockedTarget = bestTarget;
-        targetWasLost = false;
-        // Сброс punch_angle при смене цели
-        last_punch_angle = {0,0,0};
-    }
 
-    // Если кнопка отпущена — сбрасываем захват
+		for (int i = 1; i <= nMaxHighestEntity; i++) {
-    if (!aimbotActive) {
+			auto Entity = I::GameEntity->Instance->Get(i);
-        lockedTarget = nullptr;
+			if (!Entity)
-        targetWasLost = false;
+				continue;
-        last_punch_angle = {0,0,0}; // сброс rcs
+			if (!Entity->handle().valid())
-        // Сброс lastBoneIdx при отпускании кнопки аимбота (например, в Aimbot()):
+				continue;
-        // if (!aimbotActive) lastBoneIdx = -1;
+			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 = 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;
+			}
+		}
+		lockedTarget = bestTarget;
+		targetWasLost = false;
+		// Сброс punch_angle при смене цели
+		last_punch_angle = { 0,0,0 };
+	}
 
-    // Если есть захваченная цель и кнопка удерживается
+	// Если кнопка отпущена — сбрасываем захват
-    if (aimbotActive && lockedTarget) {
+	if (!aimbotActive) {
-        // Проверяем, что цель всё ещё валидна
+		lockedTarget = nullptr;
-        if (!lockedTarget->handle().valid() || lockedTarget->getHealth() <= 0) {
+		targetWasLost = false;
-            lockedTarget = nullptr;
+		last_punch_angle = { 0,0,0 }; // сброс rcs
-            targetWasLost = true;
+		// Сброс lastBoneIdx при отпускании кнопки аимбота (например, в Aimbot()):
-            // Не ищем новую цель до повторного нажатия!
+		// if (!aimbotActive) lastBoneIdx = -1;
-            last_punch_angle = {0,0,0}; // сброс rcs
+	}
-        }
-        else {
-            Vector_t target_pos = GetAimbotTargetPos(lockedTarget, lep, *viewangles);
-            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;
-            } 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;
-                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);
-                    float maxFov = Config::aimbot_fov;
-                    float factor = (maxFov > 0.01f) ? (fov / maxFov) : 0.f;
-                    smooth = smooth + (smooth * factor * Config::aimbot_dynamic_smooth_factor);
-                }
-                angle = cur + delta * (1.f / smooth);
-                angle = angle.Normalize();
-                *viewangles = angle;
-            } else {
-                *viewangles = angle;
-            }
-        }
-    }
 
-    //Если кнопка зажата, цели нет, и мы не теряли цель (т.е. только в начале или если цели не было вообще)
+	// Если есть захваченная цель и кнопка удерживается
-    if (aimbotActive && !lockedTarget && !targetWasLost) {
+	if (aimbotActive && lockedTarget) {
-       int nMaxHighestEntity = I::GameEntity->Instance->GetHighestEntityIndex();
+		// Проверяем, что цель всё ещё валидна
-       float bestFov = Config::aimbot_fov;
+		if (!lp || !lp->handle().valid() || lp->getHealth() <= 0) {
-       C_CSPlayerPawn* bestTarget = nullptr;
+			lockedTarget = nullptr;
-       QAngle_t bestAngle = { 0, 0, 0 };
+			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 {
+			Vector_t target_pos = GetAimbotTargetPos(lockedTarget, lep, *viewangles);
+			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 && 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 };
+			}
+			angle.z = 0.f;
+			angle = angle.Normalize();
+			// --- Smooth ---
+			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);
+					float maxFov = Config::aimbot_fov;
+					float factor = (maxFov > 0.01f) ? (fov / maxFov) : 0.f;
+					smooth = smooth + (smooth * factor * Config::aimbot_dynamic_smooth_factor);
+				}
+				angle = cur + delta * (1.f / smooth);
+				angle = angle.Normalize();
+				*viewangles = angle;
+			}
+			else {
+				*viewangles = angle;
+			}
+		}
+	}
 
-       for (int i = 1; i <= nMaxHighestEntity; i++) {
+	//Если кнопка зажата, цели нет, и мы не теряли цель (т.е. только в начале или если цели не было вообще)
-           auto Entity = I::GameEntity->Instance->Get(i);
+	if (aimbotActive && !lockedTarget && !targetWasLost) {
-           if (!Entity)
+		int nMaxHighestEntity = I::GameEntity->Instance->GetHighestEntityIndex();
-               continue;
+		float bestFov = Config::aimbot_fov;
-           if (!Entity->handle().valid())
+		C_CSPlayerPawn* bestTarget = nullptr;
-               continue;
+		QAngle_t bestAngle = { 0, 0, 0 };
-           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;
-           }
-       }
-       lockedTarget = bestTarget;
-       // Сброс punch_angle при смене цели
-       last_punch_angle = {0,0,0};
-    }
 
-    prevAimbotState = aimbotActive;
+		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 = 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;
+			}
+		}
+		lockedTarget = bestTarget;
+		// Сброс punch_angle при смене цели
+		last_punch_angle = { 0,0,0 };
+	}
 
-    //if (Config::shooterAfterAim) {
+	prevAimbotState = aimbotActive;
-    //    if (g_ShowMenu) return;
+}
-    //    C_CSPlayerPawn* lp = H::oGetLocalPlayer(0);
+
-    //    bool onEnemy = false;
+void Ver2Aimbot(CUserCmd* pCmd) {
-    //    if (lp) {
+	//// --- Silent Aim: чистая и безопасная реализация ---
-    //        int crosshairIdx = *(int*)((uintptr_t)lp + 0x1458); // m_iIDEntIndex
+	//if (!Config::silent_aim || !pCmd) return;
-    //        if (crosshairIdx > 0) {
+	//static C_CSPlayerPawn* lockedTarget = nullptr;
-    //            auto target = I::GameEntity->Instance->Get<C_CSPlayerPawn>(crosshairIdx);
+	//static bool prevSilentState = false;
-    //            if (target && target->getHealth() > 0 && (!Config::team_check || target->getTeam() != lp->getTeam()))
+	//static QAngle_t last_punch_angle = { 0,0,0 };
-    //                onEnemy = true;
+	//static int shotCount = 0;
-    //        }
+	//static bool targetWasLost = false;
-    //    }
+	//static bool targetWasLockedThisPress = false;
-    //    // Если врага нет под прицелом — всегда блокируем ЛКМ
+	//C_CSPlayerPawn* lp = H::oGetLocalPlayer(0);
-    //    if (!onEnemy && (GetAsyncKeyState(VK_LBUTTON) & 0x8000)) {
+	//if (!lp || !lp->handle().valid() || lp->getHealth() <= 0) return;
-    //        INPUT input = { 0 };
+	//Vector_t lep = GetEntityEyePos(lp);
-    //        input.type = INPUT_MOUSE;
+	//// Получаем viewangles только из CUserCmd!
-    //        input.mi.dwFlags = MOUSEEVENTF_LEFTUP;
+	//QAngle_t* cur = nullptr;
-    //        SendInput(1, &input, sizeof(INPUT));
+	//if (pCmd->csgoUserCmd.pBaseCmd && pCmd->csgoUserCmd.pBaseCmd->pViewAngles) {
-    //    }
+	//	cur = &pCmd->csgoUserCmd.pBaseCmd->pViewAngles->angValue;
-    //    // return; // Не делаем return, чтобы аимбот работал всегда
+	//}
-    //}
+	//if (!cur) return;
+	//// --- Кнопка активации ---
+	//bool silentActive = Config::always_on_silent_aim ? true : (GetAsyncKeyState(Config::silent_aim_key) & 0x8000);
+	//if (Config::silent_shooterAfterAim && (GetAsyncKeyState(Config::triggerbot_key) & 0x8000)) {
+	//	silentActive = true;
+	//}
+	//int shotsFired = lp ? lp->getShotsFired() : 0;
+	//shotCount = shotsFired;
+	//// --- Сброс флагов при новом нажатии ---
+	//if (silentActive && !prevSilentState) {
+	//	targetWasLost = false;
+	//	targetWasLockedThisPress = false;
+	//}
+	//// --- Поиск цели ---
+	//if (silentActive && !lockedTarget) {
+	//	if (Config::silent_rage || (!targetWasLost && !targetWasLockedThisPress)) {
+	//		int nMaxHighestEntity = I::GameEntity->Instance->GetHighestEntityIndex();
+	//		float bestFov = Config::silent_aim_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;
+	//				// --- Выбор кости для silent aim ---
+	//				Vector_t target_pos;
+	//				switch (Config::silent_aim_bone) {
+	//				case Config::BONE_HEAD:
+	//					target_pos = GetBonePosition(pawn, BONE_INDEX_HEAD); break;
+	//				case Config::BONE_NECK:
+	//					target_pos = GetBonePosition(pawn, BONE_INDEX_NECK); break;
+	//				case Config::BONE_BODY:
+	//					target_pos = GetBonePosition(pawn, BONE_INDEX_BODY); break;
+	//				case Config::BONE_NEAREST:
+	//				default:
+	//					target_pos = GetAimbotTargetPos(pawn, lep, *cur); break;
+	//				}
+	//				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 (!Config::silent_rage && lockedTarget) targetWasLockedThisPress = true;
+	//		if (!Config::silent_rage && !lockedTarget) targetWasLost = true;
+	//	}
+	//}
+	//// --- Сброс при отпускании кнопки ---
+	//if (!silentActive) {
+	//	lockedTarget = nullptr;
+	//	last_punch_angle = { 0,0,0 };
+	//	targetWasLost = false;
+	//	targetWasLockedThisPress = false;
+	//}
+	//// --- Наведение на цель ---
+	//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 };
+	//		targetWasLost = true;
+	//		prevSilentState = silentActive;
+	//		return;
+	//	}
+	//	// --- Выбор кости для silent aim ---
+	//	Vector_t target_pos;
+	//	switch (Config::silent_aim_bone) {
+	//	case Config::BONE_HEAD:
+	//		target_pos = GetBonePosition(lockedTarget, BONE_INDEX_HEAD); break;
+	//	case Config::BONE_NECK:
+	//		target_pos = GetBonePosition(lockedTarget, BONE_INDEX_NECK); break;
+	//	case Config::BONE_BODY:
+	//		target_pos = GetBonePosition(lockedTarget, BONE_INDEX_BODY); break;
+	//	case Config::BONE_NEAREST:
+	//	default:
+	//		target_pos = GetAimbotTargetPos(lockedTarget, lep, *cur); break;
+	//	}
+	//	QAngle_t angle = CalcAngles(target_pos, lep);
+	//	angle.x *= -1.f;
+	//	angle.y += 180.f;
+	//	// --- 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;
+}
+
+// --- Функция для вывода отладочной информации через ImGui ---
+void ShowSilentAimDebugInfo(const CUserCmd* pCmd) {
+    char debugBuf[256];
+    _snprintf_s(debugBuf, sizeof(debugBuf),
+        "CUserCmd: size=%zu, m_csgoUserCmd@%zu, m_nButtons@%zu, nSubticks=%d, pRep=%p, pBaseCmd=%p",
+        sizeof(CUserCmd),
+        offsetof(CUserCmd, m_csgoUserCmd),
+        offsetof(CUserCmd, m_nButtons),
+        pCmd->m_csgoUserCmd.m_inputHistoryField.m_pRep ? pCmd->m_csgoUserCmd.m_inputHistoryField.m_pRep->m_nAllocatedSize : 0,
+        (void*)pCmd->m_csgoUserCmd.m_inputHistoryField.m_pRep,
+        (void*)pCmd->m_csgoUserCmd.m_pBaseCmd);
+    g_DebugString = debugBuf;
+}
+
+void SilentAimbot(CUserCmd* pCmd) {
+    if (!Config::silent_aim || !pCmd)
+        return;
+
+    C_CSPlayerPawn* lp = H::oGetLocalPlayer(0);
+    if (!lp || !lp->handle().valid() || lp->getHealth() <= 0)
+        return;
+
+    // Кнопка активации
+    bool silentActive = Config::always_on_silent_aim ? true : (GetAsyncKeyState(Config::silent_aim_key) & 0x8000);
+    if (Config::silent_shooterAfterAim && (GetAsyncKeyState(Config::triggerbot_key) & 0x8000)) {
+        silentActive = true;
+    }
+    if (!silentActive)
+        return;
+
+    Vector_t localEye = GetEntityEyePos(lp);
+    // --- Исправленный доступ к углам ---
+    QAngle_t* curAngles = nullptr;
+    if (pCmd && pCmd->csgoUserCmd.pBaseCmd && pCmd->csgoUserCmd.pBaseCmd->pViewAngles)
+        curAngles = &pCmd->csgoUserCmd.pBaseCmd->pViewAngles->angValue;
+    if (!curAngles)
+        return;
+
+    // Поиск цели
+    float bestFov = Config::silent_aim_fov;
+    C_CSPlayerPawn* bestTarget = nullptr;
+    Vector_t bestTargetPos{};
+    for (int i = 1; i <= I::GameEntity->Instance->GetHighestEntityIndex(); ++i) {
+        auto Entity = I::GameEntity->Instance->Get(i);
+        if (!Entity || !Entity->handle().valid())
+            continue;
+        SchemaClassInfoData_t* _class = nullptr;
+        Entity->dump_class_info(&_class);
+        if (!_class || HASH(_class->szName) != HASH("C_CSPlayerPawn"))
+            continue;
+        C_CSPlayerPawn* pawn = (C_CSPlayerPawn*)Entity;
+        if (!pawn || pawn->get_entity_by_handle() == lp->get_entity_by_handle() || pawn->getHealth() <= 0)
+            continue;
+        if (Config::team_check && pawn->getTeam() == lp->getTeam())
+            continue;
+        Vector_t targetPos = GetBonePosition(pawn, Config::silent_aim_bone == Config::BONE_HEAD ? BONE_INDEX_HEAD :
+                                                        Config::silent_aim_bone == Config::BONE_NECK ? BONE_INDEX_NECK :
+                                                        Config::silent_aim_bone == Config::BONE_BODY ? BONE_INDEX_BODY :
+                                                        BONE_INDEX_HEAD);
+        QAngle_t angle = CalcAngles(targetPos, localEye);
+        angle.x *= -1.f;
+        angle.y += 180.f;
+        float fov = GetFov(*curAngles, angle);
+        if (!std::isfinite(fov) || fov > bestFov)
+            continue;
+        bestFov = fov;
+        bestTarget = pawn;
+        bestTargetPos = targetPos;
+    }
+    if (!bestTarget)
+        return;
+
+    QAngle_t aimAngle = CalcAngles(bestTargetPos, localEye);
+    aimAngle.x *= -1.f;
+    aimAngle.y += 180.f;
+
+    // Установить угол для всех сабтиков
+    pCmd->SetSubTickAngle(aimAngle);
 }

TempleWare-CS2/source/templeware/features/aim/aim.h

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

TempleWare-CS2/source/templeware/features/spectators/spectators.cpp

@@ -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 

TempleWare-CS2/source/templeware/features/spectators/spectators.h

@@ -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();
+} 

TempleWare-CS2/source/templeware/features/triggerbot/triggerbot.cpp

@@ -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) {
+        SetLMBHeld(false);
-            SimulateLMBUp();
-            lmbHeld = 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);
+    int shotsFired = lp ? lp->getShotsFired() : 0;
-    if (crosshairIdx <= 0) {
+    DWORD64 now = GetTickCount64();
-        if (lmbHeld) {
+    if (Config::shooterAfterAim) {
-            SimulateLMBUp();
+        if (shotsFired > 0) {
-            lmbHeld = false;
+            // После первого выстрела просто удерживаем ЛКМ, игнорируя все условия
+            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) {
+        SetLMBHeld(false);
-            SimulateLMBUp();
-            lmbHeld = false;
-        }
         firstShot = true;
         return;
     }
     if (target->getHealth() <= 0) {
-        if (lmbHeld) {
+        SetLMBHeld(false);
-            SimulateLMBUp();
-            lmbHeld = false;
-        }
         firstShot = true;
         return;
     }
     if (Config::team_check && target->getTeam() == lp->getTeam()) {
-        if (lmbHeld) {
+        SetLMBHeld(false);
-            SimulateLMBUp();
-            lmbHeld = false;
-        }
         firstShot = true;
         return;
     }
-    DWORD64 now = GetTickCount64();
     if (!Config::triggerbot_hold_lmb) {
         if (now - lastShotTime < static_cast<DWORD64>(Config::triggerbot_delay)) {
-            if (lmbHeld) {
+            SetLMBHeld(false);
-                SimulateLMBUp();
-                lmbHeld = false;
-            }
             firstShot = true;
             return;
         }
@@ -103,9 +173,8 @@ void Triggerbot() {
             firstShot = false;
             lastShotTime = now;
             return;
-        } else if (!lmbHeld) {
+        } else {
-            SimulateLMBDown();
+            SetLMBHeld(true);
-            lmbHeld = true;
         }
         lastShotTime = now;
         return;

TempleWare-CS2/source/templeware/features/visuals/visuals.cpp

@@ -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(),
+                if (!Players::pawns.contains(entityPointer)) {
-                    [&](const C_CSPlayerPawn& pawn) { return pawn.getAddress() == entityPointer; });
+                    Players::pawns.insert(entityPointer);
-                if (!exists) {
-                    Players::pawns.emplace_back(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(),
+                if (!Players::controllers.contains(entityPointer)) {
-                    [&](const CCSPlayerController& controller) { return controller.getAddress() == entityPointer; });
+                    Players::controllers.insert(entityPointer);
-                if (!exists) {
-                    Players::controllers.emplace_back(entityPointer);
                 }
                 continue;
             }

TempleWare-CS2/source/templeware/hooks/hooks.cpp

@@ -27,9 +27,6 @@ void __fastcall H::hkFrameStageNotify(void* a1, int stage)
 	// frame_render_stage | 9
 	if (stage == 9 && oGetLocalPlayer(0)) {
 		Esp::cache();
-
-		Aimbot();
-		Triggerbot(); // <--- вызов триггербота
 	}
 }
 
@@ -41,6 +38,15 @@ void* __fastcall H::hkLevelInit(void* pClientModeShared, const char* szNewMap) {
 	return LevelInit.GetOriginal()(pClientModeShared, szNewMap);
 }
 
+bool __fastcall H::hkCreateMove(void* pInput, int nSlot, CUserCmd* pCmd) {
+    SilentAimbot(pCmd);
+	//Ver2Aimbot(pCmd);
+    Triggerbot();
+
+	return CreateMove.GetOriginal()(pInput, nSlot, pCmd);
+		// return CreateMove.GetOriginal()(pInput, edx, nSlot, pCmd);
+}
+
 void H::Hooks::init() {
 
 	oGetWeaponData = *reinterpret_cast<int*>(M::patternScan("client", ("48 8B 81 ? ? ? ? 85 D2 78 ? 48 83 FA ? 73 ? F3 0F 10 84 90 ? ? ? ? C3 F3 0F 10 80 ? ? ? ? C3 CC CC CC CC")) + 0x3);
@@ -53,6 +59,7 @@ void H::Hooks::init() {
 	GetRenderFov.Add((void*)M::getAbsoluteAddress(M::patternScan("client", "E8 ? ? ? ? F3 0F 11 45 00 48 8B 5C 24 40"), 1), &hkGetRenderFov);
 	LevelInit.Add((void*)M::getAbsoluteAddress(M::patternScan("client", "E8 ? ? ? ? C6 83 ? ? ? ? ? C6 83"), 1), &hkLevelInit);
 	RenderFlashBangOverlay.Add((void*)M::patternScan("client", ("85 D2 0F 88 ? ? ? ? 55 56 41 55")), &hkRenderFlashbangOverlay);
+	CreateMove.Add((void*)M::patternScan("client", ("48 8B C4 4C 89 40 18 48 89 48 08 55 53 57 41 54 48 8D A8")), &hkCreateMove);
 
 	MH_EnableHook(MH_ALL_HOOKS);
 }

TempleWare-CS2/source/templeware/hooks/hooks.h

@@ -1,4 +1,5 @@
 #pragma once
+#include "../features/aim/CUserCmd.h"
 #include "includeHooks.h"
 #include "../../cs2/entity/C_AggregateSceneObject/C_AggregateSceneObject.h"
 #include "../../cs2/entity/C_CSPlayerPawn/C_CSPlayerPawn.h"
@@ -16,6 +17,8 @@ namespace H {
 	void* __fastcall hkLevelInit(void* pClientModeShared, const char* szNewMap);
 	void __fastcall hkChamsObject(void* pAnimatableSceneObjectDesc, void* pDx11, CMeshData* arrMeshDraw, int nDataCount, void* pSceneView, void* pSceneLayer, void* pUnk, void* pUnk2);
 	void __fastcall hkRenderFlashbangOverlay(void* a1, void* a2, void* a3, void* a4, void* a5);
+	// bool __fastcall hkCreateMove(void* pInput, void* edx, int nSlot, CUserCmd* pCmd);
+	bool __fastcall hkCreateMove(void* pInput, int nSlot, CUserCmd* pCmd);
 	inline float g_flActiveFov;
 	float hkGetRenderFov(void* rcx);
 
@@ -25,6 +28,7 @@ namespace H {
 	inline CInlineHookObj<decltype(&hkGetRenderFov)> GetRenderFov = { };
 	inline CInlineHookObj<decltype(&hkLevelInit)> LevelInit = { };
 	inline CInlineHookObj<decltype(&hkRenderFlashbangOverlay)> RenderFlashBangOverlay = { };
+	inline CInlineHookObj<decltype(&hkCreateMove)> CreateMove = { };
 
 	// inline hooks
 	inline int  oGetWeaponData;

TempleWare-CS2/source/templeware/menu/hud.cpp

@@ -6,6 +6,7 @@
 #include <string>
 #include <sstream>
 #include <DirectXMath.h>
+#include "../features/spectators/spectators.h"
 
 std::string g_DebugString;
 
@@ -79,4 +80,16 @@ void Hud::render() {
         ImU32 debugColor = IM_COL32(255, 255, 0, 255); // жёлтый
         ImGui::GetBackgroundDrawList()->AddText(debugPos, debugColor, g_DebugString.c_str());
     }
+
+    // Отображение списка наблюдателей
+    //Spectators::RenderSpectatorList();
+     //Spectators::RenderPlayersDebugList();
+
+    
+    // Тестовая информация для отладки
+    //static int testCounter = 0;
+    //testCounter++;
+    //if (testCounter % 60 == 0) { // Каждую секунду (при 60 FPS)
+    //    g_DebugString = "Spectator test: " + std::to_string(Spectators::GetSpectators().size()) + " players found";
+    //}
 }

TempleWare-CS2/source/templeware/menu/hud.h

@@ -1,5 +1,6 @@
 #pragma once
 #include <string>
+#include "../features/spectators/spectators.h"
 extern std::string g_DebugString;
 
 class Hud {