From 20680a57f1526960cf1ba68357dd5402a84adec1 Mon Sep 17 00:00:00 2001
From: Half People <56476339+Half-People@users.noreply.github.com>
Date: Sun, 5 Nov 2023 05:42:13 +0800
Subject: [PATCH] Add files via upload
---
HPCS2/HPCS2.sln | 31 +
HPCS2/HPCS2/HPCS2.vcxproj | 172 +
HPCS2/HPCS2/HPCS2.vcxproj.filters | 87 +
HPCS2/HPCS2/HPCS2.vcxproj.user | 4 +
HPCS2/HPCS2/Source.cpp | 1003 +++
HPCS2/HPCS2/handle_hijack.hpp | 287 +
HPCS2/HPCS2/memory.cpp | 255 +
HPCS2/HPCS2/memory.hpp | 124 +
HPCS2/HPCS2/offset/animationsystem.dll.hpp | 2579 ++++++
HPCS2/HPCS2/offset/client.dll.hpp | 4159 ++++++++++
HPCS2/HPCS2/offset/engine2.dll.hpp | 244 +
HPCS2/HPCS2/offset/host.dll.hpp | 16 +
HPCS2/HPCS2/offset/interfaces.hpp | 244 +
HPCS2/HPCS2/offset/materialsystem2.dll.hpp | 115 +
HPCS2/HPCS2/offset/networksystem.dll.hpp | 12 +
HPCS2/HPCS2/offset/offsets.hpp | 49 +
HPCS2/HPCS2/offset/particles.dll.hpp | 4037 ++++++++++
HPCS2/HPCS2/offset/pulse_system.dll.hpp | 352 +
HPCS2/HPCS2/offset/rendersystemdx11.dll.hpp | 29 +
HPCS2/HPCS2/offset/resourcesystem.dll.hpp | 213 +
HPCS2/HPCS2/offset/scenesystem.dll.hpp | 61 +
HPCS2/HPCS2/offset/schemasystem.dll.hpp | 57 +
HPCS2/HPCS2/offset/server.dll.hpp | 7168 +++++++++++++++++
HPCS2/HPCS2/offset/soundsystem.dll.hpp | 313 +
HPCS2/HPCS2/offset/vphysics2.dll.hpp | 755 ++
HPCS2/HPCS2/offset/worldrenderer.dll.hpp | 233 +
.../x64/Release/HPCS2.Build.CppClean.log | 13 +
HPCS2/HPCS2/x64/Release/HPCS2.exe.recipe | 11 +
HPCS2/HPCS2/x64/Release/HPCS2.iobj | Bin 0 -> 990789 bytes
HPCS2/HPCS2/x64/Release/HPCS2.ipdb | Bin 0 -> 323296 bytes
HPCS2/HPCS2/x64/Release/HPCS2.log | 41 +
.../x64/Release/HPCS2.tlog/CL.command.1.tlog | Bin 0 -> 1534 bytes
.../x64/Release/HPCS2.tlog/CL.read.1.tlog | Bin 0 -> 73830 bytes
.../x64/Release/HPCS2.tlog/CL.write.1.tlog | Bin 0 -> 1244 bytes
.../Release/HPCS2.tlog/HPCS2.lastbuildstate | 2 +
.../Release/HPCS2.tlog/link.command.1.tlog | 1 +
.../x64/Release/HPCS2.tlog/link.read.1.tlog | 1 +
.../x64/Release/HPCS2.tlog/link.write.1.tlog | 1 +
.../x64/Release/HPCS2.tlog/unsuccessfulbuild | 0
.../HPCS2.vcxproj.FileListAbsolute.txt | 0
HPCS2/HPCS2/x64/Release/Source.obj | Bin 0 -> 2666533 bytes
HPCS2/HPCS2/x64/Release/memory.obj | Bin 0 -> 1379325 bytes
HPCS2/HPCS2/x64/Release/vc142.pdb | Bin 0 -> 905216 bytes
HPCS2/x64/Release/HPCS2.exe | Bin 0 -> 46592 bytes
HPCS2/x64/Release/HPCS2.pdb | Bin 0 -> 1601536 bytes
HPCS2/x64/Release/aaa.exe | Bin 0 -> 47616 bytes
46 files changed, 22669 insertions(+)
create mode 100644 HPCS2/HPCS2.sln
create mode 100644 HPCS2/HPCS2/HPCS2.vcxproj
create mode 100644 HPCS2/HPCS2/HPCS2.vcxproj.filters
create mode 100644 HPCS2/HPCS2/HPCS2.vcxproj.user
create mode 100644 HPCS2/HPCS2/Source.cpp
create mode 100644 HPCS2/HPCS2/handle_hijack.hpp
create mode 100644 HPCS2/HPCS2/memory.cpp
create mode 100644 HPCS2/HPCS2/memory.hpp
create mode 100644 HPCS2/HPCS2/offset/animationsystem.dll.hpp
create mode 100644 HPCS2/HPCS2/offset/client.dll.hpp
create mode 100644 HPCS2/HPCS2/offset/engine2.dll.hpp
create mode 100644 HPCS2/HPCS2/offset/host.dll.hpp
create mode 100644 HPCS2/HPCS2/offset/interfaces.hpp
create mode 100644 HPCS2/HPCS2/offset/materialsystem2.dll.hpp
create mode 100644 HPCS2/HPCS2/offset/networksystem.dll.hpp
create mode 100644 HPCS2/HPCS2/offset/offsets.hpp
create mode 100644 HPCS2/HPCS2/offset/particles.dll.hpp
create mode 100644 HPCS2/HPCS2/offset/pulse_system.dll.hpp
create mode 100644 HPCS2/HPCS2/offset/rendersystemdx11.dll.hpp
create mode 100644 HPCS2/HPCS2/offset/resourcesystem.dll.hpp
create mode 100644 HPCS2/HPCS2/offset/scenesystem.dll.hpp
create mode 100644 HPCS2/HPCS2/offset/schemasystem.dll.hpp
create mode 100644 HPCS2/HPCS2/offset/server.dll.hpp
create mode 100644 HPCS2/HPCS2/offset/soundsystem.dll.hpp
create mode 100644 HPCS2/HPCS2/offset/vphysics2.dll.hpp
create mode 100644 HPCS2/HPCS2/offset/worldrenderer.dll.hpp
create mode 100644 HPCS2/HPCS2/x64/Release/HPCS2.Build.CppClean.log
create mode 100644 HPCS2/HPCS2/x64/Release/HPCS2.exe.recipe
create mode 100644 HPCS2/HPCS2/x64/Release/HPCS2.iobj
create mode 100644 HPCS2/HPCS2/x64/Release/HPCS2.ipdb
create mode 100644 HPCS2/HPCS2/x64/Release/HPCS2.log
create mode 100644 HPCS2/HPCS2/x64/Release/HPCS2.tlog/CL.command.1.tlog
create mode 100644 HPCS2/HPCS2/x64/Release/HPCS2.tlog/CL.read.1.tlog
create mode 100644 HPCS2/HPCS2/x64/Release/HPCS2.tlog/CL.write.1.tlog
create mode 100644 HPCS2/HPCS2/x64/Release/HPCS2.tlog/HPCS2.lastbuildstate
create mode 100644 HPCS2/HPCS2/x64/Release/HPCS2.tlog/link.command.1.tlog
create mode 100644 HPCS2/HPCS2/x64/Release/HPCS2.tlog/link.read.1.tlog
create mode 100644 HPCS2/HPCS2/x64/Release/HPCS2.tlog/link.write.1.tlog
create mode 100644 HPCS2/HPCS2/x64/Release/HPCS2.tlog/unsuccessfulbuild
create mode 100644 HPCS2/HPCS2/x64/Release/HPCS2.vcxproj.FileListAbsolute.txt
create mode 100644 HPCS2/HPCS2/x64/Release/Source.obj
create mode 100644 HPCS2/HPCS2/x64/Release/memory.obj
create mode 100644 HPCS2/HPCS2/x64/Release/vc142.pdb
create mode 100644 HPCS2/x64/Release/HPCS2.exe
create mode 100644 HPCS2/x64/Release/HPCS2.pdb
create mode 100644 HPCS2/x64/Release/aaa.exe
diff --git a/HPCS2/HPCS2.sln b/HPCS2/HPCS2.sln
new file mode 100644
index 0000000..4143814
--- /dev/null
+++ b/HPCS2/HPCS2.sln
@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.32106.194
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "HPCS2", "HPCS2\HPCS2.vcxproj", "{9A02F163-AEBD-431B-8E0E-53C246BC27A8}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|x64 = Debug|x64
+ Debug|x86 = Debug|x86
+ Release|x64 = Release|x64
+ Release|x86 = Release|x86
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {9A02F163-AEBD-431B-8E0E-53C246BC27A8}.Debug|x64.ActiveCfg = Debug|x64
+ {9A02F163-AEBD-431B-8E0E-53C246BC27A8}.Debug|x64.Build.0 = Debug|x64
+ {9A02F163-AEBD-431B-8E0E-53C246BC27A8}.Debug|x86.ActiveCfg = Debug|Win32
+ {9A02F163-AEBD-431B-8E0E-53C246BC27A8}.Debug|x86.Build.0 = Debug|Win32
+ {9A02F163-AEBD-431B-8E0E-53C246BC27A8}.Release|x64.ActiveCfg = Release|x64
+ {9A02F163-AEBD-431B-8E0E-53C246BC27A8}.Release|x64.Build.0 = Release|x64
+ {9A02F163-AEBD-431B-8E0E-53C246BC27A8}.Release|x86.ActiveCfg = Release|Win32
+ {9A02F163-AEBD-431B-8E0E-53C246BC27A8}.Release|x86.Build.0 = Release|Win32
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+ GlobalSection(ExtensibilityGlobals) = postSolution
+ SolutionGuid = {BC3F94B4-62FD-46DF-891E-E98FB39ADFF2}
+ EndGlobalSection
+EndGlobal
diff --git a/HPCS2/HPCS2/HPCS2.vcxproj b/HPCS2/HPCS2/HPCS2.vcxproj
new file mode 100644
index 0000000..4d30e07
--- /dev/null
+++ b/HPCS2/HPCS2/HPCS2.vcxproj
@@ -0,0 +1,172 @@
+
+
+
+
+ Debug
+ Win32
+
+
+ Release
+ Win32
+
+
+ Debug
+ x64
+
+
+ Release
+ x64
+
+
+
+ 16.0
+ Win32Proj
+ {9a02f163-aebd-431b-8e0e-53c246bc27a8}
+ HPCS2
+ 10.0
+
+
+
+ Application
+ true
+ v142
+ Unicode
+
+
+ Application
+ false
+ v142
+ true
+ Unicode
+
+
+ Application
+ true
+ v142
+ Unicode
+
+
+ Application
+ false
+ v142
+ true
+ Unicode
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ true
+
+
+ false
+
+
+ true
+
+
+ false
+
+
+
+ Level3
+ true
+ WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)
+ true
+
+
+ Console
+ true
+
+
+
+
+ Level3
+ true
+ true
+ true
+ WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)
+ true
+
+
+ Console
+ true
+ true
+ true
+
+
+
+
+ Level3
+ true
+ _DEBUG;_CONSOLE;%(PreprocessorDefinitions)
+ true
+
+
+ Console
+ true
+
+
+
+
+ Level3
+ true
+ true
+ true
+ NDEBUG;_CONSOLE;%(PreprocessorDefinitions)
+ true
+ stdcpp20
+
+
+ Console
+ true
+ true
+ true
+ RequireAdministrator
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/HPCS2/HPCS2/HPCS2.vcxproj.filters b/HPCS2/HPCS2/HPCS2.vcxproj.filters
new file mode 100644
index 0000000..d210227
--- /dev/null
+++ b/HPCS2/HPCS2/HPCS2.vcxproj.filters
@@ -0,0 +1,87 @@
+
+
+
+
+ {4FC737F1-C7A5-4376-A066-2A32D752A2FF}
+ cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx
+
+
+ {93995380-89BD-4b04-88EB-625FBE52EBFB}
+ h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd
+
+
+ {67DA6AB6-F800-4c08-8B7A-83BB121AAD01}
+ rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms
+
+
+
+
+ 資源檔
+
+
+ 來源檔案
+
+
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 標頭檔
+
+
+ 來源檔案
+
+
+ 來源檔案
+
+
+
\ No newline at end of file
diff --git a/HPCS2/HPCS2/HPCS2.vcxproj.user b/HPCS2/HPCS2/HPCS2.vcxproj.user
new file mode 100644
index 0000000..0f14913
--- /dev/null
+++ b/HPCS2/HPCS2/HPCS2.vcxproj.user
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/HPCS2/HPCS2/Source.cpp b/HPCS2/HPCS2/Source.cpp
new file mode 100644
index 0000000..0dcc715
--- /dev/null
+++ b/HPCS2/HPCS2/Source.cpp
@@ -0,0 +1,1003 @@
+
+#include "offset/offsets.hpp"
+#include "offset/client.dll.hpp"
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include "memory.hpp"
+#define render_distance -1
+#define show_extra true
+#define flag_render_distance 200
+#define TextSize 15
+#define BonesColor RGB(200, 200, 200)
+#define FOV 40//2
+HANDLE cs2_process_handle;
+ProcessModule cs2_module_client;
+ProcessModule base_engine;
+
+std::shared_ptr process;
+struct C_UTL_VECTOR
+{
+ DWORD_PTR count = 0;
+ DWORD_PTR data = 0;
+};
+namespace render
+{
+ void DrawBorderBox(HDC hdc, int x, int y, int w, int h, COLORREF borderColor)
+ {
+ HBRUSH hBorderBrush = CreateSolidBrush(borderColor);
+ HBRUSH hOldBrush = (HBRUSH)SelectObject(hdc, hBorderBrush);
+
+ RECT rect = { x, y, x + w, y + h };
+ FrameRect(hdc, &rect, hBorderBrush);
+
+ SelectObject(hdc, hOldBrush); // Restore the original brush
+ DeleteObject(hBorderBrush); // Delete the temporary brush
+ }
+
+ void DrawFilledBox(HDC hdc, int x, int y, int width, int height, COLORREF color)
+ {
+ HBRUSH hBrush = CreateSolidBrush(color);
+ RECT rect = { x, y, x + width, y + height };
+ FillRect(hdc, &rect, hBrush);
+ DeleteObject(hBrush);
+ }
+
+
+
+ void SetTextSize(HDC hdc, int textSize)
+ {
+ LOGFONT lf;
+ HFONT hFont, hOldFont;
+
+ // Initialize the LOGFONT structure
+ ZeroMemory(&lf, sizeof(LOGFONT));
+ lf.lfHeight = -textSize; // Set the desired text height (negative for height)
+ lf.lfWeight = FW_NORMAL; // Set the font weight (e.g., FW_NORMAL for normal)
+ lf.lfQuality = ANTIALIASED_QUALITY; // Enable anti-aliasing
+
+ // Create a new font based on the LOGFONT structure
+ hFont = CreateFontIndirect(&lf);
+
+ // Select the new font into the device context and save the old font
+ hOldFont = (HFONT)SelectObject(hdc, hFont);
+
+ // Clean up the old font (when done using it)
+ DeleteObject(hOldFont);
+ }
+
+ void RenderLine(HDC hdc,float p1x,float p1y,float p2x,float p2y, COLORREF borderColor)
+ {
+ HPEN hPen = CreatePen(PS_DASH, 2, borderColor); // ʹúɫΪ1أʵʽĻ
+ SelectObject(hdc, hPen);
+ MoveToEx(hdc, (int)p1x, (int)p1y, (LPPOINT)NULL);
+ LineTo(hdc, (int)p2x, (int)p2y);
+ DeleteObject(hPen);
+ }
+
+ void RenderText(HDC hdc, int x, int y, const char* text, COLORREF textColor, int textSize)
+ {
+ SetTextSize(hdc, textSize);
+ SetTextColor(hdc, textColor);
+
+ int len = MultiByteToWideChar(CP_UTF8, 0, text, -1, NULL, 0);
+ wchar_t* wide_text = new wchar_t[len];
+ MultiByteToWideChar(CP_UTF8, 0, text, -1, wide_text, len);
+
+ TextOutW(hdc, x, y, wide_text, len - 1);
+
+ delete[] wide_text;
+ }
+}
+namespace g {
+ inline HDC hdcBuffer = NULL;
+ inline HBITMAP hbmBuffer = NULL;
+
+ RECT gameBounds;
+}
+enum bones : int {
+ head = 6,
+ neck = 5,
+ chest = 4,
+ shoulderRight = 8,
+ shoulderLeft = 13,
+ elbowRight = 9,
+ elbowLeft = 14,
+ handRight = 11,
+ handLeft = 16,
+ crotch = 0,
+ kneeRight = 23,
+ kneeLeft = 26,
+ ankleRight = 24,
+ ankleLeft = 27,
+};
+
+
+inline namespace boneGroups {
+ inline std::vector mid = { bones::head,bones::neck,bones::chest,bones::crotch };
+ inline std::vector leftArm = { bones::neck,bones::shoulderLeft,bones::elbowLeft,bones::handLeft };
+ inline std::vector righttArm = { bones::neck,bones::shoulderRight,bones::elbowRight,bones::handRight };
+ inline std::vector leftLeg = { bones::crotch,bones::kneeLeft,bones::ankleLeft };
+ inline std::vector rightLeg = { bones::crotch,bones::kneeRight,bones::ankleRight };
+ inline std::vector> allGroups = { mid,leftArm,righttArm,leftLeg,rightLeg };
+}
+void loop();
+
+void FunctionT();
+
+LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ switch (message)
+ {
+ case WM_CREATE:
+ {
+ g::hdcBuffer = CreateCompatibleDC(NULL);
+ g::hbmBuffer = CreateCompatibleBitmap(GetDC(hWnd), g::gameBounds.right, g::gameBounds.bottom);
+ SelectObject(g::hdcBuffer, g::hbmBuffer);
+
+ SetWindowLong(hWnd, GWL_EXSTYLE, GetWindowLong(hWnd, GWL_EXSTYLE) | WS_EX_LAYERED);
+
+ SetLayeredWindowAttributes(hWnd, RGB(255, 255, 255), 0, LWA_COLORKEY);
+
+ //std::cout << "[overlay] Window created successfully" << std::endl;
+ Beep(500, 100);
+ break;
+ }
+ case WM_ERASEBKGND: // We handle this message to avoid flickering
+ return TRUE;
+ case WM_PAINT:
+ {
+ PAINTSTRUCT ps;
+ HDC hdc = BeginPaint(hWnd, &ps);
+
+ //DOUBLE BUFFERING
+ FillRect(g::hdcBuffer, &ps.rcPaint, (HBRUSH)GetStockObject(WHITE_BRUSH));
+
+
+ if (GetForegroundWindow() == process->hwnd_) {
+ //render::RenderText(g::hdcBuffer, 10, 10, "cs2 | ESP", RGB(75, 175, 175), 15);
+ loop();
+ }
+
+ BitBlt(hdc, 0, 0, g::gameBounds.right, g::gameBounds.bottom, g::hdcBuffer, 0, 0, SRCCOPY);
+
+ EndPaint(hWnd, &ps);
+ InvalidateRect(hWnd, NULL, TRUE);
+ break;
+ }
+ case WM_DESTROY:
+ DeleteDC(g::hdcBuffer);
+ DeleteObject(g::hbmBuffer);
+
+ PostQuitMessage(0);
+ break;
+ default:
+ return DefWindowProc(hWnd, message, wParam, lParam);
+ }
+ return 0;
+}
+
+
+struct view_matrix_t {
+ float* operator[ ](int index) {
+ return matrix[index];
+ }
+
+ float matrix[4][4];
+};
+
+
+struct Vector3
+{
+ // constructor
+ constexpr Vector3(
+ const float x = 0.f,
+ const float y = 0.f,
+ const float z = 0.f) noexcept :
+ x(x), y(y), z(z) { }
+
+ // operator overloads
+ constexpr const Vector3& operator-(const Vector3& other) const noexcept
+ {
+ return Vector3{ x - other.x, y - other.y, z - other.z };
+ }
+
+ constexpr const Vector3& operator+(const Vector3& other) const noexcept
+ {
+ return Vector3{ x + other.x, y + other.y, z + other.z };
+ }
+
+ constexpr const Vector3& operator/(const float factor) const noexcept
+ {
+ return Vector3{ x / factor, y / factor, z / factor };
+ }
+
+ constexpr const Vector3& operator*(const float factor) const noexcept
+ {
+ return Vector3{ x * factor, y * factor, z * factor };
+ }
+
+ constexpr const bool operator>(const Vector3& other) const noexcept {
+ return x > other.x && y > other.y && z > other.z;
+ }
+
+ constexpr const bool operator>=(const Vector3& other) const noexcept {
+ return x >= other.x && y >= other.y && z >= other.z;
+ }
+
+ constexpr const bool operator<(const Vector3& other) const noexcept {
+ return x < other.x&& y < other.y&& z < other.z;
+ }
+
+ constexpr const bool operator<=(const Vector3& other) const noexcept {
+ return x <= other.x && y <= other.y && z <= other.z;
+ }
+
+ constexpr const Vector3& ToAngle() const noexcept
+ {
+ return Vector3{
+ std::atan2(-z, std::hypot(x, y)) * (180.0f / std::numbers::pi_v),
+ std::atan2(y, x) * (180.0f / std::numbers::pi_v),
+ 0.0f
+ };
+ }
+
+ void Print()
+ {
+ std::cout << "\n x : " << x << " y :" << y << "z :" << z;
+ return;
+ }
+
+ constexpr const bool IsZero() const noexcept
+ {
+ return x == 0.f && y == 0.f && z == 0.f;
+ }
+
+ float length() const {
+ return std::sqrt(x * x + y * y + z * z);
+ }
+
+ float length2d() const {
+ return std::sqrt(x * x + y * y);
+ }
+
+
+
+ Vector3 world_to_screen(view_matrix_t matrix) const {
+ float _x = matrix[0][0] * x + matrix[0][1] * y + matrix[0][2] * z + matrix[0][3];
+ float _y = matrix[1][0] * x + matrix[1][1] * y + matrix[1][2] * z + matrix[1][3];
+ float w = matrix[3][0] * x + matrix[3][1] * y + matrix[3][2] * z + matrix[3][3];
+
+
+ float inv_w = 1.f / w;
+ _x *= inv_w;
+ _y *= inv_w;
+
+ float x = g::gameBounds.right * .5f;
+ float y = g::gameBounds.bottom * .5f;
+
+ x += 0.5f * _x * g::gameBounds.right + 0.5f;
+ y -= 0.5f * _y * g::gameBounds.bottom + 0.5f;
+
+ return { x, y, w };
+ }
+
+
+ float calculate_distance(const Vector3& point) const {
+ float dx = point.x - x;
+ float dy = point.y - y;
+ float dz = point.z - z;
+
+ return std::sqrt(dx * dx + dy * dy + dz * dz);
+ }
+
+
+ // struct data
+ float x, y, z;
+};
+
+inline constexpr Vector3 CalculateAngle(
+ const Vector3& localPosition,
+ const Vector3& enemyPosition,
+ const Vector3& viewAngles) noexcept
+{
+ return ((enemyPosition - localPosition).ToAngle() - viewAngles);
+};
+
+
+inline Vector3 clampAngles(Vector3 angles) {
+ if (angles.x > 89.0f && angles.x <= 180.0f) {
+ angles.x = 89.0f;
+ }
+
+ if (angles.x > 180.0f) {
+ angles.x -= 360.0f;
+ }
+
+ if (angles.x < -89.0f) {
+ angles.x = -89.0f;
+ }
+
+ if (angles.y > 180.0f) {
+ angles.y -= 360.0f;
+ }
+
+ if (angles.y < -180.0f) {
+ angles.y += 360.0f;
+ }
+ angles.z = 0;
+
+ return angles;
+};
+
+
+inline Vector3 normalizeAngles(Vector3 angle) {
+ while (angle.x > 180.f)
+ angle.x -= 360.0f;
+
+ while (angle.x < -180.0f)
+ angle.x += 360.0f;
+
+ while (angle.y > 180.0f)
+ angle.y -= 360.0f;
+
+ while (angle.y < -180.0f)
+ angle.y += 360.0f;
+
+ return angle;
+};
+
+
+
+inline Vector3 calculateBestAngle(Vector3 angle,float& configFov) {
+ Vector3 newAngle;
+
+ float fov = std::hypot(angle.x, angle.y);
+
+ if (fov < configFov) {
+ configFov = fov;
+ newAngle = angle;
+ }
+ return newAngle;
+}
+
+
+void aimBot(C_UTL_VECTOR aimPunchCache, int getShotsFired,Vector3& cameraPos,Vector3& viewAngles,float& fov, bool isHot,Vector3 baseViewAngles, DWORD_PTR baseViewAnglesAddy, uintptr_t boneArray) {
+ Vector3 aimPos;
+ Vector3 newAngle;
+
+ aimPos = process->read(boneArray + 6/*head*/* 32);
+// aimPos.Print();
+ const Vector3 angle = CalculateAngle(cameraPos, aimPos, viewAngles );
+ newAngle = calculateBestAngle(angle, fov/*fov*/);
+ newAngle = clampAngles(newAngle);
+
+ newAngle.x = newAngle.x / 1.f;//smoothing
+ newAngle.y = newAngle.y / 1.f;//smoothing
+
+ if (newAngle.IsZero()) {
+ return;
+ }
+
+ if (isHot) {
+ if (GetAsyncKeyState(VK_SHIFT)&0x8000) {
+
+ Vector3 aimPunchAngle = process->read(aimPunchCache.data + (aimPunchCache.count - 1) * sizeof(Vector3));
+
+ if (getShotsFired > 1) {
+ newAngle.x = newAngle.x - aimPunchAngle.x * 2.f;
+ newAngle.y = newAngle.y - aimPunchAngle.y * 2.f;
+ //newAngle = clampAngles(newAngle);
+
+ process->write(baseViewAnglesAddy, newAngle + baseViewAngles);
+ }
+ else
+ process->write(baseViewAnglesAddy, baseViewAngles + newAngle);
+ }
+ }
+ else {
+ process->write(baseViewAnglesAddy, baseViewAngles + newAngle);
+ }
+}
+
+void recoilControl(Vector3& ViewAngle, C_UTL_VECTOR aimPunchCache,int getShotsFired , DWORD_PTR baseViewAnglesAddy) {
+ static Vector3 oldPunch;
+ Vector3 aimPunchAngle = process->read(aimPunchCache.data + (aimPunchCache.count - 1) * sizeof(Vector3));
+
+ if (getShotsFired > 1) {
+ Vector3 recoilVector = {
+ ViewAngle.x + oldPunch.x - aimPunchAngle.x * 2.f,
+ ViewAngle.y + oldPunch.y - aimPunchAngle.y * 2.f
+ };
+ recoilVector = clampAngles(recoilVector);
+
+ process->write(baseViewAnglesAddy, recoilVector);
+
+
+ }
+
+ oldPunch.x = aimPunchAngle.x * 2.f;
+ oldPunch.y = aimPunchAngle.y * 2.f;
+}
+
+int main(int argc, char* argv[])
+{
+ SetConsoleTitleW(L"cs2-HalfPeople-esp");
+
+ process = std::make_shared();
+
+
+ while (!process->AttachProcessHj("cs2.exe"))
+ std::this_thread::sleep_for(std::chrono::seconds(1));
+
+
+ do {
+ cs2_module_client = process->GetModule("client.dll");
+ base_engine = process->GetModule("engine2.dll");
+ if (cs2_module_client.base == 0 || base_engine.base == 0) {
+ std::this_thread::sleep_for(std::chrono::seconds(1));
+ std::cout << " Failed to find module client.dll/engine2.dll, waiting for the game to load it..." << std::endl;
+ }
+ } while (cs2_module_client.base == 0 || base_engine.base == 0);
+
+ const uintptr_t buildNumber = process->read(base_engine.base + engine2_dll::dwBuildNumber);
+ std::cout << "\n build number : " << buildNumber;
+
+ std::cout << " Make sure your game is in \"Full Screen Windowed\"" << std::endl;
+ while (GetForegroundWindow() != process->hwnd_) {
+ std::this_thread::sleep_for(std::chrono::seconds(1));
+ process->UpdateHWND();
+ ShowWindow(process->hwnd_, TRUE);
+ }
+ std::cout << "Creating window overlay" << std::endl;
+
+ WNDCLASSEXA wc = { 0 };
+ wc.cbSize = sizeof(WNDCLASSEXA);
+ wc.lpfnWndProc = WndProc;
+ wc.style = CS_HREDRAW | CS_VREDRAW;
+ wc.hbrBackground = WHITE_BRUSH;
+ wc.hInstance = reinterpret_cast(GetWindowLongA(process->hwnd_, (-6))); // GWL_HINSTANCE));
+ wc.lpszMenuName = " ";
+ wc.lpszClassName = " ";
+
+ RegisterClassExA(&wc);
+
+ GetClientRect(process->hwnd_, &g::gameBounds);
+
+ // Create the window
+ HINSTANCE hInstance = NULL;
+ HWND hWnd = CreateWindowExA(WS_EX_TRANSPARENT | WS_EX_TOPMOST | WS_EX_LAYERED | WS_EX_TOOLWINDOW, " ", "cs2-HalfPeople-esp", WS_POPUP,
+ g::gameBounds.left, g::gameBounds.top, g::gameBounds.right - g::gameBounds.left, g::gameBounds.bottom + g::gameBounds.left, NULL, NULL, hInstance, NULL); // NULL, NULL);
+
+ if (hWnd == NULL)
+ return 0;
+
+ SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+ ShowWindow(hWnd, TRUE);
+ //SetActiveWindow(hack::process->hwnd_);
+
+ // Message loop
+ MSG msg;
+ while (GetMessage(&msg, NULL, 0, 0))
+ {
+ std::thread T(FunctionT);
+ if (GetAsyncKeyState(VK_END) & 0x8000) break;
+
+ TranslateMessage(&msg);
+ DispatchMessage(&msg);
+
+ T.join();
+ //std::this_thread::sleep_for(std::chrono::milliseconds(1));
+ }
+
+
+ DeleteDC(g::hdcBuffer);
+ DeleteObject(g::hbmBuffer);
+
+ DestroyWindow(hWnd);
+
+ process->Close();
+
+
+ system("pause");
+
+ return 0;
+}
+uintptr_t localPlayer;
+int localTeam;
+uintptr_t entity_list;
+void loop()
+{
+ render::RenderText(g::hdcBuffer, 50, 50, "HalfPeople CSGO 2 GameHack Test", RGB(200, 200,200), 30);
+
+ const view_matrix_t view_matrix = process->read(cs2_module_client.base + client_dll::dwViewMatrix);
+ entity_list = process->read( cs2_module_client.base + client_dll::dwEntityList);
+
+ localPlayer = process->read( cs2_module_client.base + client_dll::dwLocalPlayerPawn);
+ if (!localPlayer)
+ return ;
+
+ localTeam = process->read( localPlayer + C_BaseEntity::m_iTeamNum);
+
+ int playerIndex = 0;
+ uintptr_t list_entry;
+
+
+ //Vector3 cameraPos = process->read( localPlayer + C_CSPlayerPawnBase::m_vecLastClipCameraPos);
+
+ //Vector3 viewAngles = process->read( localPlayer + C_CSPlayerPawnBase::m_angEyeAngles);
+
+ //Vector3 baseViewAngles = process->read( cs2_module_client.base + client_dll::dwViewAngles);
+
+ //float fov = 15;
+
+ const uintptr_t localList_entry2 = process->read(entity_list + 0x8 * ((localPlayer & 0x7FFF) >> 9) + 16);
+ const uintptr_t localpCSPlayerPawn = process->read(localList_entry2 + 120 * (localPlayer & 0x1FF));
+ if (!localpCSPlayerPawn)
+ return;
+ const uintptr_t localCGameSceneNode = process->read(localPlayer + C_BaseEntity::m_pGameSceneNode);
+ const Vector3 localOrigin = process->read(localCGameSceneNode + CGameSceneNode::m_vecOrigin);
+ bool c4IsPlanted = process->read(cs2_module_client.base +client_dll::dwPlantedC4 - 0x8);
+ if (c4IsPlanted)
+ {
+ const uintptr_t planted_c4 = process->read(process->read(cs2_module_client.base + client_dll::dwPlantedC4));
+
+ const uintptr_t c4Node = process->read(planted_c4 + C_BaseEntity::m_pGameSceneNode);
+
+ const Vector3 c4Origin = process->read(c4Node + CGameSceneNode::m_vecAbsOrigin);
+
+ const Vector3 c4ScreenPos = c4Origin.world_to_screen(view_matrix);
+
+ if (c4ScreenPos.z >= 0.01f) {
+ float c4Distance = localOrigin.calculate_distance(c4Origin);
+ float c4RoundedDistance = std::round(c4Distance / 500.f);
+
+ float height = 50 - c4RoundedDistance;
+ float width = height * 1.4f;
+
+ render::RenderLine(g::hdcBuffer, 0, 0, c4ScreenPos.x, c4ScreenPos.y, RGB(175, 75, 75));
+
+ render::DrawFilledBox(
+ g::hdcBuffer,
+ c4ScreenPos.x - (width / 2),
+ c4ScreenPos.y - (height / 2),
+ width,
+ height,
+ RGB(175, 75, 75)
+ );
+
+ render::RenderText(
+ g::hdcBuffer,
+ c4ScreenPos.x + (width / 2 + 5),
+ c4ScreenPos.y,
+ "C4",
+ RGB(75, 75, 175),
+ TextSize
+ );
+ }
+ }
+ while (true)
+ {
+ playerIndex++;
+ list_entry = process->read( entity_list + (8 * (playerIndex & 0x7FFF) >> 9) + 16);
+ if (!list_entry)
+ break;
+
+ const uintptr_t player = process->read( list_entry + 120 * (playerIndex & 0x1FF));
+ if (!player)
+ continue;
+
+ const int playerTeam = process->read( player + C_BaseEntity::m_iTeamNum);
+
+
+ const std::uint32_t playerPawn = process->read( player + CCSPlayerController::m_hPlayerPawn);
+
+ const uintptr_t list_entry2 = process->read( entity_list + 0x8 * ((playerPawn & 0x7FFF) >> 9) + 16);
+ if (!list_entry2)
+ continue;
+
+ const uintptr_t pCSPlayerPawn = process->read( list_entry2 + 120 * (playerPawn & 0x1FF));
+
+ const int playerArmor = process->read(pCSPlayerPawn + C_CSPlayerPawnBase::m_ArmorValue);
+ const int playerHealth = process->read( pCSPlayerPawn + C_BaseEntity::m_iHealth);
+ if (playerHealth <= 0 || playerHealth > 100)
+ continue;
+
+ if (pCSPlayerPawn == localPlayer)
+ continue;
+
+ std::string playerName = "Invalid Name";
+ const DWORD64 playerNameAddress = process->read(player + CCSPlayerController::m_sSanitizedPlayerName);
+ if (playerNameAddress) {
+ char buf[256];
+ process->read_raw(playerNameAddress, buf, sizeof(buf));
+ playerName = std::string(buf);
+ }
+
+ const uintptr_t CGameSceneNode = process->read(pCSPlayerPawn + C_BaseEntity::m_pGameSceneNode);
+ const Vector3 origin = process->read(CGameSceneNode + CGameSceneNode::m_vecOrigin);
+ const Vector3 head = { origin.x, origin.y, origin.z + 75.f };
+
+ if (render_distance != -1 && (localOrigin - origin).length2d() > render_distance)
+ continue;
+
+ const Vector3 screenPos = origin.world_to_screen(view_matrix);
+ if(screenPos.z < 0)
+ continue;
+ const Vector3 screenHead = head.world_to_screen(view_matrix);
+
+
+
+ if (screenPos.z >= 0.01f) {
+ render::RenderLine(g::hdcBuffer, screenHead.x, screenHead.y, g::gameBounds.right / 2, g::gameBounds.bottom * 0.8, (localTeam == playerTeam ? RGB(75, 175, 75) : RGB(175, 75, 75)));
+ const float height = screenPos.y - screenHead.y;
+ const float width = height / 2.4f;
+ const float head_height = (screenPos.y - screenHead.y) / 8;
+ const float head_width = (height / 2.4f) / 4;
+
+ float distance = localOrigin.calculate_distance(origin);
+ int roundedDistance = std::round(distance / 10.f);
+
+ render::DrawBorderBox(
+ g::hdcBuffer,
+ screenHead.x - width / 2,
+ screenHead.y,
+ width,
+ height,
+ (localTeam == playerTeam ? RGB(75, 175, 75) : RGB(175, 75, 75))
+ );
+
+ render::DrawBorderBox(
+ g::hdcBuffer,
+ screenHead.x - (width / 2 + 10),
+ screenHead.y + (height * (100 - playerArmor) / 100),
+ 2,
+ height - (height * (100 - playerArmor) / 100),
+ RGB(0, 185, 255)
+ );
+
+ render::DrawBorderBox(
+ g::hdcBuffer,
+ screenHead.x - (width / 2 + 5),
+ screenHead.y + (height * (100 - playerHealth) / 100),
+ 2,
+ height - (height * (100 - playerHealth) / 100),
+ RGB(
+ (255 - playerHealth),
+ (55 + playerHealth * 2),
+ 75
+ )
+ );
+
+ render::RenderText(
+ g::hdcBuffer,
+ screenHead.x + (width / 2 + 5),
+ screenHead.y,
+ playerName.c_str(),
+ RGB(75, 75, 175),
+ TextSize
+ );
+
+ /**
+ * I know is not the best way but a simple way to not saturate the screen with a ton of information
+ */
+ if (roundedDistance > flag_render_distance)
+ continue;
+
+ render::RenderText(
+ g::hdcBuffer,
+ screenHead.x + (width / 2 + 5),
+ screenHead.y + TextSize,
+ (std::to_string(playerHealth) + "hp").c_str(),
+ RGB(
+ (255 - playerHealth),
+ (55 + playerHealth * 2),
+ 75
+ ),
+ TextSize
+ );
+
+ render::RenderText(
+ g::hdcBuffer,
+ screenHead.x + (width / 2 + 5),
+ screenHead.y + TextSize*2,
+ (std::to_string(playerArmor) + "armor").c_str(),
+ RGB(
+ (255 - playerArmor),
+ (55 + playerArmor * 2),
+ 75
+ ),
+ TextSize
+ );
+
+ render::RenderText(
+ g::hdcBuffer,
+ screenHead.x + (width / 2 + 5),
+ screenHead.y + TextSize * 8,
+ (std::to_string((int)distance) + "cm").c_str(),
+ RGB(
+ (255 - playerArmor),
+ (55 + playerArmor * 2),
+ 75
+ ),
+ TextSize
+ );
+
+ if (show_extra)
+ {
+ /*
+ * Reading values for extra flags is now seperated from the other reads
+ * This removes unnecessary memory reads, improving performance when not showing extra flags
+ */
+ const bool isDefusing = process->read(pCSPlayerPawn + C_CSPlayerPawnBase::m_bIsDefusing);
+ const uintptr_t playerMoneyServices = process->read(player + CCSPlayerController::m_pInGameMoneyServices);
+ const int32_t money = process->read(playerMoneyServices + CCSPlayerController_InGameMoneyServices::m_iAccount);
+ const float flashAlpha = process->read(pCSPlayerPawn + C_CSPlayerPawnBase::m_flFlashOverlayAlpha);
+
+ const auto clippingWeapon = process->read(pCSPlayerPawn + C_CSPlayerPawnBase::m_pClippingWeapon);
+ const auto weaponData = process->read(clippingWeapon + 0x360);
+ const auto weaponNameAddress = process->read(weaponData + CCSWeaponBaseVData::m_szName);
+ std::string weaponName = "Invalid Weapon Name";
+
+ if (!weaponNameAddress) {
+ weaponName = "Invalid Weapon Name";
+ }
+ else {
+ char buf[32];
+ process->read_raw(weaponNameAddress, buf, sizeof(buf));
+ weaponName = std::string(buf);
+ if (weaponName.compare(0, 7, "weapon_") == 0)
+ weaponName = weaponName.substr(7, weaponName.length()); // Remove weapon_ prefix
+ }
+
+ render::RenderText(
+ g::hdcBuffer,
+ screenHead.x + (width / 2 + 5),
+ screenHead.y + TextSize*3,
+ weaponName.c_str(),
+ RGB(75, 75, 175),
+ TextSize
+ );
+
+ render::RenderText(
+ g::hdcBuffer,
+ screenHead.x + (width / 2 + 5),
+ screenHead.y + TextSize*4,
+ (std::to_string(roundedDistance) + "m away").c_str(),
+ RGB(75, 75, 175),
+ TextSize
+ );
+
+ render::RenderText(
+ g::hdcBuffer,
+ screenHead.x + (width / 2 + 5),
+ screenHead.y + TextSize*5,
+ ("$" + std::to_string(money)).c_str(),
+ RGB(0, 125, 0),
+ TextSize
+ );
+
+ if (flashAlpha > 100)
+ {
+ render::RenderText(
+ g::hdcBuffer,
+ screenHead.x + (width / 2 + 5),
+ screenHead.y + TextSize*6,
+ "Player is flashed",
+ RGB(75, 75, 175),
+ TextSize
+ );
+ }
+
+ if (isDefusing)
+ {
+ const std::string defuText = "Player is defusing";
+ render::RenderText(
+ g::hdcBuffer,
+ screenHead.x + (width / 2 + 5),
+ screenHead.y + 60,
+ defuText.c_str(),
+ RGB(75, 75, 175),
+ TextSize
+ );
+ }
+ }
+
+
+ if (distance > 1000)
+ {
+ continue;
+ }
+
+ // const uintptr_t CGameSceneNode = process->read( pCSPlayerPawn + C_BaseEntity::m_pGameSceneNode);
+ const uintptr_t boneArray = process->read( CGameSceneNode + CSkeletonInstance::m_modelState + CGameSceneNode::m_vecOrigin);
+
+ Vector3 head_ = process->read(boneArray + 6 * 32);
+ Vector3 cou = process->read(boneArray + 5 * 32);
+ Vector3 shoulderR = process->read(boneArray + 8 * 32);
+ Vector3 shoulderL = process->read(boneArray + 13 * 32);
+ Vector3 brasR = process->read(boneArray + 9 * 32);
+ Vector3 brasL = process->read(boneArray + 14 * 32);
+ Vector3 handR = process->read(boneArray + 11 * 32);
+ Vector3 handL = process->read(boneArray + 16 * 32);
+ Vector3 cock = process->read(boneArray + 0 * 32);
+ Vector3 kneesR = process->read(boneArray + 23 * 32);
+ Vector3 kneesL = process->read(boneArray + 26 * 32);
+ Vector3 feetR = process->read(boneArray + 24 * 32);
+ Vector3 feetL = process->read(boneArray + 27 * 32);
+
+ Vector3 Ahead;
+ Vector3 Acou;
+ Vector3 AshoulderR;
+ Vector3 AshoulderL;
+ Vector3 AbrasR;
+ Vector3 AbrasL;
+ Vector3 AhandR;
+ Vector3 AhandL;
+ Vector3 Acock;
+ Vector3 AkneesR;
+ Vector3 AkneesL;
+ Vector3 AfeetR;
+ Vector3 AfeetL;
+
+
+ Ahead = head .world_to_screen(view_matrix) ;
+ if (Ahead.z < 0)
+ continue;
+ Acou = cou .world_to_screen(view_matrix) ;
+ if (Acou.z < 0)
+ continue;
+ AshoulderR= shoulderR.world_to_screen(view_matrix) ;
+ if (AshoulderR.z < 0)
+ continue;
+ AshoulderL= shoulderL.world_to_screen(view_matrix) ;
+ if (AshoulderL.z < 0)
+ continue;
+ AbrasR = brasR .world_to_screen( view_matrix) ;
+ if (AbrasR.z < 0)
+ continue;
+ AbrasL = brasL .world_to_screen( view_matrix) ;
+ if (AbrasL.z < 0)
+ continue;
+ AhandL = handL .world_to_screen( view_matrix) ;
+ if (AhandL.z < 0)
+ continue;
+ AhandR = handR .world_to_screen( view_matrix) ;
+ if (AhandR.z < 0)
+ continue;
+ Acock = cock .world_to_screen( view_matrix) ;
+ if (Acock.z < 0)
+ continue;
+ AkneesR = kneesR .world_to_screen( view_matrix) ;
+ if (AkneesR.z < 0)
+ continue;
+ AkneesL = kneesL .world_to_screen( view_matrix) ;
+ if (AkneesL.z < 0)
+ continue;
+ AfeetR = feetR .world_to_screen( view_matrix) ;
+ if (AfeetR.z < 0)
+ continue;
+ AfeetL = feetL .world_to_screen( view_matrix) ;
+ if (AfeetL.z < 0)
+ continue;
+
+ render::RenderLine(g::hdcBuffer, Ahead.x, Ahead.y, Acou.x, Acou.y, BonesColor);
+ render::RenderLine(g::hdcBuffer,Acou.x, Acou.y, AshoulderR.x, AshoulderR.y, BonesColor);
+ render::RenderLine(g::hdcBuffer,Acou.x, Acou.y, AshoulderL.x, AshoulderL.y, BonesColor);
+ render::RenderLine(g::hdcBuffer,AbrasL.x, AbrasL.y, AshoulderL.x, AshoulderL.y, BonesColor);
+ render::RenderLine(g::hdcBuffer,AbrasR.x, AbrasR.y, AshoulderR.x, AshoulderR.y, BonesColor);
+ render::RenderLine(g::hdcBuffer,AbrasR.x, AbrasR.y, AhandR.x, AhandR.y, BonesColor);
+ render::RenderLine(g::hdcBuffer,AbrasL.x, AbrasL.y, AhandL.x, AhandL.y, BonesColor);
+ render::RenderLine(g::hdcBuffer,Acou.x, Acou.y, Acock.x, Acock.y, BonesColor);
+ render::RenderLine(g::hdcBuffer,AkneesR.x, AkneesR.y, Acock.x, Acock.y, BonesColor);
+ render::RenderLine(g::hdcBuffer,AkneesL.x, AkneesL.y, Acock.x, Acock.y, BonesColor);
+ render::RenderLine(g::hdcBuffer,AkneesL.x, AkneesL.y, AfeetL.x, AfeetL.y, BonesColor);
+ render::RenderLine(g::hdcBuffer,AkneesR.x, AkneesR.y, AfeetR.x, AfeetR.y, BonesColor);
+
+
+ // Vector3 previous, current;
+ //
+ //
+ // for (std::vector currentGroup : boneGroups::allGroups) {
+ // previous = { 0,0,0 };
+ //
+ // for (int currentBone : currentGroup) {
+ // current = process->read(boneArray + currentBone * 32);
+ //
+ // if (previous.IsZero()) {
+ // previous = current;
+ // continue;
+ // }
+ //
+ // Vector3 currentScreenPos = current.world_to_screen(view_matrix);
+ // Vector3 previousScreenPos = previous.world_to_screen(view_matrix);
+ //
+ //
+ // render::RenderLine(g::hdcBuffer, previousScreenPos.x, previousScreenPos.y, currentScreenPos.x, currentScreenPos.y, BonesColor);
+ //
+ // previous = current;
+ // }
+ // }
+
+ }
+
+
+
+
+
+ }
+}
+
+void FunctionT()
+{
+
+ int playerIndex = 0;
+ uintptr_t list_entry;
+
+
+ Vector3 cameraPos = process->read(localPlayer + C_CSPlayerPawnBase::m_vecLastClipCameraPos);
+
+ Vector3 viewAngles = process->read(localPlayer + C_CSPlayerPawnBase::m_angEyeAngles);
+
+ Vector3 baseViewAngles = process->read(cs2_module_client.base + client_dll::dwViewAngles);
+
+
+ const uintptr_t localList_entry2 = process->read(entity_list + 0x8 * ((localPlayer & 0x7FFF) >> 9) + 16);
+ const uintptr_t localpCSPlayerPawn = process->read(localList_entry2 + 120 * (localPlayer & 0x1FF));
+ if (!localpCSPlayerPawn)
+ return;
+
+ uintptr_t baseViewAnglesAddy = cs2_module_client.base + client_dll::dwViewAngles;
+
+ C_UTL_VECTOR aimPunchCache = process->read(localPlayer + C_CSPlayerPawn::m_aimPunchCache);
+
+ int shotsFired = process->read(localPlayer + C_CSPlayerPawnBase::m_iShotsFired);
+
+ float fov = FOV;
+ while (true)
+ {
+ playerIndex++;
+ list_entry = process->read(entity_list + (8 * (playerIndex & 0x7FFF) >> 9) + 16);
+ if (!list_entry)
+ break;
+
+ const uintptr_t player = process->read(list_entry + 120 * (playerIndex & 0x1FF));
+ if (!player)
+ continue;
+
+ const int playerTeam = process->read(player + C_BaseEntity::m_iTeamNum);
+ if (playerTeam == localTeam)
+ {
+ continue;
+ }
+
+
+
+ const std::uint32_t playerPawn = process->read(player + CCSPlayerController::m_hPlayerPawn);
+
+ const uintptr_t list_entry2 = process->read(entity_list + 0x8 * ((playerPawn & 0x7FFF) >> 9) + 16);
+ if (!list_entry2)
+ continue;
+
+ const uintptr_t pCSPlayerPawn = process->read(list_entry2 + 120 * (playerPawn & 0x1FF));
+ if (pCSPlayerPawn == localPlayer)
+ continue;
+
+ const int playerArmor = process->read(pCSPlayerPawn + C_CSPlayerPawnBase::m_ArmorValue);
+ const int playerHealth = process->read(pCSPlayerPawn + C_BaseEntity::m_iHealth);
+ if (playerHealth <= 0 || playerHealth > 100)
+ continue;
+
+ const uintptr_t CGameSceneNode = process->read(pCSPlayerPawn + C_BaseEntity::m_pGameSceneNode);
+ const uintptr_t boneArray = process->read(CGameSceneNode + CSkeletonInstance::m_modelState + CGameSceneNode::m_vecOrigin);
+
+ aimBot(aimPunchCache,shotsFired,cameraPos, viewAngles, fov, true, baseViewAngles, baseViewAnglesAddy, boneArray);
+ //recoilControl(viewAngles, aimPunchCache, shotsFired, baseViewAnglesAddy);
+ }
+}
diff --git a/HPCS2/HPCS2/handle_hijack.hpp b/HPCS2/HPCS2/handle_hijack.hpp
new file mode 100644
index 0000000..620fd9a
--- /dev/null
+++ b/HPCS2/HPCS2/handle_hijack.hpp
@@ -0,0 +1,287 @@
+
+/*
+ Credits to: https://github.com/Apxaey/Handle-Hijacking-Anti-Cheat-Bypass for the source and public sharing!
+
+ Its a little bit messy as i tried to make it asap. All comments below this are from the original creator!
+*/
+
+/*
+ This is a stand alone bypass made by Apxaey. Feel free to use this in your cheats but credit me for the bypass as i put alot of time into this.
+ If you have some brain cells you will be able to incorporate this into your cheats and remain undetected by user-mode anticheats.
+ Obviously standard cheat 'recommendations' still apply:
+ 1.) Use self-written or not signatured code
+ 2.) Dont write impossible values
+ 3.) If your going internal use a manual map injector
+
+ If you follow the guidelines above and use this bypass you will be safe from usermode anticheats like VAC.
+ Obviously you can build and adapt upon my code to suit your needs.
+ If I was to make a cheat for myself i would put this bypass into something i call an 'external internal' cheat.
+ Whereby you make a cheat and inject into a legitimate program like discord and add a check to the this bypass to only hijack a handle from the process you inject into, giving the appearence that nothing is out of the ordinary
+ However you can implement this bypass into any form of cheat, its your decision.
+ If you need want some more info i recommend you watch my YT video on this bypass.
+ Anyways if you want to see more of my stuff feel free to join my discord server discord.gg/********. Here's my YT as well https://www.youtube.com/channel/UCPN6OOLxn1OaBP5jPThIiog.
+*/
+
+#include
+#include
+#include
+#include
+
+// macros we use.Some can be found in wintrnl.h
+#define SeDebugPriv 20
+#define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0)
+#define STATUS_INFO_LENGTH_MISMATCH ((NTSTATUS)0xC0000004)
+#define NtCurrentProcess ( (HANDLE)(LONG_PTR) -1 )
+#define ProcessHandleType 0x7
+#define SystemHandleInformation 16
+
+/*
+STRUCTURES NEEDED FOR NTOPENPROCESS:
+*/
+typedef struct _UNICODE_STRING {
+ USHORT Length;
+ USHORT MaximumLength;
+ PWCH Buffer;
+} UNICODE_STRING, * PUNICODE_STRING;
+
+typedef struct _OBJECT_ATTRIBUTES {
+ ULONG Length;
+ HANDLE RootDirectory;
+ PUNICODE_STRING ObjectName;
+ ULONG Attributes;
+ PVOID SecurityDescriptor;
+ PVOID SecurityQualityOfService;
+} OBJECT_ATTRIBUTES, * POBJECT_ATTRIBUTES;
+
+typedef struct _CLIENT_ID
+{
+ PVOID UniqueProcess;
+ PVOID UniqueThread;
+} CLIENT_ID, * PCLIENT_ID;
+
+/*
+STRUCTURES NEEDED FOR HANDLE INFORMATION:
+*/
+
+typedef struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO
+{
+ ULONG ProcessId;
+ BYTE ObjectTypeNumber;
+ BYTE Flags;
+ USHORT Handle;
+ PVOID Object;
+ ACCESS_MASK GrantedAccess;
+} SYSTEM_HANDLE, * PSYSTEM_HANDLE; //i shortened it to SYSTEM_HANDLE for the sake of typing
+
+typedef struct _SYSTEM_HANDLE_INFORMATION
+{
+ ULONG HandleCount;
+ SYSTEM_HANDLE Handles[1];
+} SYSTEM_HANDLE_INFORMATION, * PSYSTEM_HANDLE_INFORMATION;
+
+/*
+FUNCTION PROTOTYPES:
+*/
+typedef NTSTATUS(NTAPI* _NtDuplicateObject)(
+ HANDLE SourceProcessHandle,
+ HANDLE SourceHandle,
+ HANDLE TargetProcessHandle,
+ PHANDLE TargetHandle,
+ ACCESS_MASK DesiredAccess,
+ ULONG Attributes,
+ ULONG Options
+ );
+
+typedef NTSTATUS(NTAPI* _RtlAdjustPrivilege)(
+ ULONG Privilege,
+ BOOLEAN Enable,
+ BOOLEAN CurrentThread,
+ PBOOLEAN Enabled
+ );
+
+typedef NTSYSAPI NTSTATUS(NTAPI* _NtOpenProcess)(
+ PHANDLE ProcessHandle,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_ATTRIBUTES ObjectAttributes,
+ PCLIENT_ID ClientId
+ );
+
+typedef NTSTATUS(NTAPI* _NtQuerySystemInformation)(
+ ULONG SystemInformationClass, //your supposed to supply the whole class but microsoft kept the enum mostly empty so I just passed 16 instead for handle info. Thats why you get a warning in your code btw
+ PVOID SystemInformation,
+ ULONG SystemInformationLength,
+ PULONG ReturnLength
+ );
+
+SYSTEM_HANDLE_INFORMATION* hInfo; //holds the handle information
+
+//the handles we will need to use later on
+
+namespace hj {
+ HANDLE procHandle = NULL;
+ HANDLE hProcess = NULL;
+ HANDLE HijackedHandle = NULL;
+
+ // simple function i made that will just initialize our Object_Attributes structure as NtOpenProcess will fail otherwise
+ OBJECT_ATTRIBUTES InitObjectAttributes(PUNICODE_STRING name, ULONG attributes, HANDLE hRoot, PSECURITY_DESCRIPTOR security)
+ {
+ OBJECT_ATTRIBUTES object;
+
+ object.Length = sizeof(OBJECT_ATTRIBUTES);
+ object.ObjectName = name;
+ object.Attributes = attributes;
+ object.RootDirectory = hRoot;
+ object.SecurityDescriptor = security;
+
+ return object;
+ }
+
+ bool IsHandleValid(HANDLE handle) // i made this to simply check if a handle is valid rather than repeating the if statments
+ {
+ if (handle && handle != INVALID_HANDLE_VALUE)
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ HANDLE HijackExistingHandle(DWORD dwTargetProcessId)
+ {
+ HMODULE Ntdll = GetModuleHandleA("ntdll"); // get the base address of ntdll.dll
+
+ //get the address of RtlAdjustPrivilege in ntdll.dll so we can grant our process the highest permission possible
+ _RtlAdjustPrivilege RtlAdjustPrivilege = (_RtlAdjustPrivilege)GetProcAddress(Ntdll, "RtlAdjustPrivilege");
+
+ boolean OldPriv; //store the old privileges
+
+ // Give our program SeDeugPrivileges whcih allows us to get a handle to every process, even the highest privileged SYSTEM level processes.
+ RtlAdjustPrivilege(SeDebugPriv, TRUE, FALSE, &OldPriv);
+
+ //get the address of NtQuerySystemInformation in ntdll.dll so we can find all the open handles on our system
+ _NtQuerySystemInformation NtQuerySystemInformation = (_NtQuerySystemInformation)GetProcAddress(Ntdll, "NtQuerySystemInformation");
+
+ //get the address of NtDuplicateObject in ntdll.dll so we can duplicate an existing handle into our cheat, basically performing the hijacking
+ _NtDuplicateObject NtDuplicateObject = (_NtDuplicateObject)GetProcAddress(Ntdll, "NtDuplicateObject");
+
+ //get the address of NtOpenProcess in ntdll.dll so wecan create a Duplicate handle
+ _NtOpenProcess NtOpenProcess = (_NtOpenProcess)GetProcAddress(Ntdll, "NtOpenProcess");
+
+
+ //initialize the Object Attributes structure, you can just set each member to NULL rather than create a function like i did
+ OBJECT_ATTRIBUTES Obj_Attribute = InitObjectAttributes(NULL, NULL, NULL, NULL);
+
+ //clientID is a PDWORD or DWORD* of the process id to create a handle to
+ CLIENT_ID clientID = { 0 };
+
+
+ //the size variable is the amount of bytes allocated to store all the open handles
+ DWORD size = sizeof(SYSTEM_HANDLE_INFORMATION);
+
+ //we allocate the memory to store all the handles on the heap rather than the stack becuase of the large amount of data
+ hInfo = (SYSTEM_HANDLE_INFORMATION*) new byte[size];
+
+ //zero the memory handle info
+ ZeroMemory(hInfo, size);
+
+ //we use this for checking if the Native functions succeed
+ NTSTATUS NtRet = NULL;
+
+ do
+ {
+ // delete the previously allocated memory on the heap because it wasn't large enough to store all the handles
+ delete[] hInfo;
+
+ //increase the amount of memory allocated by 50%
+ size *= 1.5;
+ try
+ {
+ //set and allocate the larger size on the heap
+ hInfo = (PSYSTEM_HANDLE_INFORMATION) new byte[size];
+ }
+ catch (std::bad_alloc) //catch a bad heap allocation.
+ {
+ procHandle ? CloseHandle(procHandle) : 0;
+ }
+ Sleep(1); //sleep for the cpu
+
+ //we continue this loop until all the handles have been stored
+ } while ((NtRet = NtQuerySystemInformation(SystemHandleInformation, hInfo, size, NULL)) == STATUS_INFO_LENGTH_MISMATCH);
+
+ //check if we got all the open handles on our system
+ if (!NT_SUCCESS(NtRet))
+ {
+ procHandle ? CloseHandle(procHandle) : 0;
+ }
+
+
+ //loop through each handle on our system, and filter out handles that are invalid or cant be hijacked
+ for (unsigned int i = 0; i < hInfo->HandleCount; ++i)
+ {
+ //a variable to store the number of handles OUR cheat has open.
+ static DWORD NumOfOpenHandles;
+
+ //get the amount of outgoing handles OUR cheat has open
+ GetProcessHandleCount(GetCurrentProcess(), &NumOfOpenHandles);
+
+ //you can do a higher number if this is triggering false positives. Its just to make sure we dont fuck up and create thousands of handles
+ if (NumOfOpenHandles > 50)
+ {
+ procHandle ? CloseHandle(procHandle) : 0;
+ }
+
+ //check if the current handle is valid, otherwise increment i and check the next handle
+ if (!IsHandleValid((HANDLE)hInfo->Handles[i].Handle))
+ {
+ continue;
+ }
+
+ //check the handle type is 0x7 meaning a process handle so we dont hijack a file handle for example
+ if (hInfo->Handles[i].ObjectTypeNumber != ProcessHandleType)
+ {
+ continue;
+ }
+
+
+ //set clientID to a pointer to the process with the handle to out target
+ clientID.UniqueProcess = (DWORD*)hInfo->Handles[i].ProcessId;
+
+ //if procHandle is open, close it
+ procHandle ? CloseHandle(procHandle) : 0;
+
+ //create a a handle with duplicate only permissions to the process with a handle to our target. NOT OUR TARGET.
+ NtRet = NtOpenProcess(&procHandle, PROCESS_DUP_HANDLE, &Obj_Attribute, &clientID);
+ if (!IsHandleValid(procHandle) || !NT_SUCCESS(NtRet)) //check is the funcions succeeded and check the handle is valid
+ {
+ continue;
+ }
+
+
+ //we duplicate the handle another process has to our target into our cheat with whatever permissions we want. I did all access.
+ NtRet = NtDuplicateObject(procHandle, (HANDLE)hInfo->Handles[i].Handle, NtCurrentProcess, &HijackedHandle, PROCESS_ALL_ACCESS, 0, 0);
+ if (!IsHandleValid(HijackedHandle) || !NT_SUCCESS(NtRet))//check is the funcions succeeded and check the handle is valid
+ {
+
+ continue;
+ }
+
+ //get the process id of the handle we duplicated and check its to our target
+ if (GetProcessId(HijackedHandle) != dwTargetProcessId) {
+ CloseHandle(HijackedHandle);
+ continue;
+ }
+
+
+
+ hProcess = HijackedHandle;
+
+ break;
+ }
+
+ procHandle ? CloseHandle(procHandle) : 0;
+
+ return hProcess;
+ }
+}
\ No newline at end of file
diff --git a/HPCS2/HPCS2/memory.cpp b/HPCS2/HPCS2/memory.cpp
new file mode 100644
index 0000000..7565142
--- /dev/null
+++ b/HPCS2/HPCS2/memory.cpp
@@ -0,0 +1,255 @@
+#include "memory.hpp"
+#include
+#include "handle_hijack.hpp"
+
+uint32_t pProcess::FindProcessIdByProcessName(const char* ProcessName)
+{
+ std::wstring wideProcessName;
+ int wideCharLength = MultiByteToWideChar(CP_UTF8, 0, ProcessName, -1, nullptr, 0);
+ if (wideCharLength > 0)
+ {
+ wideProcessName.resize(wideCharLength);
+ MultiByteToWideChar(CP_UTF8, 0, ProcessName, -1, &wideProcessName[0], wideCharLength);
+ }
+
+ HANDLE hPID = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
+ PROCESSENTRY32W process_entry_{ };
+ process_entry_.dwSize = sizeof(PROCESSENTRY32W);
+
+ DWORD pid = 0;
+ if (Process32FirstW(hPID, &process_entry_))
+ {
+ do
+ {
+ if (!wcscmp(process_entry_.szExeFile, wideProcessName.c_str()))
+ {
+ pid = process_entry_.th32ProcessID;
+ break;
+ }
+ } while (Process32NextW(hPID, &process_entry_));
+ }
+ CloseHandle(hPID);
+ return pid;
+}
+
+uint32_t pProcess::FindProcessIdByWindowName(const char* WindowName)
+{
+ DWORD process_id = 0;
+ HWND windowHandle = FindWindowA(nullptr, WindowName);
+ if (windowHandle)
+ GetWindowThreadProcessId(windowHandle, &process_id);
+ return process_id;
+}
+
+HWND pProcess::GetWindowHandleFromProcessId(DWORD ProcessId) {
+ HWND hwnd = NULL;
+ do {
+ hwnd = FindWindowEx(NULL, hwnd, NULL, NULL);
+ DWORD pid = 0;
+ GetWindowThreadProcessId(hwnd, &pid);
+ if (pid == ProcessId) {
+ TCHAR windowTitle[MAX_PATH];
+ GetWindowText(hwnd, windowTitle, MAX_PATH);
+ if (IsWindowVisible(hwnd) && windowTitle[0] != '\0') {
+ return hwnd;
+ }
+ }
+ } while (hwnd != NULL);
+ return NULL; // No main window found for the given process ID
+}
+
+bool pProcess::AttachProcess(const char* ProcessName)
+{
+ this->pid_ = this->FindProcessIdByProcessName(ProcessName);
+
+ if (pid_)
+ {
+ HMODULE modules[0xFF];
+ MODULEINFO module_info;
+ DWORD _;
+
+ handle_ = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid_);
+
+ EnumProcessModulesEx(this->handle_, modules, sizeof(modules), &_, LIST_MODULES_64BIT);
+ base_client_.base = (uintptr_t)modules[0];
+
+ GetModuleInformation(this->handle_, modules[0], &module_info, sizeof(module_info));
+ base_client_.size = module_info.SizeOfImage;
+
+ hwnd_ = this->GetWindowHandleFromProcessId(pid_);
+
+ return true;
+ }
+
+ return false;
+}
+
+bool pProcess::AttachProcessHj(const char* ProcessName)
+{
+ this->pid_ = this->FindProcessIdByProcessName(ProcessName);
+
+ if (pid_)
+ {
+ HMODULE modules[0xFF];
+ MODULEINFO module_info;
+ DWORD _;
+
+
+ // Using Apxaey's handle hijack function to safely open a handle
+ handle_ = hj::HijackExistingHandle(pid_);
+
+ if (!hj::IsHandleValid(handle_))
+ {
+ std::cout << "[cheat] Handle Hijack failed, falling back to OpenProcess method." << std::endl;
+ return pProcess::AttachProcess(ProcessName); // Handle hijacking failed, so we fall back to the normal OpenProcess method
+ }
+
+ EnumProcessModulesEx(this->handle_, modules, sizeof(modules), &_, LIST_MODULES_64BIT);
+ base_client_.base = (uintptr_t)modules[0];
+
+ GetModuleInformation(this->handle_, modules[0], &module_info, sizeof(module_info));
+ base_client_.size = module_info.SizeOfImage;
+
+ hwnd_ = this->GetWindowHandleFromProcessId(pid_);
+
+ return true;
+ }
+
+ return false;
+}
+
+
+bool pProcess::AttachWindow(const char* WindowName)
+{
+ this->pid_ = this->FindProcessIdByWindowName(WindowName);
+
+ if (pid_)
+ {
+ HMODULE modules[0xFF];
+ MODULEINFO module_info;
+ DWORD _;
+
+ handle_ = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid_);
+
+ EnumProcessModulesEx(this->handle_, modules, sizeof(modules), &_, LIST_MODULES_64BIT);
+ base_client_.base = (uintptr_t)modules[0];
+
+ GetModuleInformation(this->handle_, modules[0], &module_info, sizeof(module_info));
+ base_client_.size = module_info.SizeOfImage;
+
+ hwnd_ = this->GetWindowHandleFromProcessId(pid_);
+
+ return true;
+ }
+ return false;
+}
+
+bool pProcess::UpdateHWND()
+{
+ hwnd_ = this->GetWindowHandleFromProcessId(pid_);
+ return hwnd_ == nullptr;
+}
+
+ProcessModule pProcess::GetModule(const char* lModule)
+{
+ std::wstring wideModule;
+ int wideCharLength = MultiByteToWideChar(CP_UTF8, 0, lModule, -1, nullptr, 0);
+ if (wideCharLength > 0)
+ {
+ wideModule.resize(wideCharLength);
+ MultiByteToWideChar(CP_UTF8, 0, lModule, -1, &wideModule[0], wideCharLength);
+ }
+
+ HANDLE handle_module = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid_);
+ MODULEENTRY32W module_entry_{};
+ module_entry_.dwSize = sizeof(MODULEENTRY32W);
+
+ do
+ {
+ if (!wcscmp(module_entry_.szModule, wideModule.c_str()))
+ {
+ CloseHandle(handle_module);
+ return { (DWORD_PTR)module_entry_.modBaseAddr, module_entry_.dwSize };
+ }
+ } while (Module32NextW(handle_module, &module_entry_));
+
+ CloseHandle(handle_module);
+ return { 0, 0 };
+}
+
+LPVOID pProcess::Allocate(size_t size_in_bytes)
+{
+ return VirtualAllocEx(this->handle_, NULL, size_in_bytes, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+}
+
+uintptr_t pProcess::FindSignature(std::vector signature)
+{
+ std::unique_ptr data;
+ data = std::make_unique(this->base_client_.size);
+
+ if (!ReadProcessMemory(this->handle_, (void*)(this->base_client_.base), data.get(), this->base_client_.size, NULL)) {
+ return 0x0;
+ }
+
+ for (uintptr_t i = 0; i < this->base_client_.size; i++)
+ {
+ for (uintptr_t j = 0; j < signature.size(); j++)
+ {
+ if (signature.at(j) == 0x00)
+ continue;
+
+ if (*reinterpret_cast(reinterpret_cast(&data[i + j])) == signature.at(j))
+ {
+ if (j == signature.size() - 1)
+ return this->base_client_.base + i;
+ continue;
+ }
+ break;
+ }
+ }
+ return 0x0;
+}
+
+uintptr_t pProcess::FindSignature(ProcessModule target_module, std::vector signature)
+{
+ std::unique_ptr data;
+ data = std::make_unique(0xFFFFFFF);
+
+ if (!ReadProcessMemory(this->handle_, (void*)(target_module.base), data.get(), 0xFFFFFFF, NULL)) {
+ return NULL;
+ }
+
+ for (uintptr_t i = 0; i < 0xFFFFFFF; i++)
+ {
+ for (uintptr_t j = 0; j < signature.size(); j++)
+ {
+ if (signature.at(j) == 0x00)
+ continue;
+
+ if (*reinterpret_cast(reinterpret_cast(&data[i + j])) == signature.at(j))
+ {
+ if (j == signature.size() - 1)
+ return this->base_client_.base + i;
+ continue;
+ }
+ break;
+ }
+ }
+ return 0x0;
+}
+
+uintptr_t pProcess::FindCodeCave(uint32_t length_in_bytes)
+{
+ std::vector cave_pattern = {};
+
+ for (uint32_t i = 0; i < length_in_bytes; i++) {
+ cave_pattern.push_back(0x00);
+ }
+
+ return FindSignature(cave_pattern);
+}
+
+void pProcess::Close()
+{
+ CloseHandle(handle_);
+}
\ No newline at end of file
diff --git a/HPCS2/HPCS2/memory.hpp b/HPCS2/HPCS2/memory.hpp
new file mode 100644
index 0000000..be13d0e
--- /dev/null
+++ b/HPCS2/HPCS2/memory.hpp
@@ -0,0 +1,124 @@
+#ifndef _PPROCESS_HPP_
+#define _PPROCESS_HPP_
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+typedef NTSTATUS(WINAPI* pNtReadVirtualMemory)(HANDLE ProcessHandle, PVOID BaseAddress, PVOID Buffer, ULONG NumberOfBytesToRead, PULONG NumberOfBytesRead);
+typedef NTSTATUS(WINAPI* pNtWriteVirtualMemory)(HANDLE ProcessHandle, PVOID BaseAddress, PVOID Buffer, ULONG NumberOfBytesToWrite, PULONG NumberOfBytesWritten);
+
+class pMemory {
+
+public:
+ pMemory() {
+ pfnNtReadVirtualMemory = (pNtReadVirtualMemory)GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtReadVirtualMemory");
+ pfnNtWriteVirtualMemory = (pNtWriteVirtualMemory)GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtWriteVirtualMemory");
+ }
+
+ pNtReadVirtualMemory pfnNtReadVirtualMemory;
+ pNtWriteVirtualMemory pfnNtWriteVirtualMemory;
+};
+
+struct ProcessModule
+{
+ uintptr_t base, size;
+};
+
+class pProcess
+{
+public:
+ DWORD pid_; // process id
+ HANDLE handle_; // handle to process
+ HWND hwnd_; // window handle
+ ProcessModule base_client_;
+
+public:
+ bool AttachProcess(const char* process_name);
+ bool AttachProcessHj(const char* process_name);
+ bool AttachWindow(const char* window_name);
+ bool UpdateHWND();
+ void Close();
+
+public:
+ ProcessModule GetModule(const char* module_name);
+ LPVOID Allocate(size_t size_in_bytes);
+ uintptr_t FindCodeCave(uint32_t length_in_bytes);
+ uintptr_t FindSignature(std::vector signature);
+ uintptr_t FindSignature(ProcessModule target_module, std::vector signature);
+
+ template
+ uintptr_t ReadOffsetFromSignature(std::vector signature, uint8_t offset) // offset example: "FF 05 ->22628B01<-" offset is 2
+ {
+ uintptr_t pattern_address = this->FindSignature(signature);
+ if (!pattern_address)
+ return 0x0;
+
+ T offset_value = this->read(pattern_address + offset);
+ return pattern_address + offset_value + offset + sizeof(T);
+ }
+
+ bool read_raw(uintptr_t address, void* buffer, size_t size)
+ {
+ SIZE_T bytesRead;
+ pMemory cMemory;
+
+ if (cMemory.pfnNtReadVirtualMemory(this->handle_, (PVOID)(address), buffer, static_cast(size), (PULONG)&bytesRead))
+ {
+ return bytesRead == size;
+ }
+ return false;
+ }
+
+ template
+ void write(uintptr_t address, T value)
+ {
+ pMemory cMemory;
+ cMemory.pfnNtWriteVirtualMemory(handle_, (void*)address, &value, sizeof(T), 0);
+ }
+
+ template
+ T read(uintptr_t address)
+ {
+ T buffer{};
+ pMemory cMemory;
+
+ cMemory.pfnNtReadVirtualMemory(handle_, (void*)address, &buffer, sizeof(T), 0);
+ return buffer;
+ }
+
+ void write_bytes(uintptr_t addr, std::vector patch)
+ {
+ pMemory cMemory;
+ cMemory.pfnNtWriteVirtualMemory(handle_, (void*)addr, &patch[0], patch.size(), 0);
+ }
+
+ uintptr_t read_multi_address(uintptr_t ptr, std::vector offsets)
+ {
+ uintptr_t buffer = ptr;
+ for (int i = 0; i < offsets.size(); i++)
+ buffer = this->read(buffer + offsets[i]);
+
+ return buffer;
+ }
+
+ template
+ T read_multi(uintptr_t base, std::vector offsets) {
+ uintptr_t buffer = base;
+ for (int i = 0; i < offsets.size() - 1; i++)
+ {
+ buffer = this->read(buffer + offsets[i]);
+ }
+ return this->read(buffer + offsets.back());
+ }
+
+private:
+ uint32_t FindProcessIdByProcessName(const char* process_name);
+ uint32_t FindProcessIdByWindowName(const char* window_name);
+ HWND GetWindowHandleFromProcessId(DWORD ProcessId);
+};
+#endif
\ No newline at end of file
diff --git a/HPCS2/HPCS2/offset/animationsystem.dll.hpp b/HPCS2/HPCS2/offset/animationsystem.dll.hpp
new file mode 100644
index 0000000..e636e09
--- /dev/null
+++ b/HPCS2/HPCS2/offset/animationsystem.dll.hpp
@@ -0,0 +1,2579 @@
+/*
+ * Created using https://github.com/a2x/cs2-dumper
+ * Sat, 4 Nov 2023 21:18:20 +0000
+ */
+
+#pragma once
+
+#include
+
+namespace AimMatrixOpFixedSettings_t {
+ constexpr std::ptrdiff_t m_attachment = 0x0; // CAnimAttachment
+ constexpr std::ptrdiff_t m_damping = 0x80; // CAnimInputDamping
+ constexpr std::ptrdiff_t m_poseCacheHandles = 0x90; // CPoseHandle[10]
+ constexpr std::ptrdiff_t m_eBlendMode = 0xB8; // AimMatrixBlendMode
+ constexpr std::ptrdiff_t m_fAngleIncrement = 0xBC; // float
+ constexpr std::ptrdiff_t m_nSequenceMaxFrame = 0xC0; // int32_t
+ constexpr std::ptrdiff_t m_nBoneMaskIndex = 0xC4; // int32_t
+ constexpr std::ptrdiff_t m_bTargetIsPosition = 0xC8; // bool
+}
+
+namespace AnimComponentID {
+ constexpr std::ptrdiff_t m_id = 0x0; // uint32_t
+}
+
+namespace AnimNodeID {
+ constexpr std::ptrdiff_t m_id = 0x0; // uint32_t
+}
+
+namespace AnimNodeOutputID {
+ constexpr std::ptrdiff_t m_id = 0x0; // uint32_t
+}
+
+namespace AnimParamID {
+ constexpr std::ptrdiff_t m_id = 0x0; // uint32_t
+}
+
+namespace AnimScriptHandle {
+ constexpr std::ptrdiff_t m_id = 0x0; // uint32_t
+}
+
+namespace AnimStateID {
+ constexpr std::ptrdiff_t m_id = 0x0; // uint32_t
+}
+
+namespace AnimTagID {
+ constexpr std::ptrdiff_t m_id = 0x0; // uint32_t
+}
+
+namespace AnimationDecodeDebugDumpElement_t {
+ constexpr std::ptrdiff_t m_nEntityIndex = 0x0; // int32_t
+ constexpr std::ptrdiff_t m_modelName = 0x8; // CUtlString
+ constexpr std::ptrdiff_t m_poseParams = 0x10; // CUtlVector
+ constexpr std::ptrdiff_t m_decodeOps = 0x28; // CUtlVector
+ constexpr std::ptrdiff_t m_internalOps = 0x40; // CUtlVector
+ constexpr std::ptrdiff_t m_decodedAnims = 0x58; // CUtlVector
+}
+
+namespace AnimationDecodeDebugDump_t {
+ constexpr std::ptrdiff_t m_processingType = 0x0; // AnimationProcessingType_t
+ constexpr std::ptrdiff_t m_elems = 0x8; // CUtlVector
+}
+
+namespace AnimationSnapshotBase_t {
+ constexpr std::ptrdiff_t m_flRealTime = 0x0; // float
+ constexpr std::ptrdiff_t m_rootToWorld = 0x10; // matrix3x4a_t
+ constexpr std::ptrdiff_t m_bBonesInWorldSpace = 0x40; // bool
+ constexpr std::ptrdiff_t m_boneSetupMask = 0x48; // CUtlVector
+ constexpr std::ptrdiff_t m_boneTransforms = 0x60; // CUtlVector
+ constexpr std::ptrdiff_t m_flexControllers = 0x78; // CUtlVector
+ constexpr std::ptrdiff_t m_SnapshotType = 0x90; // AnimationSnapshotType_t
+ constexpr std::ptrdiff_t m_bHasDecodeDump = 0x94; // bool
+ constexpr std::ptrdiff_t m_DecodeDump = 0x98; // AnimationDecodeDebugDumpElement_t
+}
+
+namespace AnimationSnapshot_t { // AnimationSnapshotBase_t
+ constexpr std::ptrdiff_t m_nEntIndex = 0x110; // int32_t
+ constexpr std::ptrdiff_t m_modelName = 0x118; // CUtlString
+}
+
+namespace AttachmentHandle_t {
+ constexpr std::ptrdiff_t m_Value = 0x0; // uint8_t
+}
+
+namespace BlendItem_t {
+ constexpr std::ptrdiff_t m_tags = 0x0; // CUtlVector
+ constexpr std::ptrdiff_t m_pChild = 0x18; // CAnimUpdateNodeRef
+ constexpr std::ptrdiff_t m_hSequence = 0x28; // HSequence
+ constexpr std::ptrdiff_t m_vPos = 0x2C; // Vector2D
+ constexpr std::ptrdiff_t m_flDuration = 0x34; // float
+ constexpr std::ptrdiff_t m_bUseCustomDuration = 0x38; // bool
+}
+
+namespace BoneDemoCaptureSettings_t {
+ constexpr std::ptrdiff_t m_boneName = 0x0; // CUtlString
+ constexpr std::ptrdiff_t m_flChainLength = 0x8; // float
+}
+
+namespace CActionComponentUpdater { // CAnimComponentUpdater
+ constexpr std::ptrdiff_t m_actions = 0x30; // CUtlVector>
+}
+
+namespace CAddUpdateNode { // CBinaryUpdateNode
+ constexpr std::ptrdiff_t m_footMotionTiming = 0x8C; // BinaryNodeChildOption
+ constexpr std::ptrdiff_t m_bApplyToFootMotion = 0x90; // bool
+ constexpr std::ptrdiff_t m_bApplyChannelsSeparately = 0x91; // bool
+ constexpr std::ptrdiff_t m_bUseModelSpace = 0x92; // bool
+}
+
+namespace CAimConstraint { // CBaseConstraint
+ constexpr std::ptrdiff_t m_qAimOffset = 0x70; // Quaternion
+ constexpr std::ptrdiff_t m_nUpType = 0x80; // uint32_t
+}
+
+namespace CAimMatrixUpdateNode { // CUnaryUpdateNode
+ constexpr std::ptrdiff_t m_opFixedSettings = 0x70; // AimMatrixOpFixedSettings_t
+ constexpr std::ptrdiff_t m_target = 0x148; // AnimVectorSource
+ constexpr std::ptrdiff_t m_paramIndex = 0x14C; // CAnimParamHandle
+ constexpr std::ptrdiff_t m_hSequence = 0x150; // HSequence
+ constexpr std::ptrdiff_t m_bResetChild = 0x154; // bool
+ constexpr std::ptrdiff_t m_bLockWhenWaning = 0x155; // bool
+}
+
+namespace CAnimActionUpdater {
+}
+
+namespace CAnimActivity {
+ constexpr std::ptrdiff_t m_name = 0x0; // CBufferString
+ constexpr std::ptrdiff_t m_nActivity = 0x10; // int32_t
+ constexpr std::ptrdiff_t m_nFlags = 0x14; // int32_t
+ constexpr std::ptrdiff_t m_nWeight = 0x18; // int32_t
+}
+
+namespace CAnimAttachment {
+ constexpr std::ptrdiff_t m_influenceRotations = 0x0; // Quaternion[3]
+ constexpr std::ptrdiff_t m_influenceOffsets = 0x30; // VectorAligned[3]
+ constexpr std::ptrdiff_t m_influenceIndices = 0x60; // int32_t[3]
+ constexpr std::ptrdiff_t m_influenceWeights = 0x6C; // float[3]
+ constexpr std::ptrdiff_t m_numInfluences = 0x78; // uint8_t
+}
+
+namespace CAnimBone {
+ constexpr std::ptrdiff_t m_name = 0x0; // CBufferString
+ constexpr std::ptrdiff_t m_parent = 0x10; // int32_t
+ constexpr std::ptrdiff_t m_pos = 0x14; // Vector
+ constexpr std::ptrdiff_t m_quat = 0x20; // QuaternionStorage
+ constexpr std::ptrdiff_t m_scale = 0x30; // float
+ constexpr std::ptrdiff_t m_qAlignment = 0x34; // QuaternionStorage
+ constexpr std::ptrdiff_t m_flags = 0x44; // int32_t
+}
+
+namespace CAnimBoneDifference {
+ constexpr std::ptrdiff_t m_name = 0x0; // CBufferString
+ constexpr std::ptrdiff_t m_parent = 0x10; // CBufferString
+ constexpr std::ptrdiff_t m_posError = 0x20; // Vector
+ constexpr std::ptrdiff_t m_bHasRotation = 0x2C; // bool
+ constexpr std::ptrdiff_t m_bHasMovement = 0x2D; // bool
+}
+
+namespace CAnimComponentUpdater {
+ constexpr std::ptrdiff_t m_name = 0x18; // CUtlString
+ constexpr std::ptrdiff_t m_id = 0x20; // AnimComponentID
+ constexpr std::ptrdiff_t m_networkMode = 0x24; // AnimNodeNetworkMode
+ constexpr std::ptrdiff_t m_bStartEnabled = 0x28; // bool
+}
+
+namespace CAnimCycle { // CCycleBase
+}
+
+namespace CAnimData {
+ constexpr std::ptrdiff_t m_name = 0x10; // CBufferString
+ constexpr std::ptrdiff_t m_animArray = 0x20; // CUtlVector
+ constexpr std::ptrdiff_t m_decoderArray = 0x38; // CUtlVector
+ constexpr std::ptrdiff_t m_nMaxUniqueFrameIndex = 0x50; // int32_t
+ constexpr std::ptrdiff_t m_segmentArray = 0x58; // CUtlVector
+}
+
+namespace CAnimDataChannelDesc {
+ constexpr std::ptrdiff_t m_szChannelClass = 0x0; // CBufferString
+ constexpr std::ptrdiff_t m_szVariableName = 0x10; // CBufferString
+ constexpr std::ptrdiff_t m_nFlags = 0x20; // int32_t
+ constexpr std::ptrdiff_t m_nType = 0x24; // int32_t
+ constexpr std::ptrdiff_t m_szGrouping = 0x28; // CBufferString
+ constexpr std::ptrdiff_t m_szDescription = 0x38; // CBufferString
+ constexpr std::ptrdiff_t m_szElementNameArray = 0x48; // CUtlVector
+ constexpr std::ptrdiff_t m_nElementIndexArray = 0x60; // CUtlVector
+ constexpr std::ptrdiff_t m_nElementMaskArray = 0x78; // CUtlVector
+}
+
+namespace CAnimDecoder {
+ constexpr std::ptrdiff_t m_szName = 0x0; // CBufferString
+ constexpr std::ptrdiff_t m_nVersion = 0x10; // int32_t
+ constexpr std::ptrdiff_t m_nType = 0x14; // int32_t
+}
+
+namespace CAnimDemoCaptureSettings {
+ constexpr std::ptrdiff_t m_rangeBoneChainLength = 0x0; // Vector2D
+ constexpr std::ptrdiff_t m_rangeMaxSplineErrorRotation = 0x8; // Vector2D
+ constexpr std::ptrdiff_t m_flMaxSplineErrorTranslation = 0x10; // float
+ constexpr std::ptrdiff_t m_flMaxSplineErrorScale = 0x14; // float
+ constexpr std::ptrdiff_t m_flIkRotation_MaxSplineError = 0x18; // float
+ constexpr std::ptrdiff_t m_flIkTranslation_MaxSplineError = 0x1C; // float
+ constexpr std::ptrdiff_t m_flMaxQuantizationErrorRotation = 0x20; // float
+ constexpr std::ptrdiff_t m_flMaxQuantizationErrorTranslation = 0x24; // float
+ constexpr std::ptrdiff_t m_flMaxQuantizationErrorScale = 0x28; // float
+ constexpr std::ptrdiff_t m_flIkRotation_MaxQuantizationError = 0x2C; // float
+ constexpr std::ptrdiff_t m_flIkTranslation_MaxQuantizationError = 0x30; // float
+ constexpr std::ptrdiff_t m_baseSequence = 0x38; // CUtlString
+ constexpr std::ptrdiff_t m_nBaseSequenceFrame = 0x40; // int32_t
+ constexpr std::ptrdiff_t m_boneSelectionMode = 0x44; // EDemoBoneSelectionMode
+ constexpr std::ptrdiff_t m_bones = 0x48; // CUtlVector
+ constexpr std::ptrdiff_t m_ikChains = 0x60; // CUtlVector
+}
+
+namespace CAnimDesc {
+ constexpr std::ptrdiff_t m_name = 0x0; // CBufferString
+ constexpr std::ptrdiff_t m_flags = 0x10; // CAnimDesc_Flag
+ constexpr std::ptrdiff_t fps = 0x18; // float
+ constexpr std::ptrdiff_t m_Data = 0x20; // CAnimEncodedFrames
+ constexpr std::ptrdiff_t m_movementArray = 0xF8; // CUtlVector
+ constexpr std::ptrdiff_t m_eventArray = 0x110; // CUtlVector
+ constexpr std::ptrdiff_t m_activityArray = 0x128; // CUtlVector
+ constexpr std::ptrdiff_t m_hierarchyArray = 0x140; // CUtlVector
+ constexpr std::ptrdiff_t framestalltime = 0x158; // float
+ constexpr std::ptrdiff_t m_vecRootMin = 0x15C; // Vector
+ constexpr std::ptrdiff_t m_vecRootMax = 0x168; // Vector
+ constexpr std::ptrdiff_t m_vecBoneWorldMin = 0x178; // CUtlVector
+ constexpr std::ptrdiff_t m_vecBoneWorldMax = 0x190; // CUtlVector
+ constexpr std::ptrdiff_t m_sequenceParams = 0x1A8; // CAnimSequenceParams
+}
+
+namespace CAnimDesc_Flag {
+ constexpr std::ptrdiff_t m_bLooping = 0x0; // bool
+ constexpr std::ptrdiff_t m_bAllZeros = 0x1; // bool
+ constexpr std::ptrdiff_t m_bHidden = 0x2; // bool
+ constexpr std::ptrdiff_t m_bDelta = 0x3; // bool
+ constexpr std::ptrdiff_t m_bLegacyWorldspace = 0x4; // bool
+ constexpr std::ptrdiff_t m_bModelDoc = 0x5; // bool
+ constexpr std::ptrdiff_t m_bImplicitSeqIgnoreDelta = 0x6; // bool
+ constexpr std::ptrdiff_t m_bAnimGraphAdditive = 0x7; // bool
+}
+
+namespace CAnimEncodeDifference {
+ constexpr std::ptrdiff_t m_boneArray = 0x0; // CUtlVector
+ constexpr std::ptrdiff_t m_morphArray = 0x18; // CUtlVector
+ constexpr std::ptrdiff_t m_userArray = 0x30; // CUtlVector
+ constexpr std::ptrdiff_t m_bHasRotationBitArray = 0x48; // CUtlVector
+ constexpr std::ptrdiff_t m_bHasMovementBitArray = 0x60; // CUtlVector
+ constexpr std::ptrdiff_t m_bHasMorphBitArray = 0x78; // CUtlVector
+ constexpr std::ptrdiff_t m_bHasUserBitArray = 0x90; // CUtlVector
+}
+
+namespace CAnimEncodedFrames {
+ constexpr std::ptrdiff_t m_fileName = 0x0; // CBufferString
+ constexpr std::ptrdiff_t m_nFrames = 0x10; // int32_t
+ constexpr std::ptrdiff_t m_nFramesPerBlock = 0x14; // int32_t
+ constexpr std::ptrdiff_t m_frameblockArray = 0x18; // CUtlVector
+ constexpr std::ptrdiff_t m_usageDifferences = 0x30; // CAnimEncodeDifference
+}
+
+namespace CAnimEnum {
+ constexpr std::ptrdiff_t m_value = 0x0; // uint8_t
+}
+
+namespace CAnimEventDefinition {
+ constexpr std::ptrdiff_t m_nFrame = 0x8; // int32_t
+ constexpr std::ptrdiff_t m_flCycle = 0xC; // float
+ constexpr std::ptrdiff_t m_EventData = 0x10; // KeyValues3
+ constexpr std::ptrdiff_t m_sLegacyOptions = 0x20; // CBufferString
+ constexpr std::ptrdiff_t m_sEventName = 0x30; // CGlobalSymbol
+}
+
+namespace CAnimFoot {
+ constexpr std::ptrdiff_t m_name = 0x0; // CUtlString
+ constexpr std::ptrdiff_t m_vBallOffset = 0x8; // Vector
+ constexpr std::ptrdiff_t m_vHeelOffset = 0x14; // Vector
+ constexpr std::ptrdiff_t m_ankleBoneIndex = 0x20; // int32_t
+ constexpr std::ptrdiff_t m_toeBoneIndex = 0x24; // int32_t
+}
+
+namespace CAnimFrameBlockAnim {
+ constexpr std::ptrdiff_t m_nStartFrame = 0x0; // int32_t
+ constexpr std::ptrdiff_t m_nEndFrame = 0x4; // int32_t
+ constexpr std::ptrdiff_t m_segmentIndexArray = 0x8; // CUtlVector
+}
+
+namespace CAnimFrameSegment {
+ constexpr std::ptrdiff_t m_nUniqueFrameIndex = 0x0; // int32_t
+ constexpr std::ptrdiff_t m_nLocalElementMasks = 0x4; // uint32_t
+ constexpr std::ptrdiff_t m_nLocalChannel = 0x8; // int32_t
+ constexpr std::ptrdiff_t m_container = 0x10; // CUtlBinaryBlock
+}
+
+namespace CAnimGraphDebugReplay {
+ constexpr std::ptrdiff_t m_animGraphFileName = 0x40; // CUtlString
+ constexpr std::ptrdiff_t m_frameList = 0x48; // CUtlVector>
+ constexpr std::ptrdiff_t m_startIndex = 0x60; // int32_t
+ constexpr std::ptrdiff_t m_writeIndex = 0x64; // int32_t
+ constexpr std::ptrdiff_t m_frameCount = 0x68; // int32_t
+}
+
+namespace CAnimGraphModelBinding {
+ constexpr std::ptrdiff_t m_modelName = 0x8; // CUtlString
+ constexpr std::ptrdiff_t m_pSharedData = 0x10; // CSmartPtr
+}
+
+namespace CAnimGraphNetworkSettings { // CAnimGraphSettingsGroup
+ constexpr std::ptrdiff_t m_bNetworkingEnabled = 0x20; // bool
+}
+
+namespace CAnimGraphSettingsGroup {
+}
+
+namespace CAnimGraphSettingsManager {
+ constexpr std::ptrdiff_t m_settingsGroups = 0x18; // CUtlVector>
+}
+
+namespace CAnimInputDamping {
+ constexpr std::ptrdiff_t m_speedFunction = 0x8; // DampingSpeedFunction
+ constexpr std::ptrdiff_t m_fSpeedScale = 0xC; // float
+}
+
+namespace CAnimKeyData {
+ constexpr std::ptrdiff_t m_name = 0x0; // CBufferString
+ constexpr std::ptrdiff_t m_boneArray = 0x10; // CUtlVector
+ constexpr std::ptrdiff_t m_userArray = 0x28; // CUtlVector
+ constexpr std::ptrdiff_t m_morphArray = 0x40; // CUtlVector
+ constexpr std::ptrdiff_t m_nChannelElements = 0x58; // int32_t
+ constexpr std::ptrdiff_t m_dataChannelArray = 0x60; // CUtlVector
+}
+
+namespace CAnimLocalHierarchy {
+ constexpr std::ptrdiff_t m_sBone = 0x0; // CBufferString
+ constexpr std::ptrdiff_t m_sNewParent = 0x10; // CBufferString
+ constexpr std::ptrdiff_t m_nStartFrame = 0x20; // int32_t
+ constexpr std::ptrdiff_t m_nPeakFrame = 0x24; // int32_t
+ constexpr std::ptrdiff_t m_nTailFrame = 0x28; // int32_t
+ constexpr std::ptrdiff_t m_nEndFrame = 0x2C; // int32_t
+}
+
+namespace CAnimMorphDifference {
+ constexpr std::ptrdiff_t m_name = 0x0; // CBufferString
+}
+
+namespace CAnimMotorUpdaterBase {
+ constexpr std::ptrdiff_t m_name = 0x10; // CUtlString
+ constexpr std::ptrdiff_t m_bDefault = 0x18; // bool
+}
+
+namespace CAnimMovement {
+ constexpr std::ptrdiff_t endframe = 0x0; // int32_t
+ constexpr std::ptrdiff_t motionflags = 0x4; // int32_t
+ constexpr std::ptrdiff_t v0 = 0x8; // float
+ constexpr std::ptrdiff_t v1 = 0xC; // float
+ constexpr std::ptrdiff_t angle = 0x10; // float
+ constexpr std::ptrdiff_t vector = 0x14; // Vector
+ constexpr std::ptrdiff_t position = 0x20; // Vector
+}
+
+namespace CAnimNodePath {
+ constexpr std::ptrdiff_t m_path = 0x0; // AnimNodeID[11]
+ constexpr std::ptrdiff_t m_nCount = 0x2C; // int32_t
+}
+
+namespace CAnimParamHandle {
+ constexpr std::ptrdiff_t m_type = 0x0; // AnimParamType_t
+ constexpr std::ptrdiff_t m_index = 0x1; // uint8_t
+}
+
+namespace CAnimParamHandleMap {
+ constexpr std::ptrdiff_t m_list = 0x0; // CUtlHashtable
+}
+
+namespace CAnimParameterBase {
+ constexpr std::ptrdiff_t m_name = 0x18; // CGlobalSymbol
+ constexpr std::ptrdiff_t m_group = 0x20; // CUtlString
+ constexpr std::ptrdiff_t m_id = 0x28; // AnimParamID
+ constexpr std::ptrdiff_t m_componentName = 0x40; // CUtlString
+ constexpr std::ptrdiff_t m_bNetworkingRequested = 0x4C; // bool
+ constexpr std::ptrdiff_t m_bIsReferenced = 0x4D; // bool
+}
+
+namespace CAnimParameterManagerUpdater {
+ constexpr std::ptrdiff_t m_parameters = 0x18; // CUtlVector>
+ constexpr std::ptrdiff_t m_idToIndexMap = 0x30; // CUtlHashtable
+ constexpr std::ptrdiff_t m_nameToIndexMap = 0x50; // CUtlHashtable
+ constexpr std::ptrdiff_t m_indexToHandle = 0x70; // CUtlVector
+ constexpr std::ptrdiff_t m_autoResetParams = 0x88; // CUtlVector>
+ constexpr std::ptrdiff_t m_autoResetMap = 0xA0; // CUtlHashtable
+}
+
+namespace CAnimReplayFrame {
+ constexpr std::ptrdiff_t m_inputDataBlocks = 0x10; // CUtlVector
+ constexpr std::ptrdiff_t m_instanceData = 0x28; // CUtlBinaryBlock
+ constexpr std::ptrdiff_t m_startingLocalToWorldTransform = 0x40; // CTransform
+ constexpr std::ptrdiff_t m_localToWorldTransform = 0x60; // CTransform
+ constexpr std::ptrdiff_t m_timeStamp = 0x80; // float
+}
+
+namespace CAnimScriptComponentUpdater { // CAnimComponentUpdater
+ constexpr std::ptrdiff_t m_hScript = 0x30; // AnimScriptHandle
+}
+
+namespace CAnimScriptManager {
+ constexpr std::ptrdiff_t m_scriptInfo = 0x10; // CUtlVector
+}
+
+namespace CAnimSequenceParams {
+ constexpr std::ptrdiff_t m_flFadeInTime = 0x0; // float
+ constexpr std::ptrdiff_t m_flFadeOutTime = 0x4; // float
+}
+
+namespace CAnimSkeleton {
+ constexpr std::ptrdiff_t m_localSpaceTransforms = 0x10; // CUtlVector
+ constexpr std::ptrdiff_t m_modelSpaceTransforms = 0x28; // CUtlVector
+ constexpr std::ptrdiff_t m_boneNames = 0x40; // CUtlVector
+ constexpr std::ptrdiff_t m_children = 0x58; // CUtlVector>
+ constexpr std::ptrdiff_t m_parents = 0x70; // CUtlVector
+ constexpr std::ptrdiff_t m_feet = 0x88; // CUtlVector
+ constexpr std::ptrdiff_t m_morphNames = 0xA0; // CUtlVector
+ constexpr std::ptrdiff_t m_lodBoneCounts = 0xB8; // CUtlVector
+}
+
+namespace CAnimStateMachineUpdater {
+ constexpr std::ptrdiff_t m_states = 0x8; // CUtlVector
+ constexpr std::ptrdiff_t m_transitions = 0x20; // CUtlVector
+ constexpr std::ptrdiff_t m_startStateIndex = 0x50; // int32_t
+}
+
+namespace CAnimTagBase {
+ constexpr std::ptrdiff_t m_name = 0x18; // CGlobalSymbol
+ constexpr std::ptrdiff_t m_group = 0x20; // CGlobalSymbol
+ constexpr std::ptrdiff_t m_tagID = 0x28; // AnimTagID
+ constexpr std::ptrdiff_t m_bIsReferenced = 0x2C; // bool
+}
+
+namespace CAnimTagManagerUpdater {
+ constexpr std::ptrdiff_t m_tags = 0x18; // CUtlVector>
+}
+
+namespace CAnimUpdateNodeBase {
+ constexpr std::ptrdiff_t m_nodePath = 0x18; // CAnimNodePath
+ constexpr std::ptrdiff_t m_networkMode = 0x48; // AnimNodeNetworkMode
+ constexpr std::ptrdiff_t m_name = 0x50; // CUtlString
+}
+
+namespace CAnimUpdateNodeRef {
+ constexpr std::ptrdiff_t m_nodeIndex = 0x8; // int32_t
+}
+
+namespace CAnimUpdateSharedData {
+ constexpr std::ptrdiff_t m_nodes = 0x10; // CUtlVector>
+ constexpr std::ptrdiff_t m_nodeIndexMap = 0x28; // CUtlHashtable
+ constexpr std::ptrdiff_t m_components = 0x48; // CUtlVector>
+ constexpr std::ptrdiff_t m_pParamListUpdater = 0x60; // CSmartPtr
+ constexpr std::ptrdiff_t m_pTagManagerUpdater = 0x68; // CSmartPtr
+ constexpr std::ptrdiff_t m_scriptManager = 0x70; // CSmartPtr
+ constexpr std::ptrdiff_t m_settings = 0x78; // CAnimGraphSettingsManager
+ constexpr std::ptrdiff_t m_pStaticPoseCache = 0xA8; // CSmartPtr
+ constexpr std::ptrdiff_t m_pSkeleton = 0xB0; // CSmartPtr
+ constexpr std::ptrdiff_t m_rootNodePath = 0xB8; // CAnimNodePath
+}
+
+namespace CAnimUser {
+ constexpr std::ptrdiff_t m_name = 0x0; // CBufferString
+ constexpr std::ptrdiff_t m_nType = 0x10; // int32_t
+}
+
+namespace CAnimUserDifference {
+ constexpr std::ptrdiff_t m_name = 0x0; // CBufferString
+ constexpr std::ptrdiff_t m_nType = 0x10; // int32_t
+}
+
+namespace CAnimationGraphVisualizerAxis { // CAnimationGraphVisualizerPrimitiveBase
+ constexpr std::ptrdiff_t m_xWsTransform = 0x40; // CTransform
+ constexpr std::ptrdiff_t m_flAxisSize = 0x60; // float
+}
+
+namespace CAnimationGraphVisualizerLine { // CAnimationGraphVisualizerPrimitiveBase
+ constexpr std::ptrdiff_t m_vWsPositionStart = 0x40; // VectorAligned
+ constexpr std::ptrdiff_t m_vWsPositionEnd = 0x50; // VectorAligned
+ constexpr std::ptrdiff_t m_Color = 0x60; // Color
+}
+
+namespace CAnimationGraphVisualizerPie { // CAnimationGraphVisualizerPrimitiveBase
+ constexpr std::ptrdiff_t m_vWsCenter = 0x40; // VectorAligned
+ constexpr std::ptrdiff_t m_vWsStart = 0x50; // VectorAligned
+ constexpr std::ptrdiff_t m_vWsEnd = 0x60; // VectorAligned
+ constexpr std::ptrdiff_t m_Color = 0x70; // Color
+}
+
+namespace CAnimationGraphVisualizerPrimitiveBase {
+ constexpr std::ptrdiff_t m_Type = 0x8; // CAnimationGraphVisualizerPrimitiveType
+ constexpr std::ptrdiff_t m_OwningAnimNodePaths = 0xC; // AnimNodeID[11]
+ constexpr std::ptrdiff_t m_nOwningAnimNodePathCount = 0x38; // int32_t
+}
+
+namespace CAnimationGraphVisualizerSphere { // CAnimationGraphVisualizerPrimitiveBase
+ constexpr std::ptrdiff_t m_vWsPosition = 0x40; // VectorAligned
+ constexpr std::ptrdiff_t m_flRadius = 0x50; // float
+ constexpr std::ptrdiff_t m_Color = 0x54; // Color
+}
+
+namespace CAnimationGraphVisualizerText { // CAnimationGraphVisualizerPrimitiveBase
+ constexpr std::ptrdiff_t m_vWsPosition = 0x40; // VectorAligned
+ constexpr std::ptrdiff_t m_Color = 0x50; // Color
+ constexpr std::ptrdiff_t m_Text = 0x58; // CUtlString
+}
+
+namespace CAnimationGroup {
+ constexpr std::ptrdiff_t m_nFlags = 0x10; // uint32_t
+ constexpr std::ptrdiff_t m_name = 0x18; // CBufferString
+ constexpr std::ptrdiff_t m_localHAnimArray_Handle = 0x60; // CUtlVector>
+ constexpr std::ptrdiff_t m_includedGroupArray_Handle = 0x78; // CUtlVector>
+ constexpr std::ptrdiff_t m_directHSeqGroup_Handle = 0x90; // CStrongHandle
+ constexpr std::ptrdiff_t m_decodeKey = 0x98; // CAnimKeyData
+ constexpr std::ptrdiff_t m_szScripts = 0x110; // CUtlVector
+}
+
+namespace CAttachment {
+ constexpr std::ptrdiff_t m_name = 0x0; // CUtlString
+ constexpr std::ptrdiff_t m_influenceNames = 0x8; // CUtlString[3]
+ constexpr std::ptrdiff_t m_vInfluenceRotations = 0x20; // Quaternion[3]
+ constexpr std::ptrdiff_t m_vInfluenceOffsets = 0x50; // Vector[3]
+ constexpr std::ptrdiff_t m_influenceWeights = 0x74; // float[3]
+ constexpr std::ptrdiff_t m_bInfluenceRootTransform = 0x80; // bool[3]
+ constexpr std::ptrdiff_t m_nInfluences = 0x83; // uint8_t
+ constexpr std::ptrdiff_t m_bIgnoreRotation = 0x84; // bool
+}
+
+namespace CAudioAnimTag { // CAnimTagBase
+ constexpr std::ptrdiff_t m_clipName = 0x38; // CUtlString
+ constexpr std::ptrdiff_t m_attachmentName = 0x40; // CUtlString
+ constexpr std::ptrdiff_t m_flVolume = 0x48; // float
+ constexpr std::ptrdiff_t m_bStopWhenTagEnds = 0x4C; // bool
+ constexpr std::ptrdiff_t m_bStopWhenGraphEnds = 0x4D; // bool
+ constexpr std::ptrdiff_t m_bPlayOnServer = 0x4E; // bool
+ constexpr std::ptrdiff_t m_bPlayOnClient = 0x4F; // bool
+}
+
+namespace CBaseConstraint { // CBoneConstraintBase
+ constexpr std::ptrdiff_t m_name = 0x28; // CUtlString
+ constexpr std::ptrdiff_t m_vUpVector = 0x30; // Vector
+ constexpr std::ptrdiff_t m_slaves = 0x40; // CUtlVector
+ constexpr std::ptrdiff_t m_targets = 0x58; // CUtlVector
+}
+
+namespace CBinaryUpdateNode { // CAnimUpdateNodeBase
+ constexpr std::ptrdiff_t m_pChild1 = 0x58; // CAnimUpdateNodeRef
+ constexpr std::ptrdiff_t m_pChild2 = 0x68; // CAnimUpdateNodeRef
+ constexpr std::ptrdiff_t m_timingBehavior = 0x78; // BinaryNodeTiming
+ constexpr std::ptrdiff_t m_flTimingBlend = 0x7C; // float
+ constexpr std::ptrdiff_t m_bResetChild1 = 0x80; // bool
+ constexpr std::ptrdiff_t m_bResetChild2 = 0x81; // bool
+}
+
+namespace CBindPoseUpdateNode { // CLeafUpdateNode
+}
+
+namespace CBlend2DUpdateNode { // CAnimUpdateNodeBase
+ constexpr std::ptrdiff_t m_items = 0x60; // CUtlVector
+ constexpr std::ptrdiff_t m_tags = 0x78; // CUtlVector
+ constexpr std::ptrdiff_t m_paramSpans = 0x90; // CParamSpanUpdater
+ constexpr std::ptrdiff_t m_nodeItemIndices = 0xA8; // CUtlVector
+ constexpr std::ptrdiff_t m_damping = 0xC0; // CAnimInputDamping
+ constexpr std::ptrdiff_t m_blendSourceX = 0xD0; // AnimValueSource
+ constexpr std::ptrdiff_t m_paramX = 0xD4; // CAnimParamHandle
+ constexpr std::ptrdiff_t m_blendSourceY = 0xD8; // AnimValueSource
+ constexpr std::ptrdiff_t m_paramY = 0xDC; // CAnimParamHandle
+ constexpr std::ptrdiff_t m_eBlendMode = 0xE0; // Blend2DMode
+ constexpr std::ptrdiff_t m_playbackSpeed = 0xE4; // float
+ constexpr std::ptrdiff_t m_bLoop = 0xE8; // bool
+ constexpr std::ptrdiff_t m_bLockBlendOnReset = 0xE9; // bool
+ constexpr std::ptrdiff_t m_bLockWhenWaning = 0xEA; // bool
+ constexpr std::ptrdiff_t m_bAnimEventsAndTagsOnMostWeightedOnly = 0xEB; // bool
+}
+
+namespace CBlendCurve {
+ constexpr std::ptrdiff_t m_flControlPoint1 = 0x0; // float
+ constexpr std::ptrdiff_t m_flControlPoint2 = 0x4; // float
+}
+
+namespace CBlendUpdateNode { // CAnimUpdateNodeBase
+ constexpr std::ptrdiff_t m_children = 0x60; // CUtlVector
+ constexpr std::ptrdiff_t m_sortedOrder = 0x78; // CUtlVector
+ constexpr std::ptrdiff_t m_targetValues = 0x90; // CUtlVector
+ constexpr std::ptrdiff_t m_blendValueSource = 0xAC; // AnimValueSource
+ constexpr std::ptrdiff_t m_paramIndex = 0xB0; // CAnimParamHandle
+ constexpr std::ptrdiff_t m_damping = 0xB8; // CAnimInputDamping
+ constexpr std::ptrdiff_t m_blendKeyType = 0xC8; // BlendKeyType
+ constexpr std::ptrdiff_t m_bLockBlendOnReset = 0xCC; // bool
+ constexpr std::ptrdiff_t m_bSyncCycles = 0xCD; // bool
+ constexpr std::ptrdiff_t m_bLoop = 0xCE; // bool
+ constexpr std::ptrdiff_t m_bLockWhenWaning = 0xCF; // bool
+}
+
+namespace CBlockSelectionMetricEvaluator { // CMotionMetricEvaluator
+}
+
+namespace CBodyGroupAnimTag { // CAnimTagBase
+ constexpr std::ptrdiff_t m_nPriority = 0x38; // int32_t
+ constexpr std::ptrdiff_t m_bodyGroupSettings = 0x40; // CUtlVector
+}
+
+namespace CBodyGroupSetting {
+ constexpr std::ptrdiff_t m_BodyGroupName = 0x0; // CUtlString
+ constexpr std::ptrdiff_t m_nBodyGroupOption = 0x8; // int32_t
+}
+
+namespace CBoneConstraintBase {
+}
+
+namespace CBoneConstraintDotToMorph { // CBoneConstraintBase
+ constexpr std::ptrdiff_t m_sBoneName = 0x28; // CUtlString
+ constexpr std::ptrdiff_t m_sTargetBoneName = 0x30; // CUtlString
+ constexpr std::ptrdiff_t m_sMorphChannelName = 0x38; // CUtlString
+ constexpr std::ptrdiff_t m_flRemap = 0x40; // float[4]
+}
+
+namespace CBoneConstraintPoseSpaceBone { // CBaseConstraint
+ constexpr std::ptrdiff_t m_inputList = 0x70; // CUtlVector
+}
+
+namespace CBoneConstraintPoseSpaceBone_Input_t {
+ constexpr std::ptrdiff_t m_inputValue = 0x0; // Vector
+ constexpr std::ptrdiff_t m_outputTransformList = 0x10; // CUtlVector
+}
+
+namespace CBoneConstraintPoseSpaceMorph { // CBoneConstraintBase
+ constexpr std::ptrdiff_t m_sBoneName = 0x28; // CUtlString
+ constexpr std::ptrdiff_t m_sAttachmentName = 0x30; // CUtlString
+ constexpr std::ptrdiff_t m_outputMorph = 0x38; // CUtlVector
+ constexpr std::ptrdiff_t m_inputList = 0x50; // CUtlVector
+ constexpr std::ptrdiff_t m_bClamp = 0x68; // bool
+}
+
+namespace CBoneConstraintPoseSpaceMorph_Input_t {
+ constexpr std::ptrdiff_t m_inputValue = 0x0; // Vector
+ constexpr std::ptrdiff_t m_outputWeightList = 0x10; // CUtlVector
+}
+
+namespace CBoneMaskUpdateNode { // CBinaryUpdateNode
+ constexpr std::ptrdiff_t m_nWeightListIndex = 0x8C; // int32_t
+ constexpr std::ptrdiff_t m_flRootMotionBlend = 0x90; // float
+ constexpr std::ptrdiff_t m_blendSpace = 0x94; // BoneMaskBlendSpace
+ constexpr std::ptrdiff_t m_footMotionTiming = 0x98; // BinaryNodeChildOption
+ constexpr std::ptrdiff_t m_bUseBlendScale = 0x9C; // bool
+ constexpr std::ptrdiff_t m_blendValueSource = 0xA0; // AnimValueSource
+ constexpr std::ptrdiff_t m_hBlendParameter = 0xA4; // CAnimParamHandle
+}
+
+namespace CBonePositionMetricEvaluator { // CMotionMetricEvaluator
+ constexpr std::ptrdiff_t m_nBoneIndex = 0x50; // int32_t
+}
+
+namespace CBoneVelocityMetricEvaluator { // CMotionMetricEvaluator
+ constexpr std::ptrdiff_t m_nBoneIndex = 0x50; // int32_t
+}
+
+namespace CBoolAnimParameter { // CConcreteAnimParameter
+ constexpr std::ptrdiff_t m_bDefaultValue = 0x60; // bool
+}
+
+namespace CCPPScriptComponentUpdater { // CAnimComponentUpdater
+ constexpr std::ptrdiff_t m_scriptsToRun = 0x30; // CUtlVector
+}
+
+namespace CCachedPose {
+ constexpr std::ptrdiff_t m_transforms = 0x8; // CUtlVector
+ constexpr std::ptrdiff_t m_morphWeights = 0x20; // CUtlVector
+ constexpr std::ptrdiff_t m_hSequence = 0x38; // HSequence
+ constexpr std::ptrdiff_t m_flCycle = 0x3C; // float
+}
+
+namespace CChoiceUpdateNode { // CAnimUpdateNodeBase
+ constexpr std::ptrdiff_t m_children = 0x58; // CUtlVector
+ constexpr std::ptrdiff_t m_weights = 0x70; // CUtlVector
+ constexpr std::ptrdiff_t m_blendTimes = 0x88; // CUtlVector
+ constexpr std::ptrdiff_t m_choiceMethod = 0xA0; // ChoiceMethod
+ constexpr std::ptrdiff_t m_choiceChangeMethod = 0xA4; // ChoiceChangeMethod
+ constexpr std::ptrdiff_t m_blendMethod = 0xA8; // ChoiceBlendMethod
+ constexpr std::ptrdiff_t m_blendTime = 0xAC; // float
+ constexpr std::ptrdiff_t m_bCrossFade = 0xB0; // bool
+ constexpr std::ptrdiff_t m_bResetChosen = 0xB1; // bool
+ constexpr std::ptrdiff_t m_bDontResetSameSelection = 0xB2; // bool
+}
+
+namespace CChoreoUpdateNode { // CUnaryUpdateNode
+}
+
+namespace CClothSettingsAnimTag { // CAnimTagBase
+ constexpr std::ptrdiff_t m_flStiffness = 0x38; // float
+ constexpr std::ptrdiff_t m_flEaseIn = 0x3C; // float
+ constexpr std::ptrdiff_t m_flEaseOut = 0x40; // float
+ constexpr std::ptrdiff_t m_nVertexSet = 0x48; // CUtlString
+}
+
+namespace CCompressorGroup {
+ constexpr std::ptrdiff_t m_nTotalElementCount = 0x0; // int32_t
+ constexpr std::ptrdiff_t m_szChannelClass = 0x8; // CUtlVector
+ constexpr std::ptrdiff_t m_szVariableName = 0x20; // CUtlVector
+ constexpr std::ptrdiff_t m_nType = 0x38; // CUtlVector
+ constexpr std::ptrdiff_t m_nFlags = 0x50; // CUtlVector
+ constexpr std::ptrdiff_t m_szGrouping = 0x68; // CUtlVector
+ constexpr std::ptrdiff_t m_nCompressorIndex = 0x80; // CUtlVector
+ constexpr std::ptrdiff_t m_szElementNames = 0x98; // CUtlVector>
+ constexpr std::ptrdiff_t m_nElementUniqueID = 0xB0; // CUtlVector>
+ constexpr std::ptrdiff_t m_nElementMask = 0xC8; // CUtlVector
+ constexpr std::ptrdiff_t m_vectorCompressor = 0xF8; // CUtlVector*>
+ constexpr std::ptrdiff_t m_quaternionCompressor = 0x110; // CUtlVector*>
+ constexpr std::ptrdiff_t m_intCompressor = 0x128; // CUtlVector*>
+ constexpr std::ptrdiff_t m_boolCompressor = 0x140; // CUtlVector*>
+ constexpr std::ptrdiff_t m_colorCompressor = 0x158; // CUtlVector*>
+ constexpr std::ptrdiff_t m_vector2DCompressor = 0x170; // CUtlVector*>
+ constexpr std::ptrdiff_t m_vector4DCompressor = 0x188; // CUtlVector*>
+}
+
+namespace CConcreteAnimParameter { // CAnimParameterBase
+ constexpr std::ptrdiff_t m_previewButton = 0x50; // AnimParamButton_t
+ constexpr std::ptrdiff_t m_eNetworkSetting = 0x54; // AnimParamNetworkSetting
+ constexpr std::ptrdiff_t m_bUseMostRecentValue = 0x58; // bool
+ constexpr std::ptrdiff_t m_bAutoReset = 0x59; // bool
+ constexpr std::ptrdiff_t m_bGameWritable = 0x5A; // bool
+ constexpr std::ptrdiff_t m_bGraphWritable = 0x5B; // bool
+}
+
+namespace CConstraintSlave {
+ constexpr std::ptrdiff_t m_qBaseOrientation = 0x0; // Quaternion
+ constexpr std::ptrdiff_t m_vBasePosition = 0x10; // Vector
+ constexpr std::ptrdiff_t m_nBoneHash = 0x1C; // uint32_t
+ constexpr std::ptrdiff_t m_flWeight = 0x20; // float
+ constexpr std::ptrdiff_t m_sName = 0x28; // CUtlString
+}
+
+namespace CConstraintTarget {
+ constexpr std::ptrdiff_t m_qOffset = 0x20; // Quaternion
+ constexpr std::ptrdiff_t m_vOffset = 0x30; // Vector
+ constexpr std::ptrdiff_t m_nBoneHash = 0x3C; // uint32_t
+ constexpr std::ptrdiff_t m_sName = 0x40; // CUtlString
+ constexpr std::ptrdiff_t m_flWeight = 0x48; // float
+ constexpr std::ptrdiff_t m_bIsAttachment = 0x59; // bool
+}
+
+namespace CCurrentRotationVelocityMetricEvaluator { // CMotionMetricEvaluator
+}
+
+namespace CCurrentVelocityMetricEvaluator { // CMotionMetricEvaluator
+}
+
+namespace CCycleBase {
+ constexpr std::ptrdiff_t m_flCycle = 0x0; // float
+}
+
+namespace CCycleControlClipUpdateNode { // CLeafUpdateNode
+ constexpr std::ptrdiff_t m_tags = 0x60; // CUtlVector
+ constexpr std::ptrdiff_t m_hSequence = 0x7C; // HSequence
+ constexpr std::ptrdiff_t m_duration = 0x80; // float
+ constexpr std::ptrdiff_t m_valueSource = 0x84; // AnimValueSource
+ constexpr std::ptrdiff_t m_paramIndex = 0x88; // CAnimParamHandle
+}
+
+namespace CCycleControlUpdateNode { // CUnaryUpdateNode
+ constexpr std::ptrdiff_t m_valueSource = 0x68; // AnimValueSource
+ constexpr std::ptrdiff_t m_paramIndex = 0x6C; // CAnimParamHandle
+}
+
+namespace CDampedPathAnimMotorUpdater { // CPathAnimMotorUpdaterBase
+ constexpr std::ptrdiff_t m_flAnticipationTime = 0x2C; // float
+ constexpr std::ptrdiff_t m_flMinSpeedScale = 0x30; // float
+ constexpr std::ptrdiff_t m_hAnticipationPosParam = 0x34; // CAnimParamHandle
+ constexpr std::ptrdiff_t m_hAnticipationHeadingParam = 0x36; // CAnimParamHandle
+ constexpr std::ptrdiff_t m_flSpringConstant = 0x38; // float
+ constexpr std::ptrdiff_t m_flMinSpringTension = 0x3C; // float
+ constexpr std::ptrdiff_t m_flMaxSpringTension = 0x40; // float
+}
+
+namespace CDampedValueComponentUpdater { // CAnimComponentUpdater
+ constexpr std::ptrdiff_t m_items = 0x30; // CUtlVector
+}
+
+namespace CDampedValueUpdateItem {
+ constexpr std::ptrdiff_t m_damping = 0x0; // CAnimInputDamping
+ constexpr std::ptrdiff_t m_hParamIn = 0x18; // CAnimParamHandle
+ constexpr std::ptrdiff_t m_hParamOut = 0x1A; // CAnimParamHandle
+}
+
+namespace CDemoSettingsComponentUpdater { // CAnimComponentUpdater
+ constexpr std::ptrdiff_t m_settings = 0x30; // CAnimDemoCaptureSettings
+}
+
+namespace CDirectPlaybackTagData {
+ constexpr std::ptrdiff_t m_sequenceName = 0x0; // CUtlString
+ constexpr std::ptrdiff_t m_tags = 0x8; // CUtlVector
+}
+
+namespace CDirectPlaybackUpdateNode { // CUnaryUpdateNode
+ constexpr std::ptrdiff_t m_bFinishEarly = 0x6C; // bool
+ constexpr std::ptrdiff_t m_bResetOnFinish = 0x6D; // bool
+ constexpr std::ptrdiff_t m_allTags = 0x70; // CUtlVector
+}
+
+namespace CDirectionalBlendUpdateNode { // CLeafUpdateNode
+ constexpr std::ptrdiff_t m_hSequences = 0x5C; // HSequence[8]
+ constexpr std::ptrdiff_t m_damping = 0x80; // CAnimInputDamping
+ constexpr std::ptrdiff_t m_blendValueSource = 0x90; // AnimValueSource
+ constexpr std::ptrdiff_t m_paramIndex = 0x94; // CAnimParamHandle
+ constexpr std::ptrdiff_t m_playbackSpeed = 0x98; // float
+ constexpr std::ptrdiff_t m_duration = 0x9C; // float
+ constexpr std::ptrdiff_t m_bLoop = 0xA0; // bool
+ constexpr std::ptrdiff_t m_bLockBlendOnReset = 0xA1; // bool
+}
+
+namespace CDistanceRemainingMetricEvaluator { // CMotionMetricEvaluator
+ constexpr std::ptrdiff_t m_flMaxDistance = 0x50; // float
+ constexpr std::ptrdiff_t m_flMinDistance = 0x54; // float
+ constexpr std::ptrdiff_t m_flStartGoalFilterDistance = 0x58; // float
+ constexpr std::ptrdiff_t m_flMaxGoalOvershootScale = 0x5C; // float
+ constexpr std::ptrdiff_t m_bFilterFixedMinDistance = 0x60; // bool
+ constexpr std::ptrdiff_t m_bFilterGoalDistance = 0x61; // bool
+ constexpr std::ptrdiff_t m_bFilterGoalOvershoot = 0x62; // bool
+}
+
+namespace CDrawCullingData {
+ constexpr std::ptrdiff_t m_vConeApex = 0x0; // Vector
+ constexpr std::ptrdiff_t m_ConeAxis = 0xC; // int8_t[3]
+ constexpr std::ptrdiff_t m_ConeCutoff = 0xF; // int8_t
+}
+
+namespace CEditableMotionGraph { // CMotionGraph
+}
+
+namespace CEmitTagActionUpdater { // CAnimActionUpdater
+ constexpr std::ptrdiff_t m_nTagIndex = 0x18; // int32_t
+ constexpr std::ptrdiff_t m_bIsZeroDuration = 0x1C; // bool
+}
+
+namespace CEnumAnimParameter { // CConcreteAnimParameter
+ constexpr std::ptrdiff_t m_defaultValue = 0x68; // uint8_t
+ constexpr std::ptrdiff_t m_enumOptions = 0x70; // CUtlVector
+}
+
+namespace CExpressionActionUpdater { // CAnimActionUpdater
+ constexpr std::ptrdiff_t m_hParam = 0x18; // CAnimParamHandle
+ constexpr std::ptrdiff_t m_eParamType = 0x1A; // AnimParamType_t
+ constexpr std::ptrdiff_t m_hScript = 0x1C; // AnimScriptHandle
+}
+
+namespace CFingerBone {
+ constexpr std::ptrdiff_t m_boneName = 0x0; // CUtlString
+ constexpr std::ptrdiff_t m_hingeAxis = 0x8; // Vector
+ constexpr std::ptrdiff_t m_vCapsulePos1 = 0x14; // Vector
+ constexpr std::ptrdiff_t m_vCapsulePos2 = 0x20; // Vector
+ constexpr std::ptrdiff_t m_flMinAngle = 0x2C; // float
+ constexpr std::ptrdiff_t m_flMaxAngle = 0x30; // float
+ constexpr std::ptrdiff_t m_flRadius = 0x34; // float
+}
+
+namespace CFingerChain {
+ constexpr std::ptrdiff_t m_targets = 0x0; // CUtlVector
+ constexpr std::ptrdiff_t m_bones = 0x18; // CUtlVector
+ constexpr std::ptrdiff_t m_name = 0x30; // CUtlString
+ constexpr std::ptrdiff_t m_tipParentBoneName = 0x38; // CUtlString
+ constexpr std::ptrdiff_t m_vTipOffset = 0x40; // Vector
+ constexpr std::ptrdiff_t m_metacarpalBoneName = 0x50; // CUtlString
+ constexpr std::ptrdiff_t m_vSplayHingeAxis = 0x58; // Vector
+ constexpr std::ptrdiff_t m_flSplayMinAngle = 0x64; // float
+ constexpr std::ptrdiff_t m_flSplayMaxAngle = 0x68; // float
+ constexpr std::ptrdiff_t m_flFingerScaleRatio = 0x6C; // float
+}
+
+namespace CFingerSource {
+ constexpr std::ptrdiff_t m_nFingerIndex = 0x0; // AnimVRFinger_t
+ constexpr std::ptrdiff_t m_flFingerWeight = 0x4; // float
+}
+
+namespace CFlexController {
+ constexpr std::ptrdiff_t m_szName = 0x0; // CUtlString
+ constexpr std::ptrdiff_t m_szType = 0x8; // CUtlString
+ constexpr std::ptrdiff_t min = 0x10; // float
+ constexpr std::ptrdiff_t max = 0x14; // float
+}
+
+namespace CFlexDesc {
+ constexpr std::ptrdiff_t m_szFacs = 0x0; // CUtlString
+}
+
+namespace CFlexOp {
+ constexpr std::ptrdiff_t m_OpCode = 0x0; // FlexOpCode_t
+ constexpr std::ptrdiff_t m_Data = 0x4; // int32_t
+}
+
+namespace CFlexRule {
+ constexpr std::ptrdiff_t m_nFlex = 0x0; // int32_t
+ constexpr std::ptrdiff_t m_FlexOps = 0x8; // CUtlVector
+}
+
+namespace CFloatAnimParameter { // CConcreteAnimParameter
+ constexpr std::ptrdiff_t m_fDefaultValue = 0x60; // float
+ constexpr std::ptrdiff_t m_fMinValue = 0x64; // float
+ constexpr std::ptrdiff_t m_fMaxValue = 0x68; // float
+ constexpr std::ptrdiff_t m_bInterpolate = 0x6C; // bool
+}
+
+namespace CFollowAttachmentUpdateNode { // CUnaryUpdateNode
+ constexpr std::ptrdiff_t m_opFixedData = 0x70; // FollowAttachmentSettings_t
+}
+
+namespace CFollowPathUpdateNode { // CUnaryUpdateNode
+ constexpr std::ptrdiff_t m_flBlendOutTime = 0x6C; // float
+ constexpr std::ptrdiff_t m_bBlockNonPathMovement = 0x70; // bool
+ constexpr std::ptrdiff_t m_bStopFeetAtGoal = 0x71; // bool
+ constexpr std::ptrdiff_t m_bScaleSpeed = 0x72; // bool
+ constexpr std::ptrdiff_t m_flScale = 0x74; // float
+ constexpr std::ptrdiff_t m_flMinAngle = 0x78; // float
+ constexpr std::ptrdiff_t m_flMaxAngle = 0x7C; // float
+ constexpr std::ptrdiff_t m_flSpeedScaleBlending = 0x80; // float
+ constexpr std::ptrdiff_t m_turnDamping = 0x88; // CAnimInputDamping
+ constexpr std::ptrdiff_t m_facingTarget = 0x98; // AnimValueSource
+ constexpr std::ptrdiff_t m_hParam = 0x9C; // CAnimParamHandle
+ constexpr std::ptrdiff_t m_flTurnToFaceOffset = 0xA0; // float
+ constexpr std::ptrdiff_t m_bTurnToFace = 0xA4; // bool
+}
+
+namespace CFootAdjustmentUpdateNode { // CUnaryUpdateNode
+ constexpr std::ptrdiff_t m_clips = 0x70; // CUtlVector
+ constexpr std::ptrdiff_t m_hBasePoseCacheHandle = 0x88; // CPoseHandle
+ constexpr std::ptrdiff_t m_facingTarget = 0x8C; // CAnimParamHandle
+ constexpr std::ptrdiff_t m_flTurnTimeMin = 0x90; // float
+ constexpr std::ptrdiff_t m_flTurnTimeMax = 0x94; // float
+ constexpr std::ptrdiff_t m_flStepHeightMax = 0x98; // float
+ constexpr std::ptrdiff_t m_flStepHeightMaxAngle = 0x9C; // float
+ constexpr std::ptrdiff_t m_bResetChild = 0xA0; // bool
+ constexpr std::ptrdiff_t m_bAnimationDriven = 0xA1; // bool
+}
+
+namespace CFootCycle { // CCycleBase
+}
+
+namespace CFootCycleDefinition {
+ constexpr std::ptrdiff_t m_vStancePositionMS = 0x0; // Vector
+ constexpr std::ptrdiff_t m_vMidpointPositionMS = 0xC; // Vector
+ constexpr std::ptrdiff_t m_flStanceDirectionMS = 0x18; // float
+ constexpr std::ptrdiff_t m_vToStrideStartPos = 0x1C; // Vector
+ constexpr std::ptrdiff_t m_stanceCycle = 0x28; // CAnimCycle
+ constexpr std::ptrdiff_t m_footLiftCycle = 0x2C; // CFootCycle
+ constexpr std::ptrdiff_t m_footOffCycle = 0x30; // CFootCycle
+ constexpr std::ptrdiff_t m_footStrikeCycle = 0x34; // CFootCycle
+ constexpr std::ptrdiff_t m_footLandCycle = 0x38; // CFootCycle
+}
+
+namespace CFootCycleMetricEvaluator { // CMotionMetricEvaluator
+ constexpr std::ptrdiff_t m_footIndices = 0x50; // CUtlVector
+}
+
+namespace CFootDefinition {
+ constexpr std::ptrdiff_t m_name = 0x0; // CUtlString
+ constexpr std::ptrdiff_t m_ankleBoneName = 0x8; // CUtlString
+ constexpr std::ptrdiff_t m_toeBoneName = 0x10; // CUtlString
+ constexpr std::ptrdiff_t m_vBallOffset = 0x18; // Vector
+ constexpr std::ptrdiff_t m_vHeelOffset = 0x24; // Vector
+ constexpr std::ptrdiff_t m_flFootLength = 0x30; // float
+ constexpr std::ptrdiff_t m_flBindPoseDirectionMS = 0x34; // float
+ constexpr std::ptrdiff_t m_flTraceHeight = 0x38; // float
+ constexpr std::ptrdiff_t m_flTraceRadius = 0x3C; // float
+}
+
+namespace CFootFallAnimTag { // CAnimTagBase
+ constexpr std::ptrdiff_t m_foot = 0x38; // FootFallTagFoot_t
+}
+
+namespace CFootLockUpdateNode { // CUnaryUpdateNode
+ constexpr std::ptrdiff_t m_opFixedSettings = 0x68; // FootLockPoseOpFixedSettings
+ constexpr std::ptrdiff_t m_footSettings = 0xD0; // CUtlVector