фыв

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[0x10];
+	CKeyValues3* pKeyValue = new CKeyValues3;
 	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,22 @@ 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 для сайлент аимбота
 }

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

@@ -70,5 +70,22 @@ 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 для сайлент аимбота
 }

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

@@ -130,9 +130,11 @@ 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["enemyChamsInvisible"] = Config::enemyChamsInvisible;
@@ -170,6 +172,7 @@ namespace internal_config
                 Config::fovCircleColor.z,
                 Config::fovCircleColor.w
             };
+            j["rcsActivationShots"] = Config::rcsActivationShots;
 
             auto filePath = GetConfigPath(configName);
             std::ofstream ofs(filePath);
@@ -243,9 +246,11 @@ 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::antiflash = j.value("antiflash", false);
@@ -315,6 +320,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,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
+}; 

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

@@ -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,31 +166,15 @@ 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);
+            Vector_t target_pos = Player.position + Player.viewOffset;
             QAngle_t angle = CalcAngles(target_pos, lep);
             angle.x *= -1.f;
             angle.y += 180.f;
@@ -173,45 +182,38 @@ void Aimbot() {
             if (!std::isfinite(fov) || fov > bestFov)
                 continue;
             bestFov = fov;
-                bestTarget = pawn;
+            bestTarget = &Player;
             bestAngle = angle;
         }
-        }
         if (bestTarget) {
-            Vector_t target_pos = GetAimbotTargetPos(bestTarget, lep, *viewangles);
-            //Vector_t target_pos = GetEntityEyePos(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 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 && 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,266 @@ 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;
+//}
+//
+
+void SilentAimbot(CUserCmd* pCmd) {
+    // --- Silent Aim: чистая и безопасная реализация ---
+    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;
+    static bool targetWasLost = false;
+    static bool targetWasLockedThisPress = false;
+    C_CSPlayerPawn* lp = H::oGetLocalPlayer(0);
+    if (!lp || !lp->handle().valid() || lp->getHealth() <= 0) return;
+    Vector_t lep = GetEntityEyePos(lp);
+    // Получаем viewangles только из CUserCmd!
+    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);
+    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 ((!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 (lockedTarget) targetWasLockedThisPress = true;
+            if (!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;
 }

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

@@ -1,3 +1,6 @@
 #pragma once
 
+#include "CUserCmd.h"
+
 void Aimbot();
+void SilentAimbot(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,90 @@ void SimulateLMBUp() {
     SendInput(1, &input, sizeof(INPUT));
 }
 
-static DWORD lastShotTime = 0;
-void Triggerbot() {
-    static DWORD lastShotTime = 0;
+// Управление удержанием ЛКМ
+void SetLMBHeld(bool held) {
     static bool lmbHeld = false;
-    static bool firstShot = true;
-    if (!Config::triggerbot)
-        return;
-    if (!Config::always_on_triggerbot && Config::triggerbot_key && !(GetAsyncKeyState(Config::triggerbot_key) & 0x8000))
-        return;
-    if (GetAsyncKeyState(VK_LBUTTON) & 0x8000) {
-        if (lmbHeld) {
+    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 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)) {
+        SetLMBHeld(false);
+        firstShot = true;
+        return;
+    }
+    if (GetAsyncKeyState(VK_LBUTTON) & 0x8000) {
+        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);
+    int shotsFired = lp ? lp->getShotsFired() : 0;
+    DWORD64 now = GetTickCount64();
+    if (Config::shooterAfterAim) {
+        if (shotsFired > 0) {
+            // После первого выстрела просто удерживаем ЛКМ, игнорируя все условия
+            SetLMBHeld(true);
+            return;
+        } else {
+            // До первого выстрела — обычная логика триггербота
             if (crosshairIdx <= 0) {
-        if (lmbHeld) {
-            SimulateLMBUp();
-            lmbHeld = false;
-        }
+                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 +126,55 @@ void Triggerbot() {
                     firstShot = false;
                     lastShotTime = now;
                     return;
-        } else if (!lmbHeld) {
-            SimulateLMBDown();
-            lmbHeld = true;
+                } 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) {
+        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;

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(),
-                    [&](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;
             }

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,13 @@ void* __fastcall H::hkLevelInit(void* pClientModeShared, const char* szNewMap) {
 	return LevelInit.GetOriginal()(pClientModeShared, szNewMap);
 }
 
+bool __fastcall H::hkCreateMove(void* pInput, int nSlot, void* pCmd) {
+    //Aimbot();
+    SilentAimbot(reinterpret_cast<CUserCmd*>(pCmd));
+    Triggerbot();
+    return CreateMove.GetOriginal()(pInput, 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 +57,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

@@ -16,6 +16,7 @@ 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, int nSlot, void* pCmd);
 	inline float g_flActiveFov;
 	float hkGetRenderFov(void* rcx);
 
@@ -25,6 +26,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 {