фыв

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

@@ -81,5 +81,4 @@ namespace Config {
 	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

@@ -88,5 +88,4 @@ namespace Config {
 	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

@@ -136,7 +136,6 @@ namespace internal_config
             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;
@@ -253,7 +252,6 @@ namespace internal_config
             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);
 

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

@@ -1,139 +1,29 @@
 #pragma once
 #include <cstdint>
+#include <array>
 #include "../../../templeware/utils/math/vector/vector.h"
 
-#define MEM_PAD(size) char _pad##__LINE__[size]
+struct CCmdQAngle {
-
+    QAngle_t angValue;
-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 {
+class CBaseUserCmdPB {
 public:
-    MEM_PAD(0x8); // 0x0 VTABLE
+    char pad_0x00[0x40];
-    std::uint32_t nHasBits; // 0x8
+    CCmdQAngle* pViewangles; // 0x40
-    std::uint64_t nCachedBits; // 0xC
+    // ... другие поля не нужны для silent aim
-    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;
+    char pad_0x00[0x18];
-    std::uint64_t nCachedSize;
+    CBaseUserCmdPB* pBase; // 0x18
-    RepeatedPtrField_t<CCSGOInputHistoryEntryPB> inputHistoryField;
+    // ... другие поля не нужны для silent aim
-    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
+    char pad_0x00[0x18];
-    MEM_PAD(0x10); // 0x8
+    CCSGOUserCmdPB pBase; // 0x18
-    CCSGOUserCmdPB csgoUserCmd; // 0x18
+    // ... другие поля не нужны для silent aim
-    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

@@ -15,7 +15,6 @@
 #include <Psapi.h>
 #include "../../menu/hud.h"
 #include "../../menu/menu.h"
-#include <iostream>
 
 // Адреса из дампа (актуально для 2024-07-18)
 #define DW_SENSITIVITY 0x1A6A9D8
@@ -94,7 +93,7 @@ Vector_t GetAimbotTargetPos(const C_CSPlayerPawn* Entity, const Vector_t& from,
         case Config::BONE_NEAREST:
         default: {
             // Каждый раз ищем ближайшую кость по 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;
             int bestIdx = BONE_INDEX_HEAD;
             for (int idx : bones) {
@@ -134,7 +133,7 @@ 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 QAngle_t last_punch_angle = {0,0,0};
     static int shotCount = 0;
     float sensitivity = GetGameSensitivity();
     bool aimbotActive = Config::always_on_aimbot ? true : Config::aimbot;
@@ -196,8 +195,7 @@ void Aimbot() {
             bool rcsActive = false;
             if (Config::shooterAfterAim && (GetAsyncKeyState(Config::triggerbot_key) & 0x8000)) {
                 rcsActive = (Config::rcs || Config::shooterAfterAim) && (shotCount > Config::rcsActivationShots);
-			}
+            } else {
-			else {
                 rcsActive = (Config::rcs || Config::shooterAfterAim) && (shotCount > Config::rcsActivationShots);
             }
             if (rcsActive && shotsFired > 1) {
@@ -206,9 +204,8 @@ void Aimbot() {
                 //g_DebugString = "debug: " + std::to_string(punchDelta.x);
                 angle -= cur_punch_angle * 2.f;
                 last_punch_angle = cur_punch_angle;
-			}
+            } else {
-			else {
+                last_punch_angle = {0,0,0};
-				last_punch_angle = { 0,0,0 };
             }
             angle.z = 0.f;
             angle = angle.Normalize();
@@ -227,8 +224,7 @@ void Aimbot() {
                 angle = cur + delta * (1.f / smooth);
                 angle = angle.Normalize();
                 *viewangles = angle;
-			}
+            } else {
-			else {
                 *viewangles = angle;
             }
         }
@@ -276,14 +272,14 @@ void Aimbot() {
         lockedTarget = bestTarget;
         targetWasLost = false;
         // Сброс punch_angle при смене цели
-		last_punch_angle = { 0,0,0 };
+        last_punch_angle = {0,0,0};
     }
 
     // Если кнопка отпущена — сбрасываем захват
     if (!aimbotActive) {
         lockedTarget = nullptr;
         targetWasLost = false;
-		last_punch_angle = { 0,0,0 }; // сброс rcs
+        last_punch_angle = {0,0,0}; // сброс rcs
         // Сброс lastBoneIdx при отпускании кнопки аимбота (например, в Aimbot()):
         // if (!aimbotActive) lastBoneIdx = -1;
     }
@@ -294,7 +290,7 @@ void Aimbot() {
         if (!lp || !lp->handle().valid() || lp->getHealth() <= 0) {
             lockedTarget = nullptr;
             targetWasLost = false;
-			last_punch_angle = { 0,0,0 };
+            last_punch_angle = {0,0,0};
             return;
         }
         if (
@@ -304,7 +300,7 @@ void Aimbot() {
         ) {
             lockedTarget = nullptr;
             targetWasLost = true;
-			last_punch_angle = { 0,0,0 }; // сброс rcs
+            last_punch_angle = {0,0,0}; // сброс rcs
         }
         else {
             Vector_t target_pos = GetAimbotTargetPos(lockedTarget, lep, *viewangles);
@@ -316,8 +312,7 @@ void Aimbot() {
             bool rcsActive = false;
             if (Config::shooterAfterAim && (GetAsyncKeyState(Config::triggerbot_key) & 0x8000)) {
                 rcsActive = (Config::rcs || Config::shooterAfterAim) && (shotCount > Config::rcsActivationShots);
-			}
+            } else {
-			else {
                 rcsActive = (Config::rcs || Config::shooterAfterAim) && (shotCount > Config::rcsActivationShots);
             }
             if (rcsActive && shotCount > 1) {
@@ -326,9 +321,8 @@ void Aimbot() {
                 //g_DebugString = "debug: " + std::to_string(punchDelta.x);
                 angle -= cur_punch_angle * 2.f;
                 last_punch_angle = cur_punch_angle;
-			}
+            } else {
-			else {
+                last_punch_angle = {0,0,0};
-				last_punch_angle = { 0,0,0 };
             }
             angle.z = 0.f;
             angle = angle.Normalize();
@@ -346,8 +340,7 @@ void Aimbot() {
                 angle = cur + delta * (1.f / smooth);
                 angle = angle.Normalize();
                 *viewangles = angle;
-			}
+            } else {
-			else {
                 *viewangles = angle;
             }
         }
@@ -391,217 +384,270 @@ void Aimbot() {
        }
        lockedTarget = bestTarget;
        // Сброс punch_angle при смене цели
-		last_punch_angle = { 0,0,0 };
+       last_punch_angle = {0,0,0};
     }
 
     prevAimbotState = aimbotActive;
 }
 
-void Ver2Aimbot(CUserCmd* pCmd) {
+//void SilentAimbot(CUserCmd* pCmd) {
-	//// --- Silent Aim: чистая и безопасная реализация ---
+//    if (!Config::silent_aim || !pCmd) return;
-	//if (!Config::silent_aim || !pCmd) return;
+//    static C_CSPlayerPawn* lockedTarget = nullptr;
-	//static C_CSPlayerPawn* lockedTarget = nullptr;
+//    static bool prevSilentState = false;
-	//static bool prevSilentState = 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;
+//    C_CSPlayerPawn* lp = H::oGetLocalPlayer(0);
-	//static bool targetWasLost = false;
+//    if (!lp || !lp->handle().valid() || lp->getHealth() <= 0) return;
-	//static bool targetWasLockedThisPress = false;
+//    Vector_t lep = GetEntityEyePos(lp);
-	//C_CSPlayerPawn* lp = H::oGetLocalPlayer(0);
+//    QAngle_t* cur = (QAngle_t*)(modules.getModule("client") + 0x1A78650);
-	//if (!lp || !lp->handle().valid() || lp->getHealth() <= 0) return;
+//    if (!cur) return;
-	//Vector_t lep = GetEntityEyePos(lp);
+//    bool silentActive = Config::always_on_silent_aim ? true : (GetAsyncKeyState(Config::silent_aim_key) & 0x8000);
-	//// Получаем viewangles только из CUserCmd!
+//    // --- shooterAfterAim + triggerbot_key для сайлент аимбота ---
-	//QAngle_t* cur = nullptr;
+//    if (Config::silent_shooterAfterAim && (GetAsyncKeyState(Config::triggerbot_key) & 0x8000)) {
-	//if (pCmd->csgoUserCmd.pBaseCmd && pCmd->csgoUserCmd.pBaseCmd->pViewAngles) {
+//        silentActive = true;
-	//	cur = &pCmd->csgoUserCmd.pBaseCmd->pViewAngles->angValue;
+//    }
-	//}
+//    int shotsFired = lp ? lp->getShotsFired() : 0;
-	//if (!cur) return;
+//    shotCount = shotsFired;
-	//// --- Кнопка активации ---
+//
-	//bool silentActive = Config::always_on_silent_aim ? true : (GetAsyncKeyState(Config::silent_aim_key) & 0x8000);
+//    // Если кнопка только что нажата — ищем новую цель
-	//if (Config::silent_shooterAfterAim && (GetAsyncKeyState(Config::triggerbot_key) & 0x8000)) {
+//    if (silentActive && !prevSilentState) {
-	//	silentActive = true;
+//        int nMaxHighestEntity = I::GameEntity->Instance->GetHighestEntityIndex();
-	//}
+//        float bestFov = Config::aimbot_fov;
-	//int shotsFired = lp ? lp->getShotsFired() : 0;
+//        C_CSPlayerPawn* bestTarget = nullptr;
-	//shotCount = shotsFired;
+//        QAngle_t bestAngle = { 0, 0, 0 };
-	//// --- Сброс флагов при новом нажатии ---
+//        for (int i = 1; i <= nMaxHighestEntity; i++) {
-	//if (silentActive && !prevSilentState) {
+//            auto Entity = I::GameEntity->Instance->Get(i);
-	//	targetWasLost = false;
+//            if (!Entity) continue;
-	//	targetWasLockedThisPress = false;
+//            if (!Entity->handle().valid()) continue;
-	//}
+//            SchemaClassInfoData_t* _class = nullptr;
-	//// --- Поиск цели ---
+//            Entity->dump_class_info(&_class);
-	//if (silentActive && !lockedTarget) {
+//            if (!_class) continue;
-	//	if (Config::silent_rage || (!targetWasLost && !targetWasLockedThisPress)) {
+//            const uint32_t hash = HASH(_class->szName);
-	//		int nMaxHighestEntity = I::GameEntity->Instance->GetHighestEntityIndex();
+//            if (hash == HASH("C_CSPlayerPawn")) {
-	//		float bestFov = Config::silent_aim_fov;
+//                C_CSPlayerPawn* pawn = (C_CSPlayerPawn*)Entity;
-	//		C_CSPlayerPawn* bestTarget = nullptr;
+//                if (!pawn) continue;
-	//		QAngle_t bestAngle = { 0, 0, 0 };
+//                if (pawn->get_entity_by_handle() == lp->get_entity_by_handle()) continue;
-	//		for (int i = 1; i <= nMaxHighestEntity; i++) {
+//                if (pawn->getHealth() <= 0) continue;
-	//			auto Entity = I::GameEntity->Instance->Get(i);
+//                if (Config::team_check && pawn->getTeam() == lp->getTeam()) continue;
-	//			if (!Entity) continue;
+//                Vector_t target_pos = GetAimbotTargetPos(pawn, lep, *cur);
-	//			if (!Entity->handle().valid()) continue;
+//                QAngle_t angle = CalcAngles(target_pos, lep);
-	//			SchemaClassInfoData_t* _class = nullptr;
+//                angle.x *= -1.f;
-	//			Entity->dump_class_info(&_class);
+//                angle.y += 180.f;
-	//			if (!_class) continue;
+//                float fov = GetFov(*cur, angle);
-	//			const uint32_t hash = HASH(_class->szName);
+//                if (!std::isfinite(fov) || fov > bestFov) continue;
-	//			if (hash == HASH("C_CSPlayerPawn")) {
+//                bestFov = fov;
-	//				C_CSPlayerPawn* pawn = (C_CSPlayerPawn*)Entity;
+//                bestTarget = pawn;
-	//				if (!pawn) continue;
+//                bestAngle = angle;
-	//				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;
+//        lockedTarget = bestTarget;
-	//				// --- Выбор кости для silent aim ---
+//        last_punch_angle = {0,0,0};
-	//				Vector_t target_pos;
+//    }
-	//				switch (Config::silent_aim_bone) {
+//
-	//				case Config::BONE_HEAD:
+//    // Если кнопка зажата, цели нет — постоянный поиск цели
-	//					target_pos = GetBonePosition(pawn, BONE_INDEX_HEAD); break;
+//    if (silentActive && !lockedTarget) {
-	//				case Config::BONE_NECK:
+//        int nMaxHighestEntity = I::GameEntity->Instance->GetHighestEntityIndex();
-	//					target_pos = GetBonePosition(pawn, BONE_INDEX_NECK); break;
+//        float bestFov = Config::aimbot_fov;
-	//				case Config::BONE_BODY:
+//        C_CSPlayerPawn* bestTarget = nullptr;
-	//					target_pos = GetBonePosition(pawn, BONE_INDEX_BODY); break;
+//        QAngle_t bestAngle = { 0, 0, 0 };
-	//				case Config::BONE_NEAREST:
+//        for (int i = 1; i <= nMaxHighestEntity; i++) {
-	//				default:
+//            auto Entity = I::GameEntity->Instance->Get(i);
-	//					target_pos = GetAimbotTargetPos(pawn, lep, *cur); break;
+//            if (!Entity) continue;
-	//				}
+//            if (!Entity->handle().valid()) continue;
-	//				QAngle_t angle = CalcAngles(target_pos, lep);
+//            SchemaClassInfoData_t* _class = nullptr;
-	//				angle.x *= -1.f;
+//            Entity->dump_class_info(&_class);
-	//				angle.y += 180.f;
+//            if (!_class) continue;
-	//				float fov = GetFov(*cur, angle);
+//            const uint32_t hash = HASH(_class->szName);
-	//				if (!std::isfinite(fov) || fov > bestFov) continue;
+//            if (hash == HASH("C_CSPlayerPawn")) {
-	//				bestFov = fov;
+//                C_CSPlayerPawn* pawn = (C_CSPlayerPawn*)Entity;
-	//				bestTarget = pawn;
+//                if (!pawn) continue;
-	//				bestAngle = angle;
+//                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;
-	//		lockedTarget = bestTarget;
+//                Vector_t target_pos = GetAimbotTargetPos(pawn, lep, *cur);
-	//		last_punch_angle = { 0,0,0 };
+//                QAngle_t angle = CalcAngles(target_pos, lep);
-	//		if (!Config::silent_rage && lockedTarget) targetWasLockedThisPress = true;
+//                angle.x *= -1.f;
-	//		if (!Config::silent_rage && !lockedTarget) targetWasLost = true;
+//                angle.y += 180.f;
-	//	}
+//                float fov = GetFov(*cur, angle);
-	//}
+//                if (!std::isfinite(fov) || fov > bestFov) continue;
-	//// --- Сброс при отпускании кнопки ---
+//                bestFov = fov;
-	//if (!silentActive) {
+//                bestTarget = pawn;
-	//	lockedTarget = nullptr;
+//                bestAngle = angle;
-	//	last_punch_angle = { 0,0,0 };
+//            }
-	//	targetWasLost = false;
+//        }
-	//	targetWasLockedThisPress = false;
+//        lockedTarget = bestTarget;
-	//}
+//        last_punch_angle = {0,0,0};
-	//// --- Наведение на цель ---
+//    }
-	//if (silentActive && lockedTarget) {
+//
-	//	// Проверка валидности цели
+//    // Если кнопка отпущена — сбрасываем захват
-	//	if (!lp || !lp->handle().valid() || lp->getHealth() <= 0 ||
+//    if (!silentActive) {
-	//		lockedTarget->get_entity_by_handle() == lp->get_entity_by_handle() ||
+//        lockedTarget = nullptr;
-	//		lockedTarget->getHealth() <= 0 ||
+//        last_punch_angle = {0,0,0};
-	//		!lockedTarget->handle().valid() ||
+//    }
-	//		(Config::team_check && lockedTarget->getTeam() == lp->getTeam())) {
+//
-	//		lockedTarget = nullptr;
+//    // Если есть захваченная цель и кнопка удерживается
-	//		last_punch_angle = { 0,0,0 };
+//    if (silentActive && lockedTarget) {
-	//		targetWasLost = true;
+//        // Проверяем, что цель всё ещё валидна
-	//		prevSilentState = silentActive;
+//        if (!lp || !lp->handle().valid() || lp->getHealth() <= 0 ||
-	//		return;
+//            lockedTarget->get_entity_by_handle() == lp->get_entity_by_handle() ||
-	//	}
+//            lockedTarget->getHealth() <= 0 ||
-	//	// --- Выбор кости для silent aim ---
+//            !lockedTarget->handle().valid() ||
-	//	Vector_t target_pos;
+//            (Config::team_check && lockedTarget->getTeam() == lp->getTeam())) {
-	//	switch (Config::silent_aim_bone) {
+//            lockedTarget = nullptr;
-	//	case Config::BONE_HEAD:
+//            last_punch_angle = {0,0,0};
-	//		target_pos = GetBonePosition(lockedTarget, BONE_INDEX_HEAD); break;
+//            prevSilentState = silentActive;
-	//	case Config::BONE_NECK:
+//            return;
-	//		target_pos = GetBonePosition(lockedTarget, BONE_INDEX_NECK); break;
+//        }
-	//	case Config::BONE_BODY:
+//        Vector_t target_pos = GetAimbotTargetPos(lockedTarget, lep, *cur);
-	//		target_pos = GetBonePosition(lockedTarget, BONE_INDEX_BODY); break;
+//        QAngle_t angle = CalcAngles(target_pos, lep);
-	//	case Config::BONE_NEAREST:
+//        angle.x *= -1.f;
-	//	default:
+//        angle.y += 180.f;
-	//		target_pos = GetAimbotTargetPos(lockedTarget, lep, *cur); break;
+//        //QAngle_t cur_punch_angle = *(QAngle_t*)((uintptr_t)lp + SchemaFinder::Get(hash_32_fnv1a_const("C_CSPlayerPawn->m_aimPunchAngle")));
-	//	}
+//        //// --- RCS ---
-	//	QAngle_t angle = CalcAngles(target_pos, lep);
+//        //bool rcsActive = (Config::rcs || Config::silent_shooterAfterAim) && (shotCount > Config::rcsActivationShots);
-	//	angle.x *= -1.f;
+//        //if (rcsActive && shotCount > 1) {
-	//	angle.y += 180.f;
+//        //    angle -= cur_punch_angle * 2.f;
-	//	// --- Smooth ---
+//        //    last_punch_angle = cur_punch_angle;
-	//	if (Config::silent_aim_smooth > 0.f) {
+//        //} else {
-	//		QAngle_t delta = (angle - *cur).Normalize();
+//        //    last_punch_angle = {0,0,0};
-	//		float smooth = Config::silent_aim_smooth;
+//        //}
-	//		angle = *cur + delta * (1.f / smooth);
+//        //angle.z = 0.f;
-	//		angle = angle.Normalize();
+//        //angle = angle.Normalize();
-	//	}
+//        // --- Smooth ---
-	//	*cur = angle;
+//        if (Config::silent_aim_smooth > 0.f) {
-	//}
+//            QAngle_t delta = (angle - *cur).Normalize();
-	//prevSilentState = silentActive;
+//            float smooth = Config::silent_aim_smooth;
-}
+//            angle = *cur + delta * (1.f / smooth);
-
+//            angle = angle.Normalize();
-// --- Функция для вывода отладочной информации через ImGui ---
+//        }
-void ShowSilentAimDebugInfo(const CUserCmd* pCmd) {
+//        *cur = angle;
-    char debugBuf[256];
+//    }
-    _snprintf_s(debugBuf, sizeof(debugBuf),
+//    prevSilentState = silentActive;
-        "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)
+    // --- Silent Aim: чистая и безопасная реализация ---
-        return;
+    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)
+    if (!lp || !lp->handle().valid() || lp->getHealth() <= 0) return;
-        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;
     }
-    if (!silentActive)
+    int shotsFired = lp ? lp->getShotsFired() : 0;
-        return;
+    shotCount = shotsFired;
-
+    // --- Сброс флагов при новом нажатии ---
-    Vector_t localEye = GetEntityEyePos(lp);
+    if (silentActive && !prevSilentState) {
-    // --- Исправленный доступ к углам ---
+        targetWasLost = false;
-    QAngle_t* curAngles = nullptr;
+        targetWasLockedThisPress = false;
-    if (pCmd && pCmd->csgoUserCmd.pBaseCmd && pCmd->csgoUserCmd.pBaseCmd->pViewAngles)
+    }
-        curAngles = &pCmd->csgoUserCmd.pBaseCmd->pViewAngles->angValue;
+    // --- Поиск цели ---
-    if (!curAngles)
+    if (silentActive && !lockedTarget) {
-        return;
+        if ((!targetWasLost && !targetWasLockedThisPress)) {
-
+            int nMaxHighestEntity = I::GameEntity->Instance->GetHighestEntityIndex();
-    // Поиск цели
             float bestFov = Config::silent_aim_fov;
             C_CSPlayerPawn* bestTarget = nullptr;
-    Vector_t bestTargetPos{};
+            QAngle_t bestAngle = { 0, 0, 0 };
-    for (int i = 1; i <= I::GameEntity->Instance->GetHighestEntityIndex(); ++i) {
+            for (int i = 1; i <= nMaxHighestEntity; i++) {
                 auto Entity = I::GameEntity->Instance->Get(i);
-        if (!Entity || !Entity->handle().valid())
+                if (!Entity) continue;
-            continue;
+                if (!Entity->handle().valid()) continue;
                 SchemaClassInfoData_t* _class = nullptr;
                 Entity->dump_class_info(&_class);
-        if (!_class || HASH(_class->szName) != HASH("C_CSPlayerPawn"))
+                if (!_class) continue;
-            continue;
+                const uint32_t hash = HASH(_class->szName);
+                if (hash == HASH("C_CSPlayerPawn")) {
                     C_CSPlayerPawn* pawn = (C_CSPlayerPawn*)Entity;
-        if (!pawn || pawn->get_entity_by_handle() == lp->get_entity_by_handle() || pawn->getHealth() <= 0)
+                    if (!pawn) continue;
-            continue;
+                    if (pawn->get_entity_by_handle() == lp->get_entity_by_handle()) continue;
-        if (Config::team_check && pawn->getTeam() == lp->getTeam())
+                    if (pawn->getHealth() <= 0) continue;
-            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 :
+                    // --- Выбор кости для silent aim ---
-                                                        Config::silent_aim_bone == Config::BONE_NECK ? BONE_INDEX_NECK :
+                    Vector_t target_pos;
-                                                        Config::silent_aim_bone == Config::BONE_BODY ? BONE_INDEX_BODY :
+                    switch (Config::silent_aim_bone) {
-                                                        BONE_INDEX_HEAD);
+                    case Config::BONE_HEAD:
-        QAngle_t angle = CalcAngles(targetPos, localEye);
+                        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(*curAngles, angle);
+                    float fov = GetFov(*cur, angle);
-        if (!std::isfinite(fov) || fov > bestFov)
+                    if (!std::isfinite(fov) || fov > bestFov) continue;
-            continue;
                     bestFov = fov;
                     bestTarget = pawn;
-        bestTargetPos = targetPos;
+                    bestAngle = angle;
                 }
-    if (!bestTarget)
+            }
+            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;
-
+        }
-    QAngle_t aimAngle = CalcAngles(bestTargetPos, localEye);
+        // --- Выбор кости для silent aim ---
-    aimAngle.x *= -1.f;
+        Vector_t target_pos;
-    aimAngle.y += 180.f;
+        switch (Config::silent_aim_bone) {
-
+        case Config::BONE_HEAD:
-    // Установить угол для всех сабтиков
+            target_pos = GetBonePosition(lockedTarget, BONE_INDEX_HEAD); break;
-    pCmd->SetSubTickAngle(aimAngle);
+        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

@@ -4,4 +4,3 @@
 
 void Aimbot();
 void SilentAimbot(CUserCmd* pCmd);
-void Ver2Aimbot(CUserCmd* pCmd);

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

@@ -38,13 +38,11 @@ void* __fastcall H::hkLevelInit(void* pClientModeShared, const char* szNewMap) {
 	return LevelInit.GetOriginal()(pClientModeShared, szNewMap);
 }
 
-bool __fastcall H::hkCreateMove(void* pInput, int nSlot, CUserCmd* pCmd) {
+bool __fastcall H::hkCreateMove(void* pInput, int nSlot, void* pCmd) {
-    SilentAimbot(pCmd);
+    //Aimbot();
-	//Ver2Aimbot(pCmd);
+    SilentAimbot(reinterpret_cast<CUserCmd*>(pCmd));
     Triggerbot();
-
     return CreateMove.GetOriginal()(pInput, nSlot, pCmd);
-		// return CreateMove.GetOriginal()(pInput, edx, nSlot, pCmd);
 }
 
 void H::Hooks::init() {

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

@@ -1,5 +1,4 @@
 #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"
@@ -17,8 +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, void* edx, int nSlot, CUserCmd* pCmd);
+	bool __fastcall hkCreateMove(void* pInput, int nSlot, void* pCmd);
-	bool __fastcall hkCreateMove(void* pInput, int nSlot, CUserCmd* pCmd);
 	inline float g_flActiveFov;
 	float hkGetRenderFov(void* rcx);
 

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

@@ -209,7 +209,6 @@ void Menu::render() {
             keybind.menuButton(Config::silent_aim_key);
             ImGui::Checkbox("Always On##SilentAim", &Config::always_on_silent_aim);
             ImGui::Checkbox("Shooter After Aim##Silent", &Config::silent_shooterAfterAim); // Новый чекбокс
-            ImGui::Checkbox("Rage mode##Silent", &Config::silent_rage); // Новый чекбокс
             ImGui::SliderFloat("Smooth##SilentAim", &Config::silent_aim_smooth_slider, 0.f, 10.f, "%.2f");
             Config::silent_aim_smooth = Config::silent_aim_smooth_slider; // Применяем значение ползунка к логике
             ImGui::SliderFloat("Silent Aim FOV", &Config::silent_aim_fov, 1.f, 180.f, "%1.0f");