kal

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

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

@@ -15,6 +15,7 @@
 #include <Psapi.h>
 #include "../../menu/hud.h"
 #include "../../menu/menu.h"
+#include <iostream>
 
 // Адреса из дампа (актуально для 2024-07-18)
 #define DW_SENSITIVITY 0x1A6A9D8
@@ -195,7 +196,8 @@ 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) {
@@ -204,7 +206,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 };
 			}
 			angle.z = 0.f;
@@ -224,7 +227,8 @@ void Aimbot() {
 				angle = cur + delta * (1.f / smooth);
 				angle = angle.Normalize();
 				*viewangles = angle;
-            } else {
+			}
+			else {
 				*viewangles = angle;
 			}
 		}
@@ -312,7 +316,8 @@ 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) {
@@ -321,7 +326,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 };
 			}
 			angle.z = 0.f;
@@ -340,7 +346,8 @@ void Aimbot() {
 				angle = cur + delta * (1.f / smooth);
 				angle = angle.Normalize();
 				*viewangles = angle;
-            } else {
+			}
+			else {
 				*viewangles = angle;
 			}
 		}
@@ -390,64 +397,41 @@ void Aimbot() {
 	prevAimbotState = aimbotActive;
 }
 
-//void SilentAimbot(CUserCmd* pCmd) {
+void Ver2Aimbot(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);
-//    QAngle_t* cur = (QAngle_t*)(modules.getModule("client") + 0x1A78650);
+	//// Получаем viewangles только из CUserCmd!
+	//QAngle_t* cur = nullptr;
+	//if (pCmd->csgoUserCmd.pBaseCmd && pCmd->csgoUserCmd.pBaseCmd->pViewAngles) {
+	//	cur = &pCmd->csgoUserCmd.pBaseCmd->pViewAngles->angValue;
+	//}
 	//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();
+	//	targetWasLost = false;
-//        float bestFov = Config::aimbot_fov;
+	//	targetWasLockedThisPress = false;
-//        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) {
+	//	if (Config::silent_rage || (!targetWasLost && !targetWasLockedThisPress)) {
 	//		int nMaxHighestEntity = I::GameEntity->Instance->GetHighestEntityIndex();
-//        float bestFov = Config::aimbot_fov;
+	//		float bestFov = Config::silent_aim_fov;
 	//		C_CSPlayerPawn* bestTarget = nullptr;
 	//		QAngle_t bestAngle = { 0, 0, 0 };
 	//		for (int i = 1; i <= nMaxHighestEntity; i++) {
@@ -464,7 +448,19 @@ void Aimbot() {
 	//				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);
+	//				// --- Выбор кости для 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;
@@ -477,17 +473,20 @@ void Aimbot() {
 	//		}
 	//		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 ||
@@ -495,24 +494,26 @@ void Aimbot() {
 	//		(Config::team_check && lockedTarget->getTeam() == lp->getTeam())) {
 	//		lockedTarget = nullptr;
 	//		last_punch_angle = { 0,0,0 };
+	//		targetWasLost = true;
 	//		prevSilentState = silentActive;
 	//		return;
 	//	}
-//        Vector_t target_pos = GetAimbotTargetPos(lockedTarget, lep, *cur);
+	//	// --- Выбор кости для 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;
-//        //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();
@@ -523,131 +524,84 @@ void Aimbot() {
 	//	*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) {
-    // --- Silent Aim: чистая и безопасная реализация ---
+    if (!Config::silent_aim || !pCmd)
-    if (!Config::silent_aim || !pCmd) return;
+        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;
+    if (!lp || !lp->handle().valid() || lp->getHealth() <= 0)
-    Vector_t lep = GetEntityEyePos(lp);
+        return;
-    // Получаем 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;
+    if (!silentActive)
-    shotCount = shotsFired;
+        return;
-    // --- Сброс флагов при новом нажатии ---
+
-    if (silentActive && !prevSilentState) {
+    Vector_t localEye = GetEntityEyePos(lp);
-        targetWasLost = false;
+    // --- Исправленный доступ к углам ---
-        targetWasLockedThisPress = false;
+    QAngle_t* curAngles = nullptr;
-    }
+    if (pCmd && pCmd->csgoUserCmd.pBaseCmd && pCmd->csgoUserCmd.pBaseCmd->pViewAngles)
-    // --- Поиск цели ---
+        curAngles = &pCmd->csgoUserCmd.pBaseCmd->pViewAngles->angValue;
-    if (silentActive && !lockedTarget) {
+    if (!curAngles)
-        if ((!targetWasLost && !targetWasLockedThisPress)) {
+        return;
-            int nMaxHighestEntity = I::GameEntity->Instance->GetHighestEntityIndex();
+
+    // Поиск цели
     float bestFov = Config::silent_aim_fov;
     C_CSPlayerPawn* bestTarget = nullptr;
-            QAngle_t bestAngle = { 0, 0, 0 };
+    Vector_t bestTargetPos{};
-            for (int i = 1; i <= nMaxHighestEntity; i++) {
+    for (int i = 1; i <= I::GameEntity->Instance->GetHighestEntityIndex(); ++i) {
         auto Entity = I::GameEntity->Instance->Get(i);
-                if (!Entity) continue;
+        if (!Entity || !Entity->handle().valid())
-                if (!Entity->handle().valid()) continue;
+            continue;
         SchemaClassInfoData_t* _class = nullptr;
         Entity->dump_class_info(&_class);
-                if (!_class) continue;
+        if (!_class || HASH(_class->szName) != HASH("C_CSPlayerPawn"))
-                const uint32_t hash = HASH(_class->szName);
+            continue;
-                if (hash == HASH("C_CSPlayerPawn")) {
         C_CSPlayerPawn* pawn = (C_CSPlayerPawn*)Entity;
-                    if (!pawn) continue;
+        if (!pawn || pawn->get_entity_by_handle() == lp->get_entity_by_handle() || pawn->getHealth() <= 0)
-                    if (pawn->get_entity_by_handle() == lp->get_entity_by_handle()) continue;
+            continue;
-                    if (pawn->getHealth() <= 0) continue;
+        if (Config::team_check && pawn->getTeam() == lp->getTeam())
-                    if (Config::team_check && pawn->getTeam() == lp->getTeam()) continue;
+            continue;
-                    // --- Выбор кости для silent aim ---
+        Vector_t targetPos = GetBonePosition(pawn, Config::silent_aim_bone == Config::BONE_HEAD ? BONE_INDEX_HEAD :
-                    Vector_t target_pos;
+                                                        Config::silent_aim_bone == Config::BONE_NECK ? BONE_INDEX_NECK :
-                    switch (Config::silent_aim_bone) {
+                                                        Config::silent_aim_bone == Config::BONE_BODY ? BONE_INDEX_BODY :
-                    case Config::BONE_HEAD:
+                                                        BONE_INDEX_HEAD);
-                        target_pos = GetBonePosition(pawn, BONE_INDEX_HEAD); break;
+        QAngle_t angle = CalcAngles(targetPos, localEye);
-                    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);
+        float fov = GetFov(*curAngles, angle);
-                    if (!std::isfinite(fov) || fov > bestFov) continue;
+        if (!std::isfinite(fov) || fov > bestFov)
+            continue;
         bestFov = fov;
         bestTarget = pawn;
-                    bestAngle = angle;
+        bestTargetPos = targetPos;
     }
-            }
+    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;
-        }
+
-        // --- Выбор кости для silent aim ---
+    QAngle_t aimAngle = CalcAngles(bestTargetPos, localEye);
-        Vector_t target_pos;
+    aimAngle.x *= -1.f;
-        switch (Config::silent_aim_bone) {
+    aimAngle.y += 180.f;
-        case Config::BONE_HEAD:
+
-            target_pos = GetBonePosition(lockedTarget, BONE_INDEX_HEAD); break;
+    // Установить угол для всех сабтиков
-        case Config::BONE_NECK:
+    pCmd->SetSubTickAngle(aimAngle);
-            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,3 +4,4 @@
 
 void Aimbot();
 void SilentAimbot(CUserCmd* pCmd);
+void Ver2Aimbot(CUserCmd* pCmd);

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

@@ -38,11 +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) {
+bool __fastcall H::hkCreateMove(void* pInput, int nSlot, CUserCmd* pCmd) {
-    //Aimbot();
+    SilentAimbot(pCmd);
-    SilentAimbot(reinterpret_cast<CUserCmd*>(pCmd));
+	//Ver2Aimbot(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,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,7 +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, int nSlot, void* pCmd);
+	// 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);
 

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

@@ -209,6 +209,7 @@ 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");