first submle

结构体/内存读写/Syscall读写.h

@@ -0,0 +1,239 @@
+#include <string>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <pthread.h>
+#include <sys/socket.h>
+#include <sys/syscall.h>
+#include <sys/mman.h>
+#include <sys/uio.h>
+#include <malloc.h>
+#include <math.h>
+#include <thread>
+#include <iostream>
+#include <sys/stat.h>
+#include <errno.h>
+#include <netdb.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <string.h>
+#include <iostream>
+#include <locale>
+#include <string>
+#include <codecvt>
+#include <dlfcn.h>
+
+
+using namespace std;
+
+typedef long ADDRESS;
+typedef char PACKAGENAME;
+typedef unsigned short UTF16;
+typedef char UTF8;
+
+// syscall内存读写
+#if defined(__arm__)
+int process_vm_readv_syscall = 376;
+int process_vm_writev_syscall = 377;
+#elif defined(__aarch64__)
+int process_vm_readv_syscall = 270;
+int process_vm_writev_syscall = 271;
+#elif defined(__i386__)
+int process_vm_readv_syscall = 347;
+int process_vm_writev_syscall = 348;
+#else
+int process_vm_readv_syscall = 310;
+int process_vm_writev_syscall = 311;
+#endif
+
+ssize_t process_v1(pid_t __pid, const struct iovec *__local_iov, unsigned long __local_iov_count,
+				  const struct iovec *__remote_iov, unsigned long __remote_iov_count,
+				  unsigned long __flags, bool iswrite)
+{
+	return syscall((iswrite ? process_vm_writev_syscall : process_vm_readv_syscall), __pid,
+				   __local_iov, __local_iov_count, __remote_iov, __remote_iov_count, __flags);
+}
+
+// 进程读写内存
+bool pvm1(void *address, void *buffer, size_t size, bool iswrite)
+{
+	struct iovec local[1];
+	struct iovec remote[1];
+	local[0].iov_base = buffer;
+	local[0].iov_len = size;
+	remote[0].iov_base = address;
+	remote[0].iov_len = size;
+	ssize_t bytes = process_v1(getpid(), local, 1, remote, 1, 0, iswrite);
+	return bytes == size;
+}
+
+// 读取内存
+bool vm_readv(long address, void *buffer, size_t size)
+{
+	return pvm1(reinterpret_cast < void *>(address), buffer, size, false);
+}
+
+// 写入内存
+bool vm_writev(long address, void *buffer, size_t size)
+{
+	return pvm1(reinterpret_cast < void *>(address), buffer, size, true);
+}
+
+// 获取F类内存
+float getfloat(long addr)
+{
+	float var = 0;
+	vm_readv(addr, &var, 4);
+	return (var);
+}
+
+// 获取
+int getdword(long addr)
+{
+	int var = 0;
+	vm_readv(addr, &var, 4);
+	return (var);
+}
+
+// 获取
+bool getbool(long addr)
+{
+	bool var = 0;
+	vm_readv(addr, &var, 4);
+	return (var);
+}
+
+// 获取指针
+long getPointer(long addr)
+{
+	long var = 0;
+	vm_readv(addr, &var, 4);
+	return (var);
+}
+
+// 写入F类内存
+void writefloat(long addr, float data)
+{
+	vm_writev(addr, &data, 4);
+}
+
+bool WriteAddr(void *addr, void *buffer, size_t length) {
+    unsigned long page_size = sysconf(_SC_PAGESIZE);
+    unsigned long size = page_size * sizeof(uintptr_t);
+    return mprotect((void *) ((uintptr_t) addr - ((uintptr_t) addr % page_size) - page_size), (size_t) size, PROT_EXEC | PROT_READ | PROT_WRITE) == 0 && memcpy(addr, buffer, length) != 0;
+}
+bool WriteInt(uintptr_t addr,int var) {
+    return WriteAddr(reinterpret_cast<void*>(addr),reinterpret_cast<void*>(&var), sizeof(var));
+}
+
+// 写入D类内存
+void writedword(long addr, int data)
+{
+	vm_writev(addr, &data, 4);
+}
+
+// 获取进程
+int getProcessID(const char *packageName)
+{
+	int id = -1;
+	DIR *dir;
+	FILE *fp;
+	char filename[64];
+	char cmdline[64];
+	struct dirent *entry;
+	dir = opendir("/proc");
+	while ((entry = readdir(dir)) != NULL)
+	{
+		id = atoi(entry->d_name);
+		if (id != 0)
+		{
+			sprintf(filename, "/proc/%d/cmdline", id);
+			fp = fopen(filename, "r");
+			if (fp)
+			{
+				fgets(cmdline, sizeof(cmdline), fp);
+				fclose(fp);
+				if (strcmp(packageName, cmdline) == 0)
+				{
+					return id;
+				}
+			}
+		}
+	}
+	closedir(dir);
+	return -1;
+}
+
+// 获取基址
+long get_Module_Base(const char *module_name)
+{
+	FILE *fp;
+	long addr = 0;
+	char *pch;
+	char filename[64];
+	char line[1024];
+	snprintf(filename, sizeof(filename), "/proc/%d/maps", getpid());
+	fp = fopen(filename, "r");
+	if (fp != NULL)
+	{
+		while (fgets(line, sizeof(line), fp))
+		{
+			if (strstr(line, module_name))
+			{
+				pch = strtok(line, "-");
+				addr = strtoul(pch, NULL, 16);
+				if (addr == 0x8000)
+					addr = 0;
+				break;
+			}
+		}
+		fclose(fp);
+	}
+	return addr;
+}
+
+// 读取字符信息
+void getUTF8(char * buf, long namepy)
+{
+	UTF16 buf16[16] = { 0 };
+	vm_readv(namepy, buf16, 32);
+	UTF16 *pTempUTF16 = buf16;
+	UTF8 *pTempUTF8 = buf;
+	UTF8 *pUTF8End = pTempUTF8 + 32;
+	while (pTempUTF16 < pTempUTF16 + 28)
+	{
+		if (*pTempUTF16 <= 0x007F && pTempUTF8 + 1 < pUTF8End)
+		{
+			*pTempUTF8++ = (UTF8) * pTempUTF16;
+		}
+		else if (*pTempUTF16 >= 0x0080 && *pTempUTF16 <= 0x07FF && pTempUTF8 + 2 < pUTF8End)
+		{
+			*pTempUTF8++ = (*pTempUTF16 >> 6) | 0xC0;
+			*pTempUTF8++ = (*pTempUTF16 & 0x3F) | 0x80;
+		}
+		else if (*pTempUTF16 >= 0x0800 && *pTempUTF16 <= 0xFFFF && pTempUTF8 + 3 < pUTF8End)
+		{
+			*pTempUTF8++ = (*pTempUTF16 >> 12) | 0xE0;
+			*pTempUTF8++ = ((*pTempUTF16 >> 6) & 0x3F) | 0x80;
+			*pTempUTF8++ = (*pTempUTF16 & 0x3F) | 0x80;
+		}
+		else
+		{
+			break;
+		}
+		pTempUTF16++;
+	}
+}
+bool IsPtrValid(void *addr) {
+    if (!addr) {
+        return false;
+    }
+    static int fd = -1;
+    if (fd == -1) {
+        fd = open("/dev/random", O_WRONLY);
+    }
+    return write(fd, addr, 4) >= 0;
+}

结构体/函数/Quaternion.hpp

@@ -0,0 +1,703 @@
+#pragma once
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+#include <iostream>
+
+#define SMALL_float 0.0000000001
+
+
+/**
+ * Attempt to include a header file if the file exists.
+ * If the file does not exist, create a dummy data structure for that type.
+ * If it cannot be determined if it exists, just attempt to include it.
+ */
+#ifdef __has_include
+#   if __has_include("Vector3.hpp")
+#       include "Vector3.hpp"
+#   elif !defined(GMATH_VECTOR3)
+#define GMATH_VECTOR3
+        struct Vector3
+        {
+            union
+            {
+                struct
+                {
+                    float X;
+                    float Y;
+                    float Z;
+                };
+                float data[3];
+            };
+
+            inline Vector3() : X(0), Y(0), Z(0) {}
+            inline Vector3(float data[]) : X(data[0]), Y(data[1]), Z(data[2])
+                {}
+            inline Vector3(float value) : X(value), Y(value), Z(value) {}
+            inline Vector3(float x, float y) : X(x), Y(y), Z(0) {}
+            inline Vector3(float x, float y, float z) : X(x), Y(y), Z(z) {}
+
+            static inline Vector3 Cross(Vector3 lhs, Vector3 rhs)
+            {
+                float x = lhs.Y * rhs.Z - lhs.Z * rhs.Y;
+                float y = lhs.Z * rhs.X - lhs.X * rhs.Z;
+                float z = lhs.X * rhs.Y - lhs.Y * rhs.X;
+                return Vector3(x, y, z);
+            }
+
+            static inline float Dot(Vector3 lhs, Vector3 rhs)
+            {
+                return lhs.X * rhs.X + lhs.Y * rhs.Y + lhs.Z * rhs.Z;
+            }
+
+            static inline Vector3 Normalized(Vector3 v)
+            {
+                float mag = sqrt(v.X * v.X + v.Y * v.Y + v.Z * v.Z);
+                if (mag == 0)
+                    return Vector3::Zero();
+                return v / mag;
+            }
+
+            static inline Vector3 Orthogonal(Vector3 v)
+            {
+                return v.Z < v.X ?
+                    Vector3(v.Y, -v.X, 0) : Vector3(0, -v.Z, v.Y);
+            }
+
+            static inline float SqrMagnitude(Vector3 v)
+            {
+                return v.X * v.X + v.Y * v.Y + v.Z * v.Z;
+            }
+        };
+
+
+        inline Vector3 operator+(Vector3 lhs, const Vector3 rhs)
+        {
+            return Vector3(lhs.X + rhs.X, lhs.Y + rhs.Y, lhs.Z + rhs.Z);
+        }
+
+        inline Vector3 operator*(Vector3 lhs, const float rhs)
+        {
+            return Vector3(lhs.X * rhs, lhs.Y * rhs, lhs.Z * rhs);
+        }
+#   endif
+#else
+#   include "Vector3.hpp"
+#endif
+
+
+struct Quaternion
+{
+    union
+    {
+        struct
+        {
+            float X;
+            float Y;
+            float Z;
+            float W;
+        };
+        float data[4];
+    };
+
+
+    /**
+     * Constructors.
+     */
+    inline Quaternion();
+    inline Quaternion(float data[]);
+    inline Quaternion(Vector3 vector, float scalar);
+    inline Quaternion(float x, float y, float z, float w);
+
+
+    /**
+     * Constants for common quaternions.
+     */
+    static inline Quaternion Identity();
+
+
+    /**
+     * Returns the angle between two quaternions.
+     * The quaternions must be normalized.
+     * @param a: The first quaternion.
+     * @param b: The second quaternion.
+     * @return: A scalar value.
+     */
+    static inline float Angle(Quaternion a, Quaternion b);
+
+    /**
+     * Returns the conjugate of a quaternion.
+     * @param rotation: The quaternion in question.
+     * @return: A new quaternion.
+     */
+    static inline Quaternion Conjugate(Quaternion rotation);
+
+    /**
+     * Returns the dot product of two quaternions.
+     * @param lhs: The left side of the multiplication.
+     * @param rhs: The right side of the multiplication.
+     * @return: A scalar value.
+     */
+    static inline float Dot(Quaternion lhs, Quaternion rhs);
+
+    /**
+     * Creates a new quaternion from the angle-axis representation of
+     * a rotation.
+     * @param angle: The rotation angle in radians.
+     * @param axis: The vector about which the rotation occurs.
+     * @return: A new quaternion.
+     */
+    static inline Quaternion FromAngleAxis(float angle, Vector3 axis);
+
+    /**
+     * Create a new quaternion from the euler angle representation of
+     * a rotation. The z, x and y values represent rotations about those
+     * axis in that respective order.
+     * @param rotation: The x, y and z rotations.
+     * @return: A new quaternion.
+     */
+    static inline Quaternion FromEuler(Vector3 rotation);
+
+    /**
+     * Create a new quaternion from the euler angle representation of
+     * a rotation. The z, x and y values represent rotations about those
+     * axis in that respective order.
+     * @param x: The rotation about the x-axis in radians.
+     * @param y: The rotation about the y-axis in radians.
+     * @param z: The rotation about the z-axis in radians.
+     * @return: A new quaternion.
+     */
+    static inline Quaternion FromEuler(float x, float y, float z);
+
+    /**
+     * Create a quaternion rotation which rotates "fromVector" to "toVector".
+     * @param fromVector: The vector from which to start the rotation.
+     * @param toVector: The vector at which to end the rotation.
+     * @return: A new quaternion.
+     */
+    static inline Quaternion FromToRotation(Vector3 fromVector,
+                                            Vector3 toVector);
+
+    /**
+     * Returns the inverse of a rotation.
+     * @param rotation: The quaternion in question.
+     * @return: A new quaternion.
+     */
+    static inline Quaternion Inverse(Quaternion rotation);
+
+    /**
+     * Interpolates between a and b by t, which is clamped to the range [0-1].
+     * The result is normalized before being returned.
+     * @param a: The starting rotation.
+     * @param b: The ending rotation.
+     * @return: A new quaternion.
+     */
+    static inline Quaternion Lerp(Quaternion a, Quaternion b, float t);
+
+    /**
+     * Interpolates between a and b by t. This normalizes the result when
+     * complete.
+     * @param a: The starting rotation.
+     * @param b: The ending rotation.
+     * @param t: The interpolation value.
+     * @return: A new quaternion.
+     */
+    static inline Quaternion LerpUnclamped(Quaternion a, Quaternion b,
+                                           float t);
+
+    /**
+     * Creates a rotation with the specified forward direction. This is the
+     * same as calling LookRotation with (0, 1, 0) as the upwards vector.
+     * The output is undefined for parallel vectors.
+     * @param forward: The forward direction to look toward.
+     * @return: A new quaternion.
+     */
+    static inline Quaternion LookRotation(Vector3 forward);
+
+    /**
+     * Creates a rotation with the specified forward and upwards directions.
+     * The output is undefined for parallel vectors.
+     * @param forward: The forward direction to look toward.
+     * @param upwards: The direction to treat as up.
+     * @return: A new quaternion.
+     */
+    static inline Quaternion LookRotation(Vector3 forward, Vector3 upwards);
+
+    /**
+     * Returns the norm of a quaternion.
+     * @param rotation: The quaternion in question.
+     * @return: A scalar value.
+     */
+    static inline float Norm(Quaternion rotation);
+
+    /**
+     * Returns a quaternion with identical rotation and a norm of one.
+     * @param rotation: The quaternion in question.
+     * @return: A new quaternion.
+     */
+    static inline Quaternion Normalized(Quaternion rotation);
+
+    /**
+     * Returns a new Quaternion created by rotating "from" towards "to" by
+     * "maxRadiansDelta". This will not overshoot, and if a negative delta is
+     * applied, it will rotate till completely opposite "to" and then stop.
+     * @param from: The rotation at which to start.
+     * @param to: The rotation at which to end.
+     # @param maxRadiansDelta: The maximum number of radians to rotate.
+     * @return: A new Quaternion.
+     */
+    static inline Quaternion RotateTowards(Quaternion from, Quaternion to,
+                                           float maxRadiansDelta);
+
+    /**
+     * Returns a new quaternion interpolated between a and b, using spherical
+     * linear interpolation. The variable t is clamped to the range [0-1]. The
+     * resulting quaternion will be normalized.
+     * @param a: The starting rotation.
+     * @param b: The ending rotation.
+     * @param t: The interpolation value.
+     * @return: A new quaternion.
+     */
+    static inline Quaternion Slerp(Quaternion a, Quaternion b, float t);
+
+    /**
+     * Returns a new quaternion interpolated between a and b, using spherical
+     * linear interpolation. The resulting quaternion will be normalized.
+     * @param a: The starting rotation.
+     * @param b: The ending rotation.
+     * @param t: The interpolation value.
+     * @return: A new quaternion.
+     */
+    static inline Quaternion SlerpUnclamped(Quaternion a, Quaternion b,
+                                            float t);
+
+    /**
+     * Outputs the angle axis representation of the provided quaternion.
+     * @param rotation: The input quaternion.
+     * @param angle: The output angle.
+     * @param axis: The output axis.
+     */
+    static inline void ToAngleAxis(Quaternion rotation, float &angle,
+                                   Vector3 &axis);
+
+    /**
+     * Returns the Euler angle representation of a rotation. The resulting
+     * vector contains the rotations about the z, x and y axis, in that order.
+     * @param rotation: The quaternion to convert.
+     * @return: A new vector.
+     */
+    static inline Vector3 ToEuler(Quaternion rotation);
+
+    /**
+     * Operator overloading.
+     */
+    inline struct Quaternion& operator+=(const float rhs);
+    inline struct Quaternion& operator-=(const float rhs);
+    inline struct Quaternion& operator*=(const float rhs);
+    inline struct Quaternion& operator/=(const float rhs);
+    inline struct Quaternion& operator+=(const Quaternion rhs);
+    inline struct Quaternion& operator-=(const Quaternion rhs);
+    inline struct Quaternion& operator*=(const Quaternion rhs);
+};
+
+inline Quaternion operator-(Quaternion rhs);
+inline Quaternion operator+(Quaternion lhs, const float rhs);
+inline Quaternion operator-(Quaternion lhs, const float rhs);
+inline Quaternion operator*(Quaternion lhs, const float rhs);
+inline Quaternion operator/(Quaternion lhs, const float rhs);
+inline Quaternion operator+(const float lhs, Quaternion rhs);
+inline Quaternion operator-(const float lhs, Quaternion rhs);
+inline Quaternion operator*(const float lhs, Quaternion rhs);
+inline Quaternion operator/(const float lhs, Quaternion rhs);
+inline Quaternion operator+(Quaternion lhs, const Quaternion rhs);
+inline Quaternion operator-(Quaternion lhs, const Quaternion rhs);
+inline Quaternion operator*(Quaternion lhs, const Quaternion rhs);
+inline Vector3 operator*(Quaternion lhs, const Vector3 rhs);
+inline bool operator==(const Quaternion lhs, const Quaternion rhs);
+inline bool operator!=(const Quaternion lhs, const Quaternion rhs);
+
+
+
+/*******************************************************************************
+ * Implementation
+ */
+
+Quaternion::Quaternion() : X(0), Y(0), Z(0), W(1) {}
+Quaternion::Quaternion(float data[]) : X(data[0]), Y(data[1]), Z(data[2]),
+                                       W(data[3]) {}
+Quaternion::Quaternion(Vector3 vector, float scalar) : X(vector.X),
+                                                       Y(vector.Y), Z(vector.Z), W(scalar) {}
+Quaternion::Quaternion(float x, float y, float z, float w) : X(x), Y(y),
+                                                             Z(z), W(w) {}
+
+
+Quaternion Quaternion::Identity() { return Quaternion(0, 0, 0, 1); }
+
+
+float Quaternion::Angle(Quaternion a, Quaternion b)
+{
+    float dot = Dot(a, b);
+    return acos(fmin(fabs(dot), 1)) * 2;
+}
+
+Quaternion Quaternion::Conjugate(Quaternion rotation)
+{
+    return Quaternion(-rotation.X, -rotation.Y, -rotation.Z, rotation.W);
+}
+
+float Quaternion::Dot(Quaternion lhs, Quaternion rhs)
+{
+    return lhs.X * rhs.X + lhs.Y * rhs.Y + lhs.Z * rhs.Z + lhs.W * rhs.W;
+}
+
+Quaternion Quaternion::FromAngleAxis(float angle, Vector3 axis)
+{
+    Quaternion q;
+    float m = sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
+    float s = sin(angle / 2) / m;
+    q.X = axis.X * s;
+    q.Y = axis.Y * s;
+    q.Z = axis.Z * s;
+    q.W = cos(angle / 2);
+    return q;
+}
+
+Quaternion Quaternion::FromEuler(Vector3 rotation)
+{
+    return FromEuler(rotation.X, rotation.Y, rotation.Z);
+}
+
+Quaternion Quaternion::FromEuler(float x, float y, float z)
+{
+    float cx = cos(x * 0.5);
+    float cy = cos(y * 0.5);
+    float cz = cos(z * 0.5);
+    float sx = sin(x * 0.5);
+    float sy = sin(y * 0.5);
+    float sz = sin(z * 0.5);
+    Quaternion q;
+    q.X = cx * sy * sz + cy * cz * sx;
+    q.Y = cx * cz * sy - cy * sx * sz;
+    q.Z = cx * cy * sz - cz * sx * sy;
+    q.W = sx * sy * sz + cx * cy * cz;
+    return q;
+}
+
+Quaternion Quaternion::FromToRotation(Vector3 fromVector, Vector3 toVector)
+{
+    float dot = Vector3::Dot(fromVector, toVector);
+    float k = sqrt(Vector3::SqrMagnitude(fromVector) *
+                   Vector3::SqrMagnitude(toVector));
+    if (fabs(dot / k + 1) < 0.00001)
+    {
+        Vector3 ortho = Vector3::Orthogonal(fromVector);
+        return Quaternion(Vector3::Normalized(ortho), 0);
+    }
+    Vector3 cross = Vector3::Cross(fromVector, toVector);
+    return Normalized(Quaternion(cross, dot + k));
+}
+
+Quaternion Quaternion::Inverse(Quaternion rotation)
+{
+    float n = Norm(rotation);
+    return Conjugate(rotation) / (n * n);
+}
+
+Quaternion Quaternion::Lerp(Quaternion a, Quaternion b, float t)
+{
+    if (t < 0) return Normalized(a);
+    else if (t > 1) return Normalized(b);
+    return LerpUnclamped(a, b, t);
+}
+
+Quaternion Quaternion::LerpUnclamped(Quaternion a, Quaternion b, float t)
+{
+    Quaternion quaternion;
+    if (Dot(a, b) >= 0)
+        quaternion = a * (1 - t) + b * t;
+    else
+        quaternion = a * (1 - t) - b * t;
+    return Normalized(quaternion);
+}
+
+Quaternion Quaternion::LookRotation(Vector3 forward)
+{
+    return LookRotation(forward, Vector3(0, 1, 0));
+}
+
+Quaternion Quaternion::LookRotation(Vector3 forward, Vector3 upwards)
+{
+    // Normalize inputs
+    forward = Vector3::Normalized(forward);
+    upwards = Vector3::Normalized(upwards);
+    // Don't allow zero vectors
+    if (Vector3::SqrMagnitude(forward) < SMALL_float || Vector3::SqrMagnitude(upwards) < SMALL_float)
+        return Quaternion::Identity();
+    // Handle alignment with up direction
+    if (1 - fabs(Vector3::Dot(forward, upwards)) < SMALL_float)
+        return FromToRotation(Vector3::Forward(), forward);
+    // Get orthogonal vectors
+    Vector3 right = Vector3::Normalized(Vector3::Cross(upwards, forward));
+    upwards = Vector3::Cross(forward, right);
+    // Calculate rotation
+    Quaternion quaternion;
+    float radicand = right.X + upwards.Y + forward.Z;
+    if (radicand > 0)
+    {
+        quaternion.W = sqrt(1.0 + radicand) * 0.5;
+        float recip = 1.0 / (4.0 * quaternion.W);
+        quaternion.X = (upwards.Z - forward.Y) * recip;
+        quaternion.Y = (forward.X - right.Z) * recip;
+        quaternion.Z = (right.Y - upwards.X) * recip;
+    }
+    else if (right.X >= upwards.Y && right.X >= forward.Z)
+    {
+        quaternion.X = sqrt(1.0 + right.X - upwards.Y - forward.Z) * 0.5;
+        float recip = 1.0 / (4.0 * quaternion.X);
+        quaternion.W = (upwards.Z - forward.Y) * recip;
+        quaternion.Z = (forward.X + right.Z) * recip;
+        quaternion.Y = (right.Y + upwards.X) * recip;
+    }
+    else if (upwards.Y > forward.Z)
+    {
+        quaternion.Y = sqrt(1.0 - right.X + upwards.Y - forward.Z) * 0.5;
+        float recip = 1.0 / (4.0 * quaternion.Y);
+        quaternion.Z = (upwards.Z + forward.Y) * recip;
+        quaternion.W = (forward.X - right.Z) * recip;
+        quaternion.X = (right.Y + upwards.X) * recip;
+    }
+    else
+    {
+        quaternion.Z = sqrt(1.0 - right.X - upwards.Y + forward.Z) * 0.5;
+        float recip = 1.0 / (4.0 * quaternion.Z);
+        quaternion.Y = (upwards.Z + forward.Y) * recip;
+        quaternion.X = (forward.X + right.Z) * recip;
+        quaternion.W = (right.Y - upwards.X) * recip;
+    }
+    return quaternion;
+}
+
+float Quaternion::Norm(Quaternion rotation)
+{
+    return sqrt(rotation.X * rotation.X +
+                rotation.Y * rotation.Y +
+                rotation.Z * rotation.Z +
+                rotation.W * rotation.W);
+}
+
+Quaternion Quaternion::Normalized(Quaternion rotation)
+{
+    return rotation / Norm(rotation);
+}
+
+Quaternion Quaternion::RotateTowards(Quaternion from, Quaternion to,
+                                     float maxRadiansDelta)
+{
+    float angle = Quaternion::Angle(from, to);
+    if (angle == 0)
+        return to;
+    maxRadiansDelta = fmax(maxRadiansDelta, angle - M_PI);
+    float t = fmin(1, maxRadiansDelta / angle);
+    return Quaternion::SlerpUnclamped(from, to, t);
+}
+
+Quaternion Quaternion::Slerp(Quaternion a, Quaternion b, float t)
+{
+    if (t < 0) return Normalized(a);
+    else if (t > 1) return Normalized(b);
+    return SlerpUnclamped(a, b, t);
+}
+
+Quaternion Quaternion::SlerpUnclamped(Quaternion a, Quaternion b, float t)
+{
+    float n1;
+    float n2;
+    float n3 = Dot(a, b);
+    bool flag = false;
+    if (n3 < 0)
+    {
+        flag = true;
+        n3 = -n3;
+    }
+    if (n3 > 0.999999)
+    {
+        n2 = 1 - t;
+        n1 = flag ? -t : t;
+    }
+    else
+    {
+        float n4 = acos(n3);
+        float n5 = 1 / sin(n4);
+        n2 = sin((1 - t) * n4) * n5;
+        n1 = flag ? -sin(t * n4) * n5 : sin(t * n4) * n5;
+    }
+    Quaternion quaternion;
+    quaternion.X = (n2 * a.X) + (n1 * b.X);
+    quaternion.Y = (n2 * a.Y) + (n1 * b.Y);
+    quaternion.Z = (n2 * a.Z) + (n1 * b.Z);
+    quaternion.W = (n2 * a.W) + (n1 * b.W);
+    return Normalized(quaternion);
+}
+
+void Quaternion::ToAngleAxis(Quaternion rotation, float &angle, Vector3 &axis)
+{
+    if (rotation.W > 1)
+        rotation = Normalized(rotation);
+    angle = 2 * acos(rotation.W);
+    float s = sqrt(1 - rotation.W * rotation.W);
+    if (s < 0.00001) {
+        axis.X = 1;
+        axis.Y = 0;
+        axis.Z = 0;
+    } else {
+        axis.X = rotation.X / s;
+        axis.Y = rotation.Y / s;
+        axis.Z = rotation.Z / s;
+    }
+}
+
+Vector3 Quaternion::ToEuler(Quaternion rotation)
+{
+    float sqw = rotation.W * rotation.W;
+    float sqx = rotation.X * rotation.X;
+    float sqy = rotation.Y * rotation.Y;
+    float sqz = rotation.Z * rotation.Z;
+    // If normalized is one, otherwise is correction factor
+    float unit = sqx + sqy + sqz + sqw;
+    float test = rotation.X * rotation.W - rotation.Y * rotation.Z;
+    Vector3 v;
+    // Singularity at north pole
+    if (test > 0.4995f * unit)
+    {
+        v.Y = 2 * atan2(rotation.Y, rotation.X);
+        v.X = M_PI_2;
+        v.Z = 0;
+        return v;
+    }
+    // Singularity at south pole
+    if (test < -0.4995f * unit)
+    {
+        v.Y = -2 * atan2(rotation.Y, rotation.X);
+        v.X = -M_PI_2;
+        v.Z = 0;
+        return v;
+    }
+    // Yaw
+    v.Y = atan2(2 * rotation.W * rotation.Y + 2 * rotation.Z * rotation.X,
+                1 - 2 * (rotation.X * rotation.X + rotation.Y * rotation.Y));
+    // Pitch
+    v.X = asin(2 * (rotation.W * rotation.X - rotation.Y * rotation.Z));
+    // Roll
+    v.Z = atan2(2 * rotation.W * rotation.Z + 2 * rotation.X * rotation.Y,
+                1 - 2 * (rotation.Z * rotation.Z + rotation.X * rotation.X));
+    return v;
+}
+
+struct Quaternion& Quaternion::operator+=(const float rhs)
+{
+    X += rhs;
+    Y += rhs;
+    Z += rhs;
+    W += rhs;
+    return *this;
+}
+
+struct Quaternion& Quaternion::operator-=(const float rhs)
+{
+    X -= rhs;
+    Y -= rhs;
+    Z -= rhs;
+    W -= rhs;
+    return *this;
+}
+
+struct Quaternion& Quaternion::operator*=(const float rhs)
+{
+    X *= rhs;
+    Y *= rhs;
+    Z *= rhs;
+    W *= rhs;
+    return *this;
+}
+
+struct Quaternion& Quaternion::operator/=(const float rhs)
+{
+    X /= rhs;
+    Y /= rhs;
+    Z /= rhs;
+    W /= rhs;
+    return *this;
+}
+
+struct Quaternion& Quaternion::operator+=(const Quaternion rhs)
+{
+    X += rhs.X;
+    Y += rhs.Y;
+    Z += rhs.Z;
+    W += rhs.W;
+    return *this;
+}
+
+struct Quaternion& Quaternion::operator-=(const Quaternion rhs)
+{
+    X -= rhs.X;
+    Y -= rhs.Y;
+    Z -= rhs.Z;
+    W -= rhs.W;
+    return *this;
+}
+
+struct Quaternion& Quaternion::operator*=(const Quaternion rhs)
+{
+    Quaternion q;
+    q.W = W * rhs.W - X * rhs.X - Y * rhs.Y - Z * rhs.Z;
+    q.X = X * rhs.W + W * rhs.X + Y * rhs.Z - Z * rhs.Y;
+    q.Y = W * rhs.Y - X * rhs.Z + Y * rhs.W + Z * rhs.X;
+    q.Z = W * rhs.Z + X * rhs.Y - Y * rhs.X + Z * rhs.W;
+    *this = q;
+    return *this;
+}
+
+Quaternion operator-(Quaternion rhs) { return rhs * -1; }
+Quaternion operator+(Quaternion lhs, const float rhs) { return lhs += rhs; }
+Quaternion operator-(Quaternion lhs, const float rhs) { return lhs -= rhs; }
+Quaternion operator*(Quaternion lhs, const float rhs) { return lhs *= rhs; }
+Quaternion operator/(Quaternion lhs, const float rhs) { return lhs /= rhs; }
+Quaternion operator+(const float lhs, Quaternion rhs) { return rhs += lhs; }
+Quaternion operator-(const float lhs, Quaternion rhs) { return rhs -= lhs; }
+Quaternion operator*(const float lhs, Quaternion rhs) { return rhs *= lhs; }
+Quaternion operator/(const float lhs, Quaternion rhs) { return rhs /= lhs; }
+Quaternion operator+(Quaternion lhs, const Quaternion rhs)
+{
+    return lhs += rhs;
+}
+Quaternion operator-(Quaternion lhs, const Quaternion rhs)
+{
+    return lhs -= rhs;
+}
+Quaternion operator*(Quaternion lhs, const Quaternion rhs)
+{
+    return lhs *= rhs;
+}
+
+Vector3 operator*(Quaternion lhs, const Vector3 rhs)
+{
+    Vector3 u = Vector3(lhs.X, lhs.Y, lhs.Z);
+    float s = lhs.W;
+    return u * (Vector3::Dot(u, rhs) * 2)
+           + rhs * (s * s - Vector3::Dot(u, u))
+           + Vector3::Cross(u, rhs) * (2.0 * s);
+}
+
+bool operator==(const Quaternion lhs, const Quaternion rhs)
+{
+    return lhs.X == rhs.X &&
+           lhs.Y == rhs.Y &&
+           lhs.Z == rhs.Z &&
+           lhs.W == rhs.W;
+}
+
+bool operator!=(const Quaternion lhs, const Quaternion rhs)
+{
+    return !(lhs == rhs);
+}

结构体/函数/Vector2.hpp

@@ -0,0 +1,528 @@
+#pragma once
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+
+struct Vector2
+{
+    union
+    {
+        struct
+        {
+            float X;
+            float Y;
+        };
+        float data[2];
+    };
+
+
+    /**
+     * Constructors.
+     */
+    inline Vector2();
+    inline Vector2(float data[]);
+    inline Vector2(float value);
+    inline Vector2(float x, float y);
+
+
+    /**
+     * Constants for common vectors.
+     */
+    static inline Vector2 Zero();
+    static inline Vector2 One();
+    static inline Vector2 Right();
+    static inline Vector2 Left();
+    static inline Vector2 Up();
+    static inline Vector2 Down();
+
+
+//=====𝗦𝗥𝗖==𝗝𝗢𝗜𝗡==𝗧𝗘𝗟𝗘𝗚𝗥𝗔𝗠=@𝗚𝗞𝗣𝗙𝗥𝗘𝗘𝗛𝗔𝗖𝗞𝗦===@GKPHACK===V=2.4==//
+    static inline float Angle(Vector2 a, Vector2 b);
+
+    /**
+     * Returns a vector with its magnitude clamped to maxLength.
+     * @param vector: The target vector.
+     * @param maxLength: The maximum length of the return vector.
+     * @return: A new vector.
+     */
+    static inline Vector2 ClampMagnitude(Vector2 vector, float maxLength);
+
+    /**
+     * Returns the component of a in the direction of b (scalar projection).
+     * @param a: The target vector.
+     * @param b: The vector being compared against.
+     * @return: A scalar value.
+     */
+    static inline float Component(Vector2 a, Vector2 b);
+
+    /**
+     * Returns the distance between a and b.
+     * @param a: The first point.
+     * @param b: The second point.
+     * @return: A scalar value.
+     */
+    static inline float Distance(Vector2 a, Vector2 b);
+
+    /**
+     * Returns the dot product of two vectors.
+     * @param lhs: The left side of the multiplication.
+     * @param rhs: The right side of the multiplication.
+     * @return: A scalar value.
+     */
+    static inline float Dot(Vector2 lhs, Vector2 rhs);
+
+    /**
+     * Converts a polar representation of a vector into cartesian
+     * coordinates.
+     * @param rad: The magnitude of the vector.
+     * @param theta: The angle from the X axis.
+     * @return: A new vector.
+     */
+    static inline Vector2 FromPolar(float rad, float theta);
+
+    /**
+     * Returns a vector linearly interpolated between a and b, moving along
+     * a straight line. The vector is clamped to never go beyond the end points.
+     * @param a: The starting point.
+     * @param b: The ending point.
+     * @param t: The interpolation value [0-1].
+     * @return: A new vector.
+     */
+    static inline Vector2 Lerp(Vector2 a, Vector2 b, float t);
+
+    /**
+     * Returns a vector linearly interpolated between a and b, moving along
+     * a straight line.
+     * @param a: The starting point.
+     * @param b: The ending point.
+     * @param t: The interpolation value [0-1] (no actual bounds).
+     * @return: A new vector.
+     */
+    static inline Vector2 LerpUnclamped(Vector2 a, Vector2 b, float t);
+
+    /**
+     * Returns the magnitude of a vector.
+     * @param v: The vector in question.
+     * @return: A scalar value.
+     */
+    static inline float Magnitude(Vector2 v);
+
+    /**
+     * Returns a vector made from the largest components of two other vectors.
+     * @param a: The first vector.
+     * @param b: The second vector.
+     * @return: A new vector.
+     */
+    static inline Vector2 Max(Vector2 a, Vector2 b);
+
+    /**
+     * Returns a vector made from the smallest components of two other vectors.
+     * @param a: The first vector.
+     * @param b: The second vector.
+     * @return: A new vector.
+     */
+    static inline Vector2 Min(Vector2 a, Vector2 b);
+
+    /**
+     * Returns a vector "maxDistanceDelta" units closer to the target. This
+     * interpolation is in a straight line, and will not overshoot.
+     * @param current: The current position.
+     * @param target: The destination position.
+     * @param maxDistanceDelta: The maximum distance to move.
+     * @return: A new vector.
+     */
+    static inline Vector2 MoveTowards(Vector2 current, Vector2 target,
+                               float maxDistanceDelta);
+
+    /**
+     * Returns a new vector with magnitude of one.
+     * @param v: The vector in question.
+     * @return: A new vector.
+     */
+    static inline Vector2 Normalized(Vector2 v);
+
+    /**
+     * Creates a new coordinate system out of the two vectors.
+     * Normalizes "normal" and normalizes "tangent" and makes it orthogonal to
+     * "normal"..
+     * @param normal: A reference to the first axis vector.
+     * @param tangent: A reference to the second axis vector.
+     */
+    static inline void OrthoNormalize(Vector2 &normal, Vector2 &tangent);
+
+    /**
+     * Returns the vector projection of a onto b.
+     * @param a: The target vector.
+     * @param b: The vector being projected onto.
+     * @return: A new vector.
+     */
+    static inline Vector2 Project(Vector2 a, Vector2 b);
+
+    /**
+     * Returns a vector reflected about the provided line.
+     * This behaves as if there is a plane with the line as its normal, and the
+     * vector comes in and bounces off this plane.
+     * @param vector: The vector traveling inward at the imaginary plane.
+     * @param line: The line about which to reflect.
+     * @return: A new vector pointing outward from the imaginary plane.
+     */
+    static inline Vector2 Reflect(Vector2 vector, Vector2 line);
+
+    /**
+     * Returns the vector rejection of a on b.
+     * @param a: The target vector.
+     * @param b: The vector being projected onto.
+     * @return: A new vector.
+     */
+    static inline Vector2 Reject(Vector2 a, Vector2 b);
+
+    /**
+     * Rotates vector "current" towards vector "target" by "maxRadiansDelta".
+     * This treats the vectors as directions and will linearly interpolate
+     * between their magnitudes by "maxMagnitudeDelta". This function does not
+     * overshoot. If a negative delta is supplied, it will rotate away from
+     * "target" until it is pointing the opposite direction, but will not
+     * overshoot that either.
+     * @param current: The starting direction.
+     * @param target: The destination direction.
+     * @param maxRadiansDelta: The maximum number of radians to rotate.
+     * @param maxMagnitudeDelta: The maximum delta for magnitude interpolation.
+     * @return: A new vector.
+     */
+    static inline Vector2 RotateTowards(Vector2 current, Vector2 target,
+                                 float maxRadiansDelta,
+                                 float maxMagnitudeDelta);
+
+    /**
+     * Multiplies two vectors component-wise.
+     * @param a: The lhs of the multiplication.
+     * @param b: The rhs of the multiplication.
+     * @return: A new vector.
+     */
+    static inline Vector2 Scale(Vector2 a, Vector2 b);
+
+    /**
+     * Returns a vector rotated towards b from a by the percent t.
+     * Since interpolation is done spherically, the vector moves at a constant
+     * angular velocity. This rotation is clamped to 0 <= t <= 1.
+     * @param a: The starting direction.
+     * @param b: The ending direction.
+     * @param t: The interpolation value [0-1].
+     */
+    static inline Vector2 Slerp(Vector2 a, Vector2 b, float t);
+
+    /**
+     * Returns a vector rotated towards b from a by the percent t.
+     * Since interpolation is done spherically, the vector moves at a constant
+     * angular velocity. This rotation is unclamped.
+     * @param a: The starting direction.
+     * @param b: The ending direction.
+     * @param t: The interpolation value [0-1].
+     */
+    static inline Vector2 SlerpUnclamped(Vector2 a, Vector2 b, float t);
+
+    /**
+     * Returns the squared magnitude of a vector.
+     * This is useful when comparing relative lengths, where the exact length
+     * is not important, and much time can be saved by not calculating the
+     * square root.
+     * @param v: The vector in question.
+     * @return: A scalar value.
+     */
+    static inline float SqrMagnitude(Vector2 v);
+
+    /**
+     * Calculates the polar coordinate space representation of a vector.
+     * @param vector: The vector to convert.
+     * @param rad: The magnitude of the vector.
+     * @param theta: The angle from the X axis.
+     */
+    static inline void ToPolar(Vector2 vector, float &rad, float &theta);
+
+
+    /**
+     * Operator overloading.
+     */
+    inline struct Vector2& operator+=(const float rhs);
+    inline struct Vector2& operator-=(const float rhs);
+    inline struct Vector2& operator*=(const float rhs);
+    inline struct Vector2& operator/=(const float rhs);
+    inline struct Vector2& operator+=(const Vector2 rhs);
+    inline struct Vector2& operator-=(const Vector2 rhs);
+};
+
+inline Vector2 operator-(Vector2 rhs);
+inline Vector2 operator+(Vector2 lhs, const float rhs);
+inline Vector2 operator-(Vector2 lhs, const float rhs);
+inline Vector2 operator*(Vector2 lhs, const float rhs);
+inline Vector2 operator/(Vector2 lhs, const float rhs);
+inline Vector2 operator+(const float lhs, Vector2 rhs);
+inline Vector2 operator-(const float lhs, Vector2 rhs);
+inline Vector2 operator*(const float lhs, Vector2 rhs);
+inline Vector2 operator/(const float lhs, Vector2 rhs);
+inline Vector2 operator+(Vector2 lhs, const Vector2 rhs);
+inline Vector2 operator-(Vector2 lhs, const Vector2 rhs);
+inline bool operator==(const Vector2 lhs, const Vector2 rhs);
+inline bool operator!=(const Vector2 lhs, const Vector2 rhs);
+
+
+
+/*******************************************************************************
+ * Implementation
+ */
+
+Vector2::Vector2() : X(0), Y(0) {}
+Vector2::Vector2(float data[]) : X(data[0]), Y(data[1]) {}
+Vector2::Vector2(float value) : X(value), Y(value) {}
+Vector2::Vector2(float x, float y) : X(x), Y(y) {}
+
+
+Vector2 Vector2::Zero() { return Vector2(0, 0); }
+Vector2 Vector2::One() { return Vector2(1, 1); }
+Vector2 Vector2::Right() { return Vector2(1, 0); }
+Vector2 Vector2::Left() { return Vector2(-1, 0); }
+Vector2 Vector2::Up() { return Vector2(0, 1); }
+Vector2 Vector2::Down() { return Vector2(0, -1); }
+
+
+float Vector2::Angle(Vector2 a, Vector2 b)
+{
+    float v = Dot(a, b) / (Magnitude(a) * Magnitude(b));
+    v = fmax(v, -1.0);
+    v = fmin(v, 1.0);
+    return acos(v);
+}
+
+Vector2 Vector2::ClampMagnitude(Vector2 vector, float maxLength)
+{
+    float length = Magnitude(vector);
+    if (length > maxLength)
+        vector *= maxLength / length;
+    return vector;
+}
+
+float Vector2::Component(Vector2 a, Vector2 b)
+{
+    return Dot(a, b) / Magnitude(b);
+}
+
+float Vector2::Distance(Vector2 a, Vector2 b)
+{
+    return Vector2::Magnitude(a - b);
+}
+
+float Vector2::Dot(Vector2 lhs, Vector2 rhs)
+{
+    return lhs.X * rhs.X + lhs.Y * rhs.Y;
+}
+
+Vector2 Vector2::FromPolar(float rad, float theta)
+{
+    Vector2 v;
+    v.X = rad * cos(theta);
+    v.Y = rad * sin(theta);
+    return v;
+}
+
+Vector2 Vector2::Lerp(Vector2 a, Vector2 b, float t)
+{
+    if (t < 0) return a;
+    else if (t > 1) return b;
+    return LerpUnclamped(a, b, t);
+}
+
+Vector2 Vector2::LerpUnclamped(Vector2 a, Vector2 b, float t)
+{
+    return (b - a) * t + a;
+}
+
+float Vector2::Magnitude(Vector2 v)
+{
+    return sqrt(SqrMagnitude(v));
+}
+
+Vector2 Vector2::Max(Vector2 a, Vector2 b)
+{
+    float x = a.X > b.X ? a.X : b.X;
+    float y = a.Y > b.Y ? a.Y : b.Y;
+    return Vector2(x, y);
+}
+
+Vector2 Vector2::Min(Vector2 a, Vector2 b)
+{
+    float x = a.X > b.X ? b.X : a.X;
+    float y = a.Y > b.Y ? b.Y : a.Y;
+    return Vector2(x, y);
+}
+
+Vector2 Vector2::MoveTowards(Vector2 current, Vector2 target,
+                             float maxDistanceDelta)
+{
+    Vector2 d = target - current;
+    float m = Magnitude(d);
+    if (m < maxDistanceDelta || m == 0)
+        return target;
+    return current + (d * maxDistanceDelta / m);
+}
+
+Vector2 Vector2::Normalized(Vector2 v)
+{
+    float mag = Magnitude(v);
+    if (mag == 0)
+        return Vector2::Zero();
+    return v / mag;
+}
+
+void Vector2::OrthoNormalize(Vector2 &normal, Vector2 &tangent)
+{
+    normal = Normalized(normal);
+    tangent = Reject(tangent, normal);
+    tangent = Normalized(tangent);
+}
+
+Vector2 Vector2::Project(Vector2 a, Vector2 b)
+{
+    float m = Magnitude(b);
+    return Dot(a, b) / (m * m) * b;
+}
+
+Vector2 Vector2::Reflect(Vector2 vector, Vector2 planeNormal)
+{
+    return vector - 2 * Project(vector, planeNormal);
+}
+
+Vector2 Vector2::Reject(Vector2 a, Vector2 b)
+{
+    return a - Project(a, b);
+}
+
+Vector2 Vector2::RotateTowards(Vector2 current, Vector2 target,
+                               float maxRadiansDelta,
+                               float maxMagnitudeDelta)
+{
+    float magCur = Magnitude(current);
+    float magTar = Magnitude(target);
+    float newMag = magCur + maxMagnitudeDelta *
+        ((magTar > magCur) - (magCur > magTar));
+    newMag = fmin(newMag, fmax(magCur, magTar));
+    newMag = fmax(newMag, fmin(magCur, magTar));
+
+    float totalAngle = Angle(current, target) - maxRadiansDelta;
+    if (totalAngle <= 0)
+        return Normalized(target) * newMag;
+    else if (totalAngle >= M_PI)
+        return Normalized(-target) * newMag;
+
+    float axis = current.X * target.Y - current.Y * target.X;
+    axis = axis / fabs(axis);
+    if (!(1 - fabs(axis) < 0.00001))
+        axis = 1;
+    current = Normalized(current);
+    Vector2 newVector = current * cos(maxRadiansDelta) +
+        Vector2(-current.Y, current.X) * sin(maxRadiansDelta) * axis;
+    return newVector * newMag;
+}
+
+Vector2 Vector2::Scale(Vector2 a, Vector2 b)
+{
+    return Vector2(a.X * b.X, a.Y * b.Y);
+}
+
+Vector2 Vector2::Slerp(Vector2 a, Vector2 b, float t)
+{
+    if (t < 0) return a;
+    else if (t > 1) return b;
+    return SlerpUnclamped(a, b, t);
+}
+
+Vector2 Vector2::SlerpUnclamped(Vector2 a, Vector2 b, float t)
+{
+    float magA = Magnitude(a);
+    float magB = Magnitude(b);
+    a /= magA;
+    b /= magB;
+    float dot = Dot(a, b);
+    dot = fmax(dot, -1.0);
+    dot = fmin(dot, 1.0);
+    float theta = acos(dot) * t;
+    Vector2 relativeVec = Normalized(b - a * dot);
+    Vector2 newVec = a * cos(theta) + relativeVec * sin(theta);
+    return newVec * (magA + (magB - magA) * t);
+}
+
+float Vector2::SqrMagnitude(Vector2 v)
+{
+    return v.X * v.X + v.Y * v.Y;
+}
+
+void Vector2::ToPolar(Vector2 vector, float &rad, float &theta)
+{
+    rad = Magnitude(vector);
+    theta = atan2(vector.Y, vector.X);
+}
+
+
+struct Vector2& Vector2::operator+=(const float rhs)
+{
+    X += rhs;
+    Y += rhs;
+    return *this;
+}
+
+struct Vector2& Vector2::operator-=(const float rhs)
+{
+    X -= rhs;
+    Y -= rhs;
+    return *this;
+}
+
+struct Vector2& Vector2::operator*=(const float rhs)
+{
+    X *= rhs;
+    Y *= rhs;
+    return *this;
+}
+
+struct Vector2& Vector2::operator/=(const float rhs)
+{
+    X /= rhs;
+    Y /= rhs;
+    return *this;
+}
+
+struct Vector2& Vector2::operator+=(const Vector2 rhs)
+{
+    X += rhs.X;
+    Y += rhs.Y;
+    return *this;
+}
+
+struct Vector2& Vector2::operator-=(const Vector2 rhs)
+{
+    X -= rhs.X;
+    Y -= rhs.Y;
+    return *this;
+}
+
+Vector2 operator-(Vector2 rhs) { return rhs * -1; }
+Vector2 operator+(Vector2 lhs, const float rhs) { return lhs += rhs; }
+Vector2 operator-(Vector2 lhs, const float rhs) { return lhs -= rhs; }
+Vector2 operator*(Vector2 lhs, const float rhs) { return lhs *= rhs; }
+Vector2 operator/(Vector2 lhs, const float rhs) { return lhs /= rhs; }
+Vector2 operator+(const float lhs, Vector2 rhs) { return rhs += lhs; }
+Vector2 operator-(const float lhs, Vector2 rhs) { return rhs -= lhs; }
+Vector2 operator*(const float lhs, Vector2 rhs) { return rhs *= lhs; }
+Vector2 operator/(const float lhs, Vector2 rhs) { return rhs /= lhs; }
+Vector2 operator+(Vector2 lhs, const Vector2 rhs) { return lhs += rhs; }
+Vector2 operator-(Vector2 lhs, const Vector2 rhs) { return lhs -= rhs; }
+
+bool operator==(const Vector2 lhs, const Vector2 rhs)
+{
+    return lhs.X == rhs.X && lhs.Y == rhs.Y;
+}
+
+bool operator!=(const Vector2 lhs, const Vector2 rhs)
+{
+    return !(lhs == rhs);
+}

结构体/函数/Vector3.hpp

@@ -0,0 +1,625 @@
+#pragma once
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+
+struct Vector3
+{
+    union
+    {
+        struct
+        {
+            float X;
+            float Y;
+            float Z;
+        };
+        float data[3];
+    };
+//=====𝗦𝗥𝗖==𝗝𝗢𝗜𝗡==𝗧𝗘𝗟𝗘𝗚𝗥𝗔𝗠=@𝗚𝗞𝗣𝗙𝗥𝗘𝗘𝗛𝗔𝗖𝗞𝗦===@GKPHACK===V=2.4==//
+    inline Vector3();
+    inline Vector3(float data[]);
+    inline Vector3(float value);
+    inline Vector3(float x, float y);
+    inline Vector3(float x, float y, float z);
+
+
+    /**
+     * Constants for common vectors.
+     */
+    static inline Vector3 Zero();
+    static inline Vector3 One();
+    static inline Vector3 Right();
+    static inline Vector3 Left();
+    static inline Vector3 Up();
+    static inline Vector3 Down();
+    static inline Vector3 Forward();
+    static inline Vector3 Backward();
+
+
+    /**
+     * Returns the angle between two vectors in radians.
+     * @param a: The first vector.
+     * @param b: The second vector.
+     * @return: A scalar value.
+     */
+    static inline float Angle(Vector3 a, Vector3 b);
+
+    /**
+     * Returns a vector with its magnitude clamped to maxLength.
+     * @param vector: The target vector.
+     * @param maxLength: The maximum length of the return vector.
+     * @return: A new vector.
+     */
+    static inline Vector3 ClampMagnitude(Vector3 vector, float maxLength);
+
+    /**
+     * Returns the component of a in the direction of b (scalar projection).
+     * @param a: The target vector.
+     * @param b: The vector being compared against.
+     * @return: A scalar value.
+     */
+    static inline float Component(Vector3 a, Vector3 b);
+
+    /**
+     * Returns the cross product of two vectors.
+     * @param lhs: The left side of the multiplication.
+     * @param rhs: The right side of the multiplication.
+     * @return: A new vector.
+     */
+    static inline Vector3 Cross(Vector3 lhs, Vector3 rhs);
+
+    /**
+     * Returns the distance between a and b.
+     * @param a: The first point.
+     * @param b: The second point.
+     * @return: A scalar value.
+     */
+    static inline float Distance(Vector3 a, Vector3 b);
+
+    static inline char ToChar(Vector3 a);
+
+    /**
+     * Returns the dot product of two vectors.
+     * @param lhs: The left side of the multiplication.
+     * @param rhs: The right side of the multiplication.
+     * @return: A scalar value.
+     */
+    static inline float Dot(Vector3 lhs, Vector3 rhs);
+
+    /**
+     * Converts a spherical representation of a vector into cartesian
+     * coordinates.
+     * This uses the ISO convention (radius r, inclination theta, azimuth phi).
+     * @param rad: The magnitude of the vector.
+     * @param theta: The angle in the XY plane from the X axis.
+     * @param phi: The angle from the positive Z axis to the vector.
+     * @return: A new vector.
+     */
+    static inline Vector3 FromSpherical(float rad, float theta, float phi);
+
+    /**
+     * Returns a vector linearly interpolated between a and b, moving along
+     * a straight line. The vector is clamped to never go beyond the end points.
+     * @param a: The starting point.
+     * @param b: The ending point.
+     * @param t: The interpolation value [0-1].
+     * @return: A new vector.
+     */
+    static inline Vector3 Lerp(Vector3 a, Vector3 b, float t);
+
+    /**
+     * Returns a vector linearly interpolated between a and b, moving along
+     * a straight line.
+     * @param a: The starting point.
+     * @param b: The ending point.
+     * @param t: The interpolation value [0-1] (no actual bounds).
+     * @return: A new vector.
+     */
+    static inline Vector3 LerpUnclamped(Vector3 a, Vector3 b, float t);
+
+    /**
+     * Returns the magnitude of a vector.
+     * @param v: The vector in question.
+     * @return: A scalar value.
+     */
+    static inline float Magnitude(Vector3 v);
+
+    /**
+     * Returns a vector made from the largest components of two other vectors.
+     * @param a: The first vector.
+     * @param b: The second vector.
+     * @return: A new vector.
+     */
+    static inline Vector3 Max(Vector3 a, Vector3 b);
+
+    /**
+     * Returns a vector made from the smallest components of two other vectors.
+     * @param a: The first vector.
+     * @param b: The second vector.
+     * @return: A new vector.
+     */
+    static inline Vector3 Min(Vector3 a, Vector3 b);
+
+    /**
+     * Returns a vector "maxDistanceDelta" units closer to the target. This
+     * interpolation is in a straight line, and will not overshoot.
+     * @param current: The current position.
+     * @param target: The destination position.
+     * @param maxDistanceDelta: The maximum distance to move.
+     * @return: A new vector.
+     */
+    static inline Vector3 MoveTowards(Vector3 current, Vector3 target,
+                                      float maxDistanceDelta);
+
+    /**
+     * Returns a new vector with magnitude of one.
+     * @param v: The vector in question.
+     * @return: A new vector.
+     */
+    static inline Vector3 Normalized(Vector3 v);
+
+    /**
+     * Returns an arbitrary vector orthogonal to the input.
+     * This vector is not normalized.
+     * @param v: The input vector.
+     * @return: A new vector.
+     */
+    static inline Vector3 Orthogonal(Vector3 v);
+
+    /**
+     * Creates a new coordinate system out of the three vectors.
+     * Normalizes "normal", normalizes "tangent" and makes it orthogonal to
+     * "normal" and normalizes "binormal" and makes it orthogonal to both
+     * "normal" and "tangent".
+     * @param normal: A reference to the first axis vector.
+     * @param tangent: A reference to the second axis vector.
+     * @param binormal: A reference to the third axis vector.
+     */
+    static inline void OrthoNormalize(Vector3 &normal, Vector3 &tangent,
+                                      Vector3 &binormal);
+
+    /**
+     * Returns the vector projection of a onto b.
+     * @param a: The target vector.
+     * @param b: The vector being projected onto.
+     * @return: A new vector.
+     */
+    static inline Vector3 Project(Vector3 a, Vector3 b);
+
+    /**
+     * Returns a vector projected onto a plane orthogonal to "planeNormal".
+     * This can be visualized as the shadow of the vector onto the plane, if
+     * the light source were in the direction of the plane normal.
+     * @param vector: The vector to project.
+     * @param planeNormal: The normal of the plane onto which to project.
+     * @param: A new vector.
+     */
+    static inline Vector3 ProjectOnPlane(Vector3 vector, Vector3 planeNormal);
+
+    /**
+     * Returns a vector reflected off the plane orthogonal to the normal.
+     * The input vector is pointed inward, at the plane, and the return vector
+     * is pointed outward from the plane, like a beam of light hitting and then
+     * reflecting off a mirror.
+     * @param vector: The vector traveling inward at the plane.
+     * @param planeNormal: The normal of the plane off of which to reflect.
+     * @return: A new vector pointing outward from the plane.
+     */
+    static inline Vector3 Reflect(Vector3 vector, Vector3 planeNormal);
+
+    /**
+     * Returns the vector rejection of a on b.
+     * @param a: The target vector.
+     * @param b: The vector being projected onto.
+     * @return: A new vector.
+     */
+    static inline Vector3 Reject(Vector3 a, Vector3 b);
+
+    /**
+     * Rotates vector "current" towards vector "target" by "maxRadiansDelta".
+     * This treats the vectors as directions and will linearly interpolate
+     * between their magnitudes by "maxMagnitudeDelta". This function does not
+     * overshoot. If a negative delta is supplied, it will rotate away from
+     * "target" until it is pointing the opposite direction, but will not
+     * overshoot that either.
+     * @param current: The starting direction.
+     * @param target: The destination direction.
+     * @param maxRadiansDelta: The maximum number of radians to rotate.
+     * @param maxMagnitudeDelta: The maximum delta for magnitude interpolation.
+     * @return: A new vector.
+     */
+    static inline Vector3 RotateTowards(Vector3 current, Vector3 target,
+                                        float maxRadiansDelta,
+                                        float maxMagnitudeDelta);
+
+    /**
+     * Multiplies two vectors element-wise.
+     * @param a: The lhs of the multiplication.
+     * @param b: The rhs of the multiplication.
+     * @return: A new vector.
+     */
+    static inline Vector3 Scale(Vector3 a, Vector3 b);
+
+    /**
+     * Returns a vector rotated towards b from a by the percent t.
+     * Since interpolation is done spherically, the vector moves at a constant
+     * angular velocity. This rotation is clamped to 0 <= t <= 1.
+     * @param a: The starting direction.
+     * @param b: The ending direction.
+     * @param t: The interpolation value [0-1].
+     */
+    static inline Vector3 Slerp(Vector3 a, Vector3 b, float t);
+
+    /**
+     * Returns a vector rotated towards b from a by the percent t.
+     * Since interpolation is done spherically, the vector moves at a constant
+     * angular velocity. This rotation is unclamped.
+     * @param a: The starting direction.
+     * @param b: The ending direction.
+     * @param t: The interpolation value [0-1].
+     */
+    static inline Vector3 SlerpUnclamped(Vector3 a, Vector3 b, float t);
+
+    /**
+     * Returns the squared magnitude of a vector.
+     * This is useful when comparing relative lengths, where the exact length
+     * is not important, and much time can be saved by not calculating the
+     * square root.
+     * @param v: The vector in question.
+     * @return: A scalar value.
+     */
+    static inline float SqrMagnitude(Vector3 v);
+
+    /**
+     * Calculates the spherical coordinate space representation of a vector.
+     * This uses the ISO convention (radius r, inclination theta, azimuth phi).
+     * @param vector: The vector to convert.
+     * @param rad: The magnitude of the vector.
+     * @param theta: The angle in the XY plane from the X axis.
+     * @param phi: The angle from the positive Z axis to the vector.
+     */
+    static inline void ToSpherical(Vector3 vector, float &rad, float &theta,
+                                   float &phi);
+
+
+    /**
+     * Operator overloading.
+     */
+    inline struct Vector3& operator+=(const float rhs);
+    inline struct Vector3& operator-=(const float rhs);
+    inline struct Vector3& operator*=(const float rhs);
+    inline struct Vector3& operator/=(const float rhs);
+    inline struct Vector3& operator+=(const Vector3 rhs);
+    inline struct Vector3& operator-=(const Vector3 rhs);
+};
+
+inline Vector3 operator-(Vector3 rhs);
+inline Vector3 operator+(Vector3 lhs, const float rhs);
+inline Vector3 operator-(Vector3 lhs, const float rhs);
+inline Vector3 operator*(Vector3 lhs, const float rhs);
+inline Vector3 operator/(Vector3 lhs, const float rhs);
+inline Vector3 operator+(const float lhs, Vector3 rhs);
+inline Vector3 operator-(const float lhs, Vector3 rhs);
+inline Vector3 operator*(const float lhs, Vector3 rhs);
+inline Vector3 operator/(const float lhs, Vector3 rhs);
+inline Vector3 operator+(Vector3 lhs, const Vector3 rhs);
+inline Vector3 operator-(Vector3 lhs, const Vector3 rhs);
+inline bool operator==(const Vector3 lhs, const Vector3 rhs);
+inline bool operator!=(const Vector3 lhs, const Vector3 rhs);
+
+
+
+/*******************************************************************************
+ * Implementation
+ */
+
+Vector3::Vector3() : X(0), Y(0), Z(0) {}
+Vector3::Vector3(float data[]) : X(data[0]), Y(data[1]), Z(data[2]) {}
+Vector3::Vector3(float value) : X(value), Y(value), Z(value) {}
+Vector3::Vector3(float x, float y) : X(x), Y(y), Z(0) {}
+Vector3::Vector3(float x, float y, float z) : X(x), Y(y), Z(z) {}
+
+
+Vector3 Vector3::Zero() { return Vector3(0, 0, 0); }
+Vector3 Vector3::One() { return Vector3(1, 1, 1); }
+Vector3 Vector3::Right() { return Vector3(1, 0, 0); }
+Vector3 Vector3::Left() { return Vector3(-1, 0, 0); }
+Vector3 Vector3::Up() { return Vector3(0, 1, 0); }
+Vector3 Vector3::Down() { return Vector3(0, -1, 0); }
+Vector3 Vector3::Forward() { return Vector3(0, 0, 1); }
+Vector3 Vector3::Backward() { return Vector3(0, 0, -1); }
+
+
+float Vector3::Angle(Vector3 a, Vector3 b)
+{
+    float v = Dot(a, b) / (Magnitude(a) * Magnitude(b));
+    v = fmax(v, -1.0);
+    v = fmin(v, 1.0);
+    return acos(v);
+}
+
+Vector3 Vector3::ClampMagnitude(Vector3 vector, float maxLength)
+{
+    float length = Magnitude(vector);
+    if (length > maxLength)
+        vector *= maxLength / length;
+    return vector;
+}
+
+float Vector3::Component(Vector3 a, Vector3 b)
+{
+    return Dot(a, b) / Magnitude(b);
+}
+
+Vector3 Vector3::Cross(Vector3 lhs, Vector3 rhs)
+{
+    float x = lhs.Y * rhs.Z - lhs.Z * rhs.Y;
+    float y = lhs.Z * rhs.X - lhs.X * rhs.Z;
+    float z = lhs.X * rhs.Y - lhs.Y * rhs.X;
+    return Vector3(x, y, z);
+}
+
+float Vector3::Distance(Vector3 a, Vector3 b)
+{
+    return Vector3::Magnitude(a - b);
+}
+
+float Vector3::Dot(Vector3 lhs, Vector3 rhs)
+{
+    return lhs.X * rhs.X + lhs.Y * rhs.Y + lhs.Z * rhs.Z;
+}
+
+Vector3 Vector3::FromSpherical(float rad, float theta, float phi)
+{
+    Vector3 v;
+    v.X = rad * sin(theta) * cos(phi);
+    v.Y = rad * sin(theta) * sin(phi);
+    v.Z = rad * cos(theta);
+    return v;
+}
+
+Vector3 Vector3::Lerp(Vector3 a, Vector3 b, float t)
+{
+    if (t < 0) return a;
+    else if (t > 1) return b;
+    return LerpUnclamped(a, b, t);
+}
+
+Vector3 Vector3::LerpUnclamped(Vector3 a, Vector3 b, float t)
+{
+    return (b - a) * t + a;
+}
+
+float Vector3::Magnitude(Vector3 v)
+{
+    return sqrt(SqrMagnitude(v));
+}
+
+Vector3 Vector3::Max(Vector3 a, Vector3 b)
+{
+    float x = a.X > b.X ? a.X : b.X;
+    float y = a.Y > b.Y ? a.Y : b.Y;
+    float z = a.Z > b.Z ? a.Z : b.Z;
+    return Vector3(x, y, z);
+}
+
+Vector3 Vector3::Min(Vector3 a, Vector3 b)
+{
+    float x = a.X > b.X ? b.X : a.X;
+    float y = a.Y > b.Y ? b.Y : a.Y;
+    float z = a.Z > b.Z ? b.Z : a.Z;
+    return Vector3(x, y, z);
+}
+
+Vector3 Vector3::MoveTowards(Vector3 current, Vector3 target,
+                             float maxDistanceDelta)
+{
+    Vector3 d = target - current;
+    float m = Magnitude(d);
+    if (m < maxDistanceDelta || m == 0)
+        return target;
+    return current + (d * maxDistanceDelta / m);
+}
+
+Vector3 Vector3::Normalized(Vector3 v)
+{
+    float mag = Magnitude(v);
+    if (mag == 0)
+        return Vector3::Zero();
+    return v / mag;
+}
+
+Vector3 Vector3::Orthogonal(Vector3 v)
+{
+    return v.Z < v.X ? Vector3(v.Y, -v.X, 0) : Vector3(0, -v.Z, v.Y);
+}
+
+void Vector3::OrthoNormalize(Vector3 &normal, Vector3 &tangent,
+                             Vector3 &binormal)
+{
+    normal = Normalized(normal);
+    tangent = ProjectOnPlane(tangent, normal);
+    tangent = Normalized(tangent);
+    binormal = ProjectOnPlane(binormal, tangent);
+    binormal = ProjectOnPlane(binormal, normal);
+    binormal = Normalized(binormal);
+}
+
+Vector3 Vector3::Project(Vector3 a, Vector3 b)
+{
+    float m = Magnitude(b);
+    return Dot(a, b) / (m * m) * b;
+}
+
+Vector3 Vector3::ProjectOnPlane(Vector3 vector, Vector3 planeNormal)
+{
+    return Reject(vector, planeNormal);
+}
+
+Vector3 Vector3::Reflect(Vector3 vector, Vector3 planeNormal)
+{
+    return vector - 2 * Project(vector, planeNormal);
+}
+
+Vector3 Vector3::Reject(Vector3 a, Vector3 b)
+{
+    return a - Project(a, b);
+}
+
+Vector3 Vector3::RotateTowards(Vector3 current, Vector3 target,
+                               float maxRadiansDelta,
+                               float maxMagnitudeDelta)
+{
+    float magCur = Magnitude(current);
+    float magTar = Magnitude(target);
+    float newMag = magCur + maxMagnitudeDelta *
+                            ((magTar > magCur) - (magCur > magTar));
+    newMag = fmin(newMag, fmax(magCur, magTar));
+    newMag = fmax(newMag, fmin(magCur, magTar));
+
+    float totalAngle = Angle(current, target) - maxRadiansDelta;
+    if (totalAngle <= 0)
+        return Normalized(target) * newMag;
+    else if (totalAngle >= M_PI)
+        return Normalized(-target) * newMag;
+
+    Vector3 axis = Cross(current, target);
+    float magAxis = Magnitude(axis);
+    if (magAxis == 0)
+        axis = Normalized(Cross(current, current + Vector3(3.95, 5.32, -4.24)));
+    else
+        axis /= magAxis;
+    current = Normalized(current);
+    Vector3 newVector = current * cos(maxRadiansDelta) +
+                        Cross(axis, current) * sin(maxRadiansDelta);
+    return newVector * newMag;
+}
+
+Vector3 Vector3::Scale(Vector3 a, Vector3 b)
+{
+    return Vector3(a.X * b.X, a.Y * b.Y, a.Z * b.Z);
+}
+
+Vector3 Vector3::Slerp(Vector3 a, Vector3 b, float t)
+{
+    if (t < 0) return a;
+    else if (t > 1) return b;
+    return SlerpUnclamped(a, b, t);
+}
+
+Vector3 Vector3::SlerpUnclamped(Vector3 a, Vector3 b, float t)
+{
+    float magA = Magnitude(a);
+    float magB = Magnitude(b);
+    a /= magA;
+    b /= magB;
+    float dot = Dot(a, b);
+    dot = fmax(dot, -1.0);
+    dot = fmin(dot, 1.0);
+    float theta = acos(dot) * t;
+    Vector3 relativeVec = Normalized(b - a * dot);
+    Vector3 newVec = a * cos(theta) + relativeVec * sin(theta);
+    return newVec * (magA + (magB - magA) * t);
+}
+
+float Vector3::SqrMagnitude(Vector3 v)
+{
+    return v.X * v.X + v.Y * v.Y + v.Z * v.Z;
+}
+
+void Vector3::ToSpherical(Vector3 vector, float &rad, float &theta,
+                          float &phi)
+{
+    rad = Magnitude(vector);
+    float v = vector.Z / rad;
+    v = fmax(v, -1.0);
+    v = fmin(v, 1.0);
+    theta = acos(v);
+    phi = atan2(vector.Y, vector.X);
+}
+
+
+struct Vector3& Vector3::operator+=(const float rhs)
+{
+    X += rhs;
+    Y += rhs;
+    Z += rhs;
+    return *this;
+}
+
+struct Vector3& Vector3::operator-=(const float rhs)
+{
+    X -= rhs;
+    Y -= rhs;
+    Z -= rhs;
+    return *this;
+}
+
+struct Vector3& Vector3::operator*=(const float rhs)
+{
+    X *= rhs;
+    Y *= rhs;
+    Z *= rhs;
+    return *this;
+}
+
+struct Vector3& Vector3::operator/=(const float rhs)
+{
+    X /= rhs;
+    Y /= rhs;
+    Z /= rhs;
+    return *this;
+}
+
+struct Vector3& Vector3::operator+=(const Vector3 rhs)
+{
+    X += rhs.X;
+    Y += rhs.Y;
+    Z += rhs.Z;
+    return *this;
+}
+
+struct Vector3& Vector3::operator-=(const Vector3 rhs)
+{
+    X -= rhs.X;
+    Y -= rhs.Y;
+    Z -= rhs.Z;
+    return *this;
+}
+
+char Vector3::ToChar(Vector3 a) {
+    const char* x = (const char*)(int)a.X;
+    const char* y = (const char*)(int)a.Y;
+    const char* z = (const char*)(int)a.Z;
+    char buffer[25];
+    strncpy(buffer, x, sizeof(buffer));
+    strncpy(buffer, ", ", sizeof(buffer));
+    strncpy(buffer, y, sizeof(buffer));
+    strncpy(buffer, ", ", sizeof(buffer));
+    strncpy(buffer, z, sizeof(buffer));
+    strncpy(buffer, ", ", sizeof(buffer));
+    return buffer[25];
+}
+
+Vector3 operator-(Vector3 rhs) { return rhs * -1; }
+Vector3 operator+(Vector3 lhs, const float rhs) { return lhs += rhs; }
+Vector3 operator-(Vector3 lhs, const float rhs) { return lhs -= rhs; }
+Vector3 operator*(Vector3 lhs, const float rhs) { return lhs *= rhs; }
+Vector3 operator/(Vector3 lhs, const float rhs) { return lhs /= rhs; }
+Vector3 operator+(const float lhs, Vector3 rhs) { return rhs += lhs; }
+Vector3 operator-(const float lhs, Vector3 rhs) { return rhs -= lhs; }
+Vector3 operator*(const float lhs, Vector3 rhs) { return rhs *= lhs; }
+Vector3 operator/(const float lhs, Vector3 rhs) { return rhs /= lhs; }
+Vector3 operator+(Vector3 lhs, const Vector3 rhs) { return lhs += rhs; }
+Vector3 operator-(Vector3 lhs, const Vector3 rhs) { return lhs -= rhs; }
+
+bool operator==(const Vector3 lhs, const Vector3 rhs)
+{
+    return lhs.X == rhs.X && lhs.Y == rhs.Y && lhs.Z == rhs.Z;
+}
+
+bool operator!=(const Vector3 lhs, const Vector3 rhs)
+{
+    return !(lhs == rhs);
+}

结构体/函数/必要函数.h

@@ -0,0 +1,142 @@
+TNameEntryArray*GetGNames(){
+return(TNameEntryArray*)getPointer(UE4+0x4431AE4);
+}
+
+static UEngine *GEngine = 0;
+UWorld *GetWorld() {
+    while (!GEngine) {
+ GEngine = UObject::FindObject<UEngine>("UAEGameEngine Transient.UAEGameEngine_1");
+ sleep(1);
+   }
+    if (GEngine) {
+    auto ViewPort = GEngine->GameViewport;
+if (ViewPort) {
+   return ViewPort->World;
+}   }
+    return 0;
+}
+#include <vector>
+std::vector<AActor*> getActors()
+{
+	auto World = GetWorld();
+	if (!World)
+		return std::vector<AActor*>();
+	auto PersistentLevel = World->PersistentLevel;
+	if (!PersistentLevel)
+		return std::vector<AActor*>();
+	auto Actors = *(TArray<AActor*> *)((uintptr_t)PersistentLevel + 0x70);
+	std::vector<AActor*> actors;
+	for (int i = 0; i < Actors.Num(); i++)
+	{
+		auto Actor = Actors[i];
+		if (Actor)
+		{
+			actors.push_back(Actor);
+		}
+	}
+	return actors;
+}
+
+
+
+struct sRegion {
+    uintptr_t start, end;
+};
+
+std::vector<sRegion> trapRegions;
+
+bool isObjectInvalid(UObject *obj) {
+    if (!IsPtrValid(obj)) {
+        return true;
+    }
+
+    if (!IsPtrValid(obj->ClassPrivate)) {
+        return true;
+    }
+
+    if (obj->InternalIndex <= 0) {
+        return true;
+    }
+
+    if (obj->NamePrivate.ComparisonIndex <= 0) {
+        return true;
+    }
+
+    if ((uintptr_t)(obj) % sizeof(uintptr_t) != 0x0 && (uintptr_t)(obj) % sizeof(uintptr_t) != 0x4) {
+        return true;
+    }
+
+    if (std::any_of(trapRegions.begin(), trapRegions.end(), [obj](sRegion region) { return ((uintptr_t) obj) >= region.start && ((uintptr_t) obj) <= region.end; }) ||
+        std::any_of(trapRegions.begin(), trapRegions.end(), [obj](sRegion region) { return ((uintptr_t) obj->ClassPrivate) >= region.start && ((uintptr_t) obj->ClassPrivate) <= region.end; })) {
+        return true;
+    }
+
+    return false;
+}
+
+AUAEGameMode *GameMode=0;
+ASTExtraPlayerCharacter *PlayerCharacter=0;
+ASTExtraPlayerController *PlayerController2=0;
+APlayerController *PlayerController=0;
+AGameNetworkManager *NetworkManager = 0;
+void GetActor(){
+
+         auto Actors = getActors();
+        for (int i = 0; i < Actors.size(); i++) {
+            auto Actor = Actors[i];
+            if (isObjectInvalid(Actor))
+                continue;
+            
+            if (Actor->IsA(AGameNetworkManager::StaticClass())) {
+                NetworkManager = (AGameNetworkManager *) Actor;
+                break;
+            }
+      
+			}
+        }
+        
+void 获取对象(){
+auto Actors = getActors();
+        for (int i = 0; i < Actors.size(); i++) {
+            auto Actor = Actors[i];
+
+            
+            if (Actor->IsA(AUAEGameMode::StaticClass())) {
+                GameMode = (AUAEGameMode *) Actor;
+                break;
+            }
+        }
+        for (int i = 0; i < Actors.size(); i++) {
+            auto Actor = Actors[i];
+
+            
+            if (Actor->IsA(ASTExtraPlayerCharacter::StaticClass())) {
+                PlayerCharacter = (ASTExtraPlayerCharacter *) Actor;
+                break;
+            }
+        }
+        for (int i = 0; i < Actors.size(); i++) {
+            auto Actor = Actors[i];
+
+            
+            if (Actor->IsA(ASTExtraPlayerController::StaticClass())) {
+                PlayerController2 = (ASTExtraPlayerController *) Actor;
+                break;
+            }
+        }
+        for (int i = 0; i < Actors.size(); i++) {
+            auto Actor = Actors[i];
+
+            
+            if (Actor->IsA(APlayerController::StaticClass())) {
+                PlayerController = (APlayerController *) Actor;
+                break;
+            }
+        }
+}
+void 修复(){
+获取对象();
+GameMode->bEnableClimbing=true;
+GameMode->bEnableDamage=true;
+GameMode->bEnableDamage=20;
+}

结构体/函数/普通函数.h

@@ -0,0 +1,215 @@
+ASTExtraPlayerCharacter *g_LocalPlayer = 0;
+ASTExtraPlayerController *g_LocalController = 0;
+// ================= 语言设置和记忆功能 =================
+enum class Language {
+    CHINESE,
+    ENGLISH
+};
+
+static Language currentLanguage = Language::CHINESE;
+static const char* LANGUAGE_FILE = "/sdcard/pubg_menu_language.conf";
+
+// 保存语言设置到文件
+void SaveLanguageSetting() {
+    std::ofstream file(LANGUAGE_FILE);
+    if (file.is_open()) {
+        file << static_cast<int>(currentLanguage);
+        file.close();
+    }
+}
+
+// 从文件加载语言设置
+void LoadLanguageSetting() {
+    std::ifstream file(LANGUAGE_FILE);
+    if (file.is_open()) {
+        int lang;
+        file >> lang;
+        currentLanguage = static_cast<Language>(lang);
+        file.close();
+    }
+}
+
+// 切换语言
+void ToggleLanguage() {
+    currentLanguage = (currentLanguage == Language::CHINESE) ? Language::ENGLISH : Language::CHINESE;
+    SaveLanguageSetting();
+}
+
+// 多语言文本函数
+const char* T(const char* chinese, const char* english) {
+    return (currentLanguage == Language::CHINESE) ? chinese : english;
+}
+#define IM_PI 3.14159265358979323846f
+#define RAD2DEG(x) ((float)(x) * (float)(180.f / IM_PI))
+#define DEG2RAD(x) ((float)(x) * (float)(IM_PI / 180.f))
+ImColor 紫色2 = ImColor(46,46,177);
+ImColor 粉色=ImColor(226,145,163,255);
+ImColor 浅蓝 = ImColor(ImVec4(36/255.f, 249/255.f, 217/255.f, 255/255.f));
+ImColor 蓝色 = ImColor(ImVec4(170/255.f, 203/255.f, 244/255.f, 0.95f));
+ImColor 白色 = ImColor(ImVec4(255/255.f, 255/255.f, 258/255.f, 0.95f));
+ImColor 浅粉 = ImColor(ImVec4(255/255.f, 200/255.f, 250/255.f, 0.95f));
+ImColor 黑色 = ImColor(ImVec4(0/255.f, 0/255.f, 0/255.f, 0.7f));
+ImColor 半黑 = ImColor(ImVec4(0/255.f, 0/255.f, 0/255.f, 0.18f));
+ImColor 血色 = ImColor(ImVec4(0/255.f, 249/255.f, 0/255.f, 0.35f));
+ImColor 红色 = ImColor(ImVec4(233/255.f, 55/255.f, 51/255.f, 0.95f));
+ImColor 绿色 = ImColor(ImVec4(50/255.f, 222/215.f, 50/255.f, 0.95f));
+ImColor 黄色 = ImColor(ImVec4(255/255.f, 255/255.f, 0/255.f, 0.95f));
+ImColor 橘黄 = ImColor(ImVec4(255/255.f, 150/255.f, 30/255.f, 0.95f));
+ImColor 粉红 = ImColor(ImVec4(220/255.f, 108/255.f, 1202/255.f, 0.95f));
+ImColor 紫色 = ImColor(ImVec4(169/255.f, 120/255.f, 223/255.f, 0.95f));	
+ImColor 空白 = ImColor(ImVec4(1.0/255.f, 1.0/255.f, 1.0/255.f, 0.0f));
+
+
+namespace Settings
+{
+    static int Tab = 1;
+}
+
+std::string getClipboardTextt() {
+    if (!g_App)
+ return "";
+
+    auto activity = g_App->activity;
+    if (!activity)
+ return "";
+
+    auto vm = activity->vm;
+    if (!vm)
+ return "";
+
+    auto object = activity->clazz;
+    if (!object)
+ return "";
+
+    std::string result;
+
+    JNIEnv *env;
+    vm->AttachCurrentThread(&env, 0);
+    {
+ auto ContextClass = env->FindClass("android/content/Context");
+ auto getSystemServiceMethod = env->GetMethodID(ContextClass, "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;");
+
+ auto str = env->NewStringUTF("clipboard");
+ auto clipboardManager = env->CallObjectMethod(object, getSystemServiceMethod, str);
+ env->DeleteLocalRef(str);
+
+ auto ClipboardManagerClass = env->FindClass("android/content/ClipboardManager");
+ auto getText = env->GetMethodID(ClipboardManagerClass, "getText", "()Ljava/lang/CharSequence;");
+
+ auto CharSequenceClass = env->FindClass("java/lang/CharSequence");
+ auto toStringMethod = env->GetMethodID(CharSequenceClass, "toString", "()Ljava/lang/String;");
+
+ auto text = env->CallObjectMethod(clipboardManager, getText);
+ if (text) {
+str = (jstring) env->CallObjectMethod(text, toStringMethod);
+result = env->GetStringUTFChars(str, 0);
+env->DeleteLocalRef(str);
+env->DeleteLocalRef(text);
+ }
+
+ env->DeleteLocalRef(CharSequenceClass);
+ env->DeleteLocalRef(ClipboardManagerClass);
+ env->DeleteLocalRef(clipboardManager);
+ env->DeleteLocalRef(ContextClass);
+    }
+    vm->DetachCurrentThread();
+
+    return result;
+}
+
+// 安全写入D内存
+void safeWritedword(uintptr_t addr, int value) {
+    long pageSize = sysconf(_SC_PAGESIZE);   // = 4096
+    uintptr_t pageStart = addr & ~(pageSize - 1);
+
+    if (mprotect((void*)(pageStart), pageSize * 2, PROT_READ | PROT_WRITE | PROT_EXEC) != 0) {
+        perror("mprotect failed");
+        return;
+    }
+
+    *((int*)addr) = value;
+}
+
+FVector WorldToRadar(float Yaw, FVector Origin, FVector LocalOrigin, float PosX, float PosY, Vector3 Size, bool &outbuff) {
+ bool flag = false;
+ double num = (double)Yaw;
+ double num2 = num * 0.017453292519943295;
+ float num3 = (float)std::cos(num2);
+ float num4 = (float)std::sin(num2);
+ float num5 = Origin.X - LocalOrigin.X;
+ float num6 = Origin.Y - LocalOrigin.Y;
+ struct FVector Xector;
+ Xector.X = (num6 * num3 - num5 * num4) / 150.f;
+ Xector.Y = (num5 * num3 + num6 * num4) / 150.f;
+ struct FVector Xector2;
+ Xector2.X = Xector.X + PosX + Size.X / 2.f;
+ Xector2.Y = -Xector.Y + PosY + Size.Y / 2.f;
+ bool flag2 = Xector2.X > PosX + Size.X;
+ if (flag2) {
+  Xector2.X = PosX + Size.X;
+ }else{
+  bool flag3 = Xector2.X < PosX;
+  if (flag3) {
+   Xector2.X = PosX;
+  }
+ }
+ bool flag4 = Xector2.Y > PosY + Size.Y;
+ if (flag4) {
+  Xector2.Y = PosY + Size.Y;
+ }else{
+  bool flag5 = Xector2.Y < PosY;
+  if (flag5){
+   Xector2.Y = PosY;
+  }
+ }
+ bool flag6 = Xector2.Y == PosY || Xector2.X == PosX;
+ if (flag6){
+  flag = true;
+ }
+ outbuff = flag;
+ return Xector2;
+}
+void VectorAnglesRadar(Vector3 & forward, FVector & angles) {
+ if (forward.X == 0.f && forward.Y == 0.f) {
+  angles.X = forward.Z > 0.f ? -90.f : 90.f;
+  angles.Y = 0.f;
+ } else {
+  angles.X = RAD2DEG(atan2(-forward.Z, forward.Magnitude(forward)));
+  angles.Y = RAD2DEG(atan2(forward.Y, forward.X));
+ }
+ angles.Z = 0.f;
+}
+void Box4Line(ImDrawList *draw, float thicc, int x, int y, int w, int h, int color) {
+    int iw = w / 4;
+    int ih = h / 4;
+    // top
+    draw->AddRect(ImVec2(x, y),ImVec2(x + iw, y), color, thicc);
+    draw->AddRect(ImVec2(x + w - iw, y),ImVec2(x + w, y), color, thicc);
+    draw->AddRect(ImVec2(x, y),ImVec2(x, y + ih), color, thicc);
+    draw->AddRect(ImVec2(x + w - 1, y),ImVec2(x + w - 1, y + ih), color, thicc);;
+    // bottom
+    draw->AddRect(ImVec2(x, y + h),ImVec2(x + iw, y + h), color, thicc);
+    draw->AddRect(ImVec2(x + w - iw, y + h),ImVec2(x + w, y + h), color, thicc);
+    draw->AddRect(ImVec2(x, y + h - ih), ImVec2(x, y + h), color, thicc);
+    draw->AddRect(ImVec2(x + w - 1, y + h - ih), ImVec2(x + w - 1, y + h), color, thicc);
+}
+void 绘制加粗文本(float size, float x, float y, ImColor color, ImColor color1, const char* str)
+{
+    ImGui::GetBackgroundDrawList()->AddText(NULL, size, {x-0.8, y-0.8}, color1, str);
+    ImGui::GetBackgroundDrawList()->AddText(NULL, size, {x+0.8, y+0.8}, color1, str);
+    ImGui::GetBackgroundDrawList()->AddText(NULL, size, {x, y}, color, str);
+}
+void RotateTriangle(std::array<Vector3, 3> & points, float rotation) {
+ const auto points_center = (points.at(0) + points.at(1) + points.at(2)) / 3;
+ for (auto & point : points) {
+  point = point - points_center;
+  const auto temp_x = point.X;
+  const auto temp_y = point.Y;
+  const auto theta = DEG2RAD(rotation);
+  const auto c = cosf(theta);
+  const auto s = sinf(theta);
+  point.X = temp_x * c - temp_y * s;
+  point.Y = temp_x * s + temp_y * c;
+  point = point + points_center;
+ }
+}

结构体/函数/混淆.cpp

@@ -0,0 +1,12 @@
+
+#include "混淆.h"
+
+size_t& _lxy_oxor_any_::X() {
+	static size_t x = 0; 
+	return x;
+}
+
+size_t& _lxy_oxor_any_::Y() {
+	static size_t y = 0; 
+	return y;
+}

结构体/函数/混淆.h

@@ -0,0 +1,699 @@
+#ifndef 混淆_H
+#define 混淆_H
+
+#if _KERNEL_MODE
+#ifndef _VCRUNTIME_DISABLED_WARNINGS
+#define _VCRUNTIME_DISABLED_WARNINGS
+#endif
+#endif
+
+#include <stdint.h>
+
+#if _WIN32 || _WIN64
+#if _WIN64
+#define 混淆_ENVIRONMENT64
+#else
+#define 混淆_ENVIRONMENT32
+#endif
+#endif
+
+#if __GNUC__
+#if __x86_64__ || __ppc64__
+#define 混淆_ENVIRONMENT64
+#else
+#define 混淆_ENVIRONMENT32
+#endif
+#endif
+
+#ifdef _MSC_VER
+#define 混淆_FORCEINLINE __forceinline
+#else
+#define 混淆_FORCEINLINE __attribute__((always_inline)) inline
+#endif
+
+#ifdef _DEBUG
+#define 混淆
+#define oxorvar
+#else
+#define 混淆(any) _lxy_oxor_any_::oxor_any<decltype(_lxy_oxor_any_::typeofs(any)), _lxy_oxor_any_::array_size(any), __COUNTER__>(any, _lxy_::make_index_sequence<sizeof(decltype(any))>()).get()
+#define oxorvar(var) ((var) + 混淆(0))
+#endif
+
+namespace _lxy_ {
+
+	// https://stackoverflow.com/a/32223343/16602611
+
+	template <size_t... Ints>
+	struct index_sequence {
+		using type = index_sequence;
+		using value_type = size_t;
+		static constexpr size_t size() noexcept { return sizeof...(Ints); }
+	};
+
+	// --------------------------------------------------------------------
+
+	template <class Sequence1, class Sequence2>
+	struct _merge_and_renumber;
+
+	template <size_t... I1, size_t... I2>
+	struct _merge_and_renumber<index_sequence<I1...>, index_sequence<I2...>>
+		: index_sequence<I1..., (sizeof...(I1) + I2)...>
+	{ };
+
+	// --------------------------------------------------------------------
+
+	template <size_t N>
+	struct make_index_sequence
+		: _merge_and_renumber<typename make_index_sequence<N / 2>::type,
+		typename make_index_sequence<N - N / 2>::type>
+	{ };
+
+	template<> struct make_index_sequence<0> : index_sequence<> { };
+	template<> struct make_index_sequence<1> : index_sequence<0> { };
+}
+
+namespace _lxy_oxor_any_ {
+
+	/*
+	template <size_t ...>
+	struct indexSequence {
+	};
+
+	template <size_t N, size_t ... Next>
+	struct indexSequenceHelper : public indexSequenceHelper<N - 1U, N - 1U, Next...> {
+	};
+
+	template <size_t ... Next>
+	struct indexSequenceHelper<0U, Next ... > {
+		using type = indexSequence<Next ... >;
+	};
+
+	template <size_t N>
+	using makeIndexSequence = typename indexSequenceHelper<N>::type;
+	*/
+
+	size_t& X();
+
+	size_t& Y();
+
+	static constexpr size_t base_key = static_cast<size_t>(
+		(__TIME__[7] - '0') +
+		(__TIME__[6] - '0') * 10 +
+		(__TIME__[4] - '0') * 60 +
+		(__TIME__[3] - '0') * 600 +
+		(__TIME__[1] - '0') * 3600 +
+		(__TIME__[0] - '0') * 36000);
+
+	template<uint32_t s, size_t n>
+	class random_constant_32 {
+		static constexpr uint32_t x = s ^ (s << 13);
+		static constexpr uint32_t y = x ^ (x >> 17);
+		static constexpr uint32_t z = y ^ (y << 5);
+	public:
+		static constexpr uint32_t value = random_constant_32<z, n - 1>::value;
+	};
+
+	template<uint32_t s>
+	class random_constant_32<s, 0> {
+	public:
+		static constexpr uint32_t value = s;
+	};
+
+	template<uint64_t s, size_t n>
+	class random_constant_64 {
+		static constexpr uint64_t x = s ^ (s << 13);
+		static constexpr uint64_t y = x ^ (x >> 7);
+		static constexpr uint64_t z = y ^ (y << 17);
+	public:
+		static constexpr uint64_t value = random_constant_64<z, n - 1>::value;
+	};
+
+	template<uint64_t s>
+	class random_constant_64<s, 0> {
+	public:
+		static constexpr uint64_t value = s;
+	};
+
+#ifdef 混淆_ENVIRONMENT64
+#define random_constant random_constant_64
+#else
+#define random_constant random_constant_32
+#endif 
+
+	template<typename T, size_t size>
+	static 混淆_FORCEINLINE constexpr size_t array_size(const T(&)[size]) { return size; }
+
+	template<typename T>
+	static 混淆_FORCEINLINE constexpr size_t array_size(T) { return 0; }
+
+	template<typename T, size_t size>
+	static inline T typeofs(const T(&)[size]);
+
+	template<typename T>
+	static inline T typeofs(T);
+
+	template<size_t key>
+	static 混淆_FORCEINLINE constexpr uint8_t encrypt_byte(uint8_t c, size_t i) {
+		return static_cast<uint8_t>(((c + (key * 7)) ^ (i + key)));
+	}
+
+	template<size_t key>
+	static 混淆_FORCEINLINE constexpr uint8_t decrypt_byte(uint8_t c, size_t i) {
+		//a ^ b == (a + b) - 2 * (a & b)
+		size_t a = c;
+		size_t b = i + key;
+		//size_t a_xor_b = (a + b) - 2 * (a & b);
+		size_t a_xor_b = (a + b) - ((a & b) + (b & a));
+		return static_cast<uint8_t>((a_xor_b)-(key * 7));
+	}
+
+	template<size_t key>
+	static 混淆_FORCEINLINE constexpr size_t limit() {
+		constexpr size_t bcf_value[] = { 1,2,3,4,5, 6,8,9,10,16, 32,40,64,66,100, 128,512,1000,1024,4096, 'a','z','A','Z','*' };
+		return bcf_value[key % (sizeof(bcf_value) / sizeof(bcf_value[0]))];
+	}
+
+	template<typename return_type, size_t key, size_t size>
+	static 混淆_FORCEINLINE const return_type decrypt(uint8_t(&buffer)[size]) {
+#ifndef 混淆_DISABLE_OBFUSCATION
+
+		uint8_t source;
+		uint8_t decrypted; //do not assign initial value
+		size_t stack_x;
+		size_t stack_y;
+
+	loc_start_1:
+		stack_x = X();
+		stack_y = Y();
+	loc_start_2:
+		for (size_t i = 0; i < size; i++) {
+			source = buffer[i];
+		loc_start_3:
+			if (stack_x <= i) {
+				if (stack_x < stack_y + limit<key * __COUNTER__>()) {
+					decrypted = decrypt_byte<key* __COUNTER__>(source, i);//fake
+				}
+				else if (stack_x == stack_y + limit<key * __COUNTER__>() % 1 + 1) {
+					//unreachable
+					decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+					goto loc_unreachable_9;
+				}
+				else if (stack_x == stack_y + limit<key * __COUNTER__>() % 2 + 1) {
+					//unreachable
+					decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+					goto loc_unreachable_8;
+				}
+				else if (stack_x == stack_y + limit<key * __COUNTER__>() % 3 + 1) {
+					//unreachable
+					decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+					goto loc_unreachable_7;
+				}
+				else if (stack_x == stack_y + limit<key * __COUNTER__>() % 4 + 1) {
+					//unreachable
+					decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+					goto loc_unreachable_6;
+				}
+				else if (stack_x == stack_y + limit<key * __COUNTER__>() % 5 + 1) {
+					//unreachable
+					decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+					goto loc_unreachable_5;
+				}
+				else if (stack_x == stack_y + limit<key * __COUNTER__>() % 6 + 1) {
+					//unreachable
+					decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+					goto loc_unreachable_4;
+				}
+				else if (stack_x == stack_y + limit<key * __COUNTER__>() % 7 + 1) {
+					//unreachable
+					decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+					goto loc_unreachable_3;
+				}
+				else if (stack_x == stack_y + limit<key * __COUNTER__>() % 8 + 1) {
+					//unreachable
+					decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+					goto loc_unreachable_2;
+				}
+				else if (stack_x == stack_y + limit<key * __COUNTER__>() % 9 + 1) {
+					//unreachable
+					decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+					goto loc_unreachable_1;
+				}
+			loc_start_4:
+				if (stack_y <= i) {
+					if (stack_x < stack_y + limit<key * __COUNTER__>()) {
+						decrypted = decrypt_byte<key* __COUNTER__>(source, i);//fake
+					}
+					else if (stack_x == stack_y + limit<key * __COUNTER__>() % 1 + 1) {
+						//unreachable
+						decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+						goto loc_unreachable_1;
+					}
+					else if (stack_x == stack_y + limit<key * __COUNTER__>() % 2 + 1) {
+						//unreachable
+						decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+						goto loc_unreachable_2;
+					}
+					else if (stack_x == stack_y + limit<key * __COUNTER__>() % 3 + 1) {
+						//unreachable
+						decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+						goto loc_unreachable_3;
+					}
+					else if (stack_x == stack_y + limit<key * __COUNTER__>() % 4 + 1) {
+						//unreachable
+						decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+						goto loc_unreachable_4;
+					}
+					else if (stack_x == stack_y + limit<key * __COUNTER__>() % 5 + 1) {
+						//unreachable
+						decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+						goto loc_unreachable_5;
+					}
+					else if (stack_x == stack_y + limit<key * __COUNTER__>() % 6 + 1) {
+						//unreachable
+						decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+						goto loc_unreachable_6;
+					}
+					else if (stack_x == stack_y + limit<key * __COUNTER__>() % 7 + 1) {
+						//unreachable
+						decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+						goto loc_unreachable_7;
+					}
+					else if (stack_x == stack_y + limit<key * __COUNTER__>() % 8 + 1) {
+						//unreachable
+						decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+						goto loc_unreachable_8;
+					}
+					else if (stack_x == stack_y + limit<key * __COUNTER__>() % 9 + 1) {
+						//unreachable
+						decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+						goto loc_unreachable_9;
+					}
+				loc_start_5:
+					if (stack_x + stack_y <= i) {
+						if (stack_x < stack_y + limit<key * __COUNTER__>()) {
+							decrypted = decrypt_byte<key>(source, i);//real
+						}
+						else if (stack_x == stack_y + limit<key * __COUNTER__>() % 1 + 1) {
+							//unreachable
+							decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+							goto loc_unreachable_9;
+						}
+						else if (stack_x == stack_y + limit<key * __COUNTER__>() % 2 + 1) {
+							//unreachable
+							decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+							goto loc_unreachable_8;
+						}
+						else if (stack_x == stack_y + limit<key * __COUNTER__>() % 3 + 1) {
+							//unreachable
+							decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+							goto loc_unreachable_7;
+						}
+						else if (stack_x == stack_y + limit<key * __COUNTER__>() % 4 + 1) {
+							//unreachable
+							decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+							goto loc_unreachable_6;
+						}
+						else if (stack_x == stack_y + limit<key * __COUNTER__>() % 5 + 1) {
+							//unreachable
+							decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+							goto loc_unreachable_5;
+						}
+						else if (stack_x == stack_y + limit<key * __COUNTER__>() % 6 + 1) {
+							//unreachable
+							decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+							goto loc_unreachable_4;
+						}
+						else if (stack_x == stack_y + limit<key * __COUNTER__>() % 7 + 1) {
+							//unreachable
+							decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+							goto loc_unreachable_3;
+						}
+						else if (stack_x == stack_y + limit<key * __COUNTER__>() % 8 + 1) {
+							//unreachable
+							decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+							goto loc_unreachable_2;
+						}
+						else if (stack_x == stack_y + limit<key * __COUNTER__>() % 9 + 1) {
+							//unreachable
+							decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+							goto loc_unreachable_1;
+						}
+					loc_start_6:
+						if (stack_x + stack_y != limit<key * __COUNTER__>()) {
+							if (stack_x > stack_y + limit<key * __COUNTER__>()) {
+								//unreachable
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>() % 1 + 1) {
+								//unreachable
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_1;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>() % 2 + 1) {
+								//unreachable
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_2;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>() % 3 + 1) {
+								//unreachable
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_3;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>() % 4 + 1) {
+								//unreachable
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_4;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>() % 5 + 1) {
+								//unreachable
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_5;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>() % 6 + 1) {
+								//unreachable
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_6;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>() % 7 + 1) {
+								//unreachable
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_7;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>() % 8 + 1) {
+								//unreachable
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_8;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>() % 9 + 1) {
+								//unreachable
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_9;
+							}
+						loc_start_7:
+							if (stack_x < limit<key * __COUNTER__>()) {
+								if (stack_x > stack_y + limit<key * __COUNTER__>()) {
+									//unreachable
+									decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								}
+								else if (stack_x == stack_y + limit<key * __COUNTER__>() % 1 + 1) {
+									//unreachable
+									decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+									goto loc_unreachable_9;
+								}
+								else if (stack_x == stack_y + limit<key * __COUNTER__>() % 2 + 1) {
+									//unreachable
+									decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+									goto loc_unreachable_8;
+								}
+								else if (stack_x == stack_y + limit<key * __COUNTER__>() % 3 + 1) {
+									//unreachable
+									decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+									goto loc_unreachable_7;
+								}
+								else if (stack_x == stack_y + limit<key * __COUNTER__>() % 4 + 1) {
+									//unreachable
+									decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+									goto loc_unreachable_6;
+								}
+								else if (stack_x == stack_y + limit<key * __COUNTER__>() % 5 + 1) {
+									//unreachable
+									decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+									goto loc_unreachable_5;
+								}
+								else if (stack_x == stack_y + limit<key * __COUNTER__>() % 6 + 1) {
+									//unreachable
+									decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+									goto loc_unreachable_4;
+								}
+								else if (stack_x == stack_y + limit<key * __COUNTER__>() % 7 + 1) {
+									//unreachable
+									decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+									goto loc_unreachable_3;
+								}
+								else if (stack_x == stack_y + limit<key * __COUNTER__>() % 8 + 1) {
+									//unreachable
+									decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+									goto loc_unreachable_2;
+								}
+								else if (stack_x == stack_y + limit<key * __COUNTER__>() % 9 + 1) {
+									//unreachable
+									decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+									goto loc_unreachable_1;
+								}
+							loc_start_8:
+								if (stack_y < limit<key * __COUNTER__>()) {
+								loc_start_9:
+									buffer[i] = decrypted;//assign
+								}
+								else {
+									//unreachable
+									decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+									decrypted += decrypted;
+								loc_unreachable_1:
+									buffer[i] = decrypt_byte<key* __COUNTER__>(source, i);
+								loc_unreachable_2:
+									stack_y++;
+								loc_unreachable_3:
+									i--;
+								}
+							}
+							else {
+								//unreachable
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								decrypted += buffer[i];
+							loc_unreachable_4:
+								buffer[i] = decrypt_byte<key* __COUNTER__>(source, i);
+								buffer[i] += decrypted;
+							loc_unreachable_5:
+								stack_x += stack_y;
+							loc_unreachable_6:
+								i--;
+								i -= decrypted;
+							}
+						}
+						else {
+							//unreachable
+							decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+							decrypted -= buffer[i];
+						loc_unreachable_7:
+							buffer[i] = decrypt_byte<key* __COUNTER__>(source, i);
+							stack_y++;
+							i -= buffer[i];
+							i -= stack_y;
+						loc_unreachable_8:
+							buffer[i] = decrypt_byte<key* __COUNTER__>(source, i);
+							stack_x++;
+							i--;
+							i -= stack_x;
+						loc_unreachable_9:
+							i += buffer[i];
+							i += stack_y;
+							continue;
+						}
+					}
+					else {
+						//unreachable
+						while (true) {
+							if (stack_x == stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_1;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_2;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_3;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_4;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_5;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_6;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_7;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_8;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_9;
+							}
+							else if (stack_x == stack_y + limit<key * __COUNTER__>()) {
+								continue;
+							}
+							else {
+								stack_x = stack_y + limit<key* __COUNTER__>();
+								stack_y = stack_x + limit<key* __COUNTER__>();
+							}
+
+							if (stack_x < stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_start_1;
+							}
+							else if (stack_x < stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_start_2;
+							}
+							else if (stack_x < stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_start_3;
+							}
+							else if (stack_x < stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_start_4;
+							}
+							else if (stack_x < stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_start_5;
+							}
+							else if (stack_x < stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_start_6;
+							}
+							else if (stack_x < stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_start_7;
+							}
+							else if (stack_x < stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_start_8;
+							}
+							else if (stack_x < stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_start_9;
+							}
+							else if (stack_x < stack_y + limit<key * __COUNTER__>()) {
+								continue;
+							}
+							else {
+								stack_x = stack_y + limit<key* __COUNTER__>();
+								stack_y = stack_x + limit<key* __COUNTER__>();
+							}
+
+							if (stack_x > stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_9;
+							}
+							else if (stack_x > stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_8;
+							}
+							else if (stack_x > stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_7;
+							}
+							else if (stack_x > stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_6;
+							}
+							else if (stack_x > stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_5;
+							}
+							else if (stack_x > stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_4;
+							}
+							else if (stack_x > stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_3;
+							}
+							else if (stack_x > stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_2;
+							}
+							else if (stack_x > stack_y + limit<key * __COUNTER__>()) {
+								decrypted = decrypt_byte<key* __COUNTER__>(source, i);
+								goto loc_unreachable_1;
+							}
+							else if (stack_x > stack_y + limit<key * __COUNTER__>()) {
+								continue;
+							}
+							else {
+								stack_x = stack_y + limit<key* __COUNTER__>();
+								stack_y = stack_x + limit<key* __COUNTER__>();
+							}
+						}
+					}
+				}
+				else {
+					//unreachable
+					//Ooops, Decompilation failure:
+					//401000: stack frame is too big
+					return reinterpret_cast<return_type>(buffer + ((key * __COUNTER__) % 0x400000 + 0x1400000));
+				}
+			}
+			else {
+				//unreachable
+				//Ooops, Decompilation failure:
+				//401000: stack frame is too big
+				return reinterpret_cast<return_type>(buffer + ((key * __COUNTER__) % 0x1400000 + 0x400000));
+			}
+		}
+
+#else
+		for (size_t i = 0; i < size; i++) {
+			buffer[i] = decrypt_byte<key>(buffer[i], i);
+		}
+#endif // 混淆_DISABLE_OBFUSCATION
+		return reinterpret_cast<return_type>(buffer);
+	}
+
+	static 混淆_FORCEINLINE constexpr size_t align(size_t n, size_t a) {
+		return (n + a - 1) & ~(a - 1);
+	}
+
+	template<typename any_t, size_t ary_size, size_t counter>
+	class oxor_any {
+
+		static constexpr size_t size = align(ary_size * sizeof(any_t), 16)
+			+ random_constant<counter^ base_key, (counter^ base_key) % 128>::value % (16 + 1);
+
+		static constexpr size_t key = random_constant<counter^ base_key, (size^ base_key) % 128>::value;
+
+		uint8_t buffer[size];
+
+	public:
+
+		template<size_t... indices>
+		混淆_FORCEINLINE constexpr oxor_any(const any_t(&any)[ary_size], _lxy_::index_sequence<indices...>) :
+			buffer{ encrypt_byte<key>(((uint8_t*)&any)[indices], indices)... } {
+		}
+
+		混淆_FORCEINLINE const any_t* get() { return decrypt<const any_t*, key>(buffer); }
+	};
+
+	template<typename any_t, size_t counter>
+	class oxor_any<any_t, 0, counter> {
+
+		static constexpr size_t size = align(sizeof(any_t), 16)
+			+ random_constant<counter^ base_key, (counter^ base_key) % 128>::value % (16 + 1);
+
+		static constexpr size_t key = random_constant<counter^ base_key, (size^ base_key) % 128>::value;
+
+		uint8_t buffer[size];
+
+	public:
+
+		template<size_t... indices>
+		混淆_FORCEINLINE constexpr oxor_any(any_t any, _lxy_::index_sequence<indices...>) :
+			buffer{ encrypt_byte<key>(reinterpret_cast<uint8_t*>(&any)[indices], indices)... } {
+		}
+
+		混淆_FORCEINLINE const any_t get() { return *decrypt<const any_t*, key>(buffer); }
+	};
+}
+
+#endif // 混淆_H

结构体/数据/SDK/PUBGM_AIModule_structs.hpp

@@ -0,0 +1,931 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:39 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Enums
+//---------------------------------------------------------------------------
+
+// Enum AIModule.EPathFollowingResult
+enum class EPathFollowingResult : uint8_t
+{
+	EPathFollowingResult__Success  = 0,
+	EPathFollowingResult__Blocked  = 1,
+	EPathFollowingResult__OffPath  = 2,
+	EPathFollowingResult__Aborted  = 3,
+	EPathFollowingResult__Skipped_DEPRECATED = 4,
+	EPathFollowingResult__Invalid  = 5,
+	EPathFollowingResult__EPathFollowingResult_MAX = 6
+};
+
+
+// Enum AIModule.EEnvQueryStatus
+enum class EEnvQueryStatus : uint8_t
+{
+	EEnvQueryStatus__Processing    = 0,
+	EEnvQueryStatus__Success       = 1,
+	EEnvQueryStatus__Failed        = 2,
+	EEnvQueryStatus__Aborted       = 3,
+	EEnvQueryStatus__OwnerLost     = 4,
+	EEnvQueryStatus__MissingParam  = 5,
+	EEnvQueryStatus__EEnvQueryStatus_MAX = 6
+};
+
+
+// Enum AIModule.EAISenseNotifyType
+enum class EAISenseNotifyType : uint8_t
+{
+	EAISenseNotifyType__OnEveryPerception = 0,
+	EAISenseNotifyType__OnPerceptionChange = 1,
+	EAISenseNotifyType__EAISenseNotifyType_MAX = 2
+};
+
+
+// Enum AIModule.EAITaskPriority
+enum class EAITaskPriority : uint8_t
+{
+	EAITaskPriority__Lowest        = 0,
+	EAITaskPriority__Low           = 1,
+	EAITaskPriority__AutonomousAI  = 2,
+	EAITaskPriority__High          = 3,
+	EAITaskPriority__Ultimate      = 4,
+	EAITaskPriority__EAITaskPriority_MAX = 5
+};
+
+
+// Enum AIModule.EGenericAICheck
+enum class EGenericAICheck : uint8_t
+{
+	EGenericAICheck__Less          = 0,
+	EGenericAICheck__LessOrEqual   = 1,
+	EGenericAICheck__Equal         = 2,
+	EGenericAICheck__NotEqual      = 3,
+	EGenericAICheck__GreaterOrEqual = 4,
+	EGenericAICheck__Greater       = 5,
+	EGenericAICheck__IsTrue        = 6,
+	EGenericAICheck__MAX           = 7
+};
+
+
+// Enum AIModule.EAILockSource
+enum class EAILockSource : uint8_t
+{
+	EAILockSource__Animation       = 0,
+	EAILockSource__Logic           = 1,
+	EAILockSource__Script          = 2,
+	EAILockSource__Gameplay        = 3,
+	EAILockSource__MAX             = 4
+};
+
+
+// Enum AIModule.EAIRequestPriority
+enum class EAIRequestPriority : uint8_t
+{
+	EAIRequestPriority__SoftScript = 0,
+	EAIRequestPriority__Logic      = 1,
+	EAIRequestPriority__HardScript = 2,
+	EAIRequestPriority__Reaction   = 3,
+	EAIRequestPriority__Ultimate   = 4,
+	EAIRequestPriority__MAX        = 5
+};
+
+
+// Enum AIModule.EPawnActionEventType
+enum class EPawnActionEventType : uint8_t
+{
+	EPawnActionEventType__Invalid  = 0,
+	EPawnActionEventType__FailedToStart = 1,
+	EPawnActionEventType__InstantAbort = 2,
+	EPawnActionEventType__FinishedAborting = 3,
+	EPawnActionEventType__FinishedExecution = 4,
+	EPawnActionEventType__Push     = 5,
+	EPawnActionEventType__EPawnActionEventType_MAX = 6
+};
+
+
+// Enum AIModule.EPawnActionResult
+enum class EPawnActionResult : uint8_t
+{
+	EPawnActionResult__NotStarted  = 0,
+	EPawnActionResult__InProgress  = 1,
+	EPawnActionResult__Success     = 2,
+	EPawnActionResult__Failed      = 3,
+	EPawnActionResult__Aborted     = 4,
+	EPawnActionResult__EPawnActionResult_MAX = 5
+};
+
+
+// Enum AIModule.EPawnActionAbortState
+enum class EPawnActionAbortState : uint8_t
+{
+	EPawnActionAbortState__NeverStarted = 0,
+	EPawnActionAbortState__NotBeingAborted = 1,
+	EPawnActionAbortState__MarkPendingAbort = 2,
+	EPawnActionAbortState__LatentAbortInProgress = 3,
+	EPawnActionAbortState__AbortDone = 4,
+	EPawnActionAbortState__MAX     = 5
+};
+
+
+// Enum AIModule.FAIDistanceType
+enum class EFAIDistanceType : uint8_t
+{
+	FAIDistanceType__Distance3D    = 0,
+	FAIDistanceType__Distance2D    = 1,
+	FAIDistanceType__DistanceZ     = 2,
+	FAIDistanceType__MAX           = 3
+};
+
+
+// Enum AIModule.EAIOptionFlag
+enum class EAIOptionFlag : uint8_t
+{
+	EAIOptionFlag__Default         = 0,
+	EAIOptionFlag__Enable          = 1,
+	EAIOptionFlag__Disable         = 2,
+	EAIOptionFlag__MAX             = 3
+};
+
+
+// Enum AIModule.EBTFlowAbortMode
+enum class EBTFlowAbortMode : uint8_t
+{
+	EBTFlowAbortMode__None         = 0,
+	EBTFlowAbortMode__LowerPriority = 1,
+	EBTFlowAbortMode__Self         = 2,
+	EBTFlowAbortMode__Both         = 3,
+	EBTFlowAbortMode__EBTFlowAbortMode_MAX = 4
+};
+
+
+// Enum AIModule.EBTNodeResult
+enum class EBTNodeResult : uint8_t
+{
+	EBTNodeResult__Succeeded       = 0,
+	EBTNodeResult__Failed          = 1,
+	EBTNodeResult__Aborted         = 2,
+	EBTNodeResult__InProgress      = 3,
+	EBTNodeResult__EBTNodeResult_MAX = 4
+};
+
+
+// Enum AIModule.ETextKeyOperation
+enum class ETextKeyOperation : uint8_t
+{
+	ETextKeyOperation__Equal       = 0,
+	ETextKeyOperation__NotEqual    = 1,
+	ETextKeyOperation__Contain     = 2,
+	ETextKeyOperation__NotContain  = 3,
+	ETextKeyOperation__ETextKeyOperation_MAX = 4
+};
+
+
+// Enum AIModule.EArithmeticKeyOperation
+enum class EArithmeticKeyOperation : uint8_t
+{
+	EArithmeticKeyOperation__Equal = 0,
+	EArithmeticKeyOperation__NotEqual = 1,
+	EArithmeticKeyOperation__Less  = 2,
+	EArithmeticKeyOperation__LessOrEqual = 3,
+	EArithmeticKeyOperation__Greater = 4,
+	EArithmeticKeyOperation__GreaterOrEqual = 5,
+	EArithmeticKeyOperation__EArithmeticKeyOperation_MAX = 6
+};
+
+
+// Enum AIModule.EBasicKeyOperation
+enum class EBasicKeyOperation : uint8_t
+{
+	EBasicKeyOperation__Set        = 0,
+	EBasicKeyOperation__NotSet     = 1,
+	EBasicKeyOperation__EBasicKeyOperation_MAX = 2
+};
+
+
+// Enum AIModule.EBTParallelMode
+enum class EBTParallelMode : uint8_t
+{
+	EBTParallelMode__AbortBackground = 0,
+	EBTParallelMode__WaitForBackground = 1,
+	EBTParallelMode__EBTParallelMode_MAX = 2
+};
+
+
+// Enum AIModule.EBTDecoratorLogic
+enum class EBTDecoratorLogic : uint8_t
+{
+	EBTDecoratorLogic__Invalid     = 0,
+	EBTDecoratorLogic__Test        = 1,
+	EBTDecoratorLogic__And         = 2,
+	EBTDecoratorLogic__Or          = 3,
+	EBTDecoratorLogic__Not         = 4,
+	EBTDecoratorLogic__EBTDecoratorLogic_MAX = 5
+};
+
+
+// Enum AIModule.EBTChildIndex
+enum class EBTChildIndex : uint8_t
+{
+	EBTChildIndex__FirstNode       = 0,
+	EBTChildIndex__TaskNode        = 1,
+	EBTChildIndex__EBTChildIndex_MAX = 2
+};
+
+
+// Enum AIModule.EBTBlackboardRestart
+enum class EBTBlackboardRestart : uint8_t
+{
+	EBTBlackboardRestart__ValueChange = 0,
+	EBTBlackboardRestart__ResultChange = 1,
+	EBTBlackboardRestart__EBTBlackboardRestart_MAX = 2
+};
+
+
+// Enum AIModule.EBlackBoardEntryComparison
+enum class EBlackBoardEntryComparison : uint8_t
+{
+	EBlackBoardEntryComparison__Equal = 0,
+	EBlackBoardEntryComparison__NotEqual = 1,
+	EBlackBoardEntryComparison__EBlackBoardEntryComparison_MAX = 2
+};
+
+
+// Enum AIModule.EPathExistanceQueryType
+enum class EPathExistanceQueryType : uint8_t
+{
+	EPathExistanceQueryType__NavmeshRaycast2D = 0,
+	EPathExistanceQueryType__HierarchicalQuery = 1,
+	EPathExistanceQueryType__RegularPathFinding = 2,
+	EPathExistanceQueryType__EPathExistanceQueryType_MAX = 3
+};
+
+
+// Enum AIModule.EPointOnCircleSpacingMethod
+enum class EPointOnCircleSpacingMethod : uint8_t
+{
+	EPointOnCircleSpacingMethod__BySpaceBetween = 0,
+	EPointOnCircleSpacingMethod__ByNumberOfPoints = 1,
+	EPointOnCircleSpacingMethod__EPointOnCircleSpacingMethod_MAX = 2
+};
+
+
+// Enum AIModule.EEQSNormalizationType
+enum class EEQSNormalizationType : uint8_t
+{
+	EEQSNormalizationType__Absolute = 0,
+	EEQSNormalizationType__RelativeToScores = 1,
+	EEQSNormalizationType__EEQSNormalizationType_MAX = 2
+};
+
+
+// Enum AIModule.EEnvTestDistance
+enum class EEnvTestDistance : uint8_t
+{
+	EEnvTestDistance__Distance3D   = 0,
+	EEnvTestDistance__Distance2D   = 1,
+	EEnvTestDistance__DistanceZ    = 2,
+	EEnvTestDistance__DistanceAbsoluteZ = 3,
+	EEnvTestDistance__EEnvTestDistance_MAX = 4
+};
+
+
+// Enum AIModule.EEnvTestDot
+enum class EEnvTestDot : uint8_t
+{
+	EEnvTestDot__Dot3D             = 0,
+	EEnvTestDot__Dot2D             = 1,
+	EEnvTestDot__EEnvTestDot_MAX   = 2
+};
+
+
+// Enum AIModule.EEnvTestPathfinding
+enum class EEnvTestPathfinding : uint8_t
+{
+	EEnvTestPathfinding__PathExist = 0,
+	EEnvTestPathfinding__PathCost  = 1,
+	EEnvTestPathfinding__PathLength = 2,
+	EEnvTestPathfinding__EEnvTestPathfinding_MAX = 3
+};
+
+
+// Enum AIModule.EEnvQueryTestClamping
+enum class EEnvQueryTestClamping : uint8_t
+{
+	EEnvQueryTestClamping__None    = 0,
+	EEnvQueryTestClamping__SpecifiedValue = 1,
+	EEnvQueryTestClamping__FilterThreshold = 2,
+	EEnvQueryTestClamping__EEnvQueryTestClamping_MAX = 3
+};
+
+
+// Enum AIModule.EEnvDirection
+enum class EEnvDirection : uint8_t
+{
+	EEnvDirection__TwoPoints       = 0,
+	EEnvDirection__Rotation        = 1,
+	EEnvDirection__EEnvDirection_MAX = 2
+};
+
+
+// Enum AIModule.EEnvOverlapShape
+enum class EEnvOverlapShape : uint8_t
+{
+	EEnvOverlapShape__Box          = 0,
+	EEnvOverlapShape__Sphere       = 1,
+	EEnvOverlapShape__Capsule      = 2,
+	EEnvOverlapShape__EEnvOverlapShape_MAX = 3
+};
+
+
+// Enum AIModule.EEnvTraceShape
+enum class EEnvTraceShape : uint8_t
+{
+	EEnvTraceShape__Line           = 0,
+	EEnvTraceShape__Box            = 1,
+	EEnvTraceShape__Sphere         = 2,
+	EEnvTraceShape__Capsule        = 3,
+	EEnvTraceShape__EEnvTraceShape_MAX = 4
+};
+
+
+// Enum AIModule.EEnvQueryTrace
+enum class EEnvQueryTrace : uint8_t
+{
+	EEnvQueryTrace__None           = 0,
+	EEnvQueryTrace__Navigation     = 1,
+	EEnvQueryTrace__Geometry       = 2,
+	EEnvQueryTrace__NavigationOverLedges = 3,
+	EEnvQueryTrace__EEnvQueryTrace_MAX = 4
+};
+
+
+// Enum AIModule.EAIParamType
+enum class EAIParamType : uint8_t
+{
+	EAIParamType__Float            = 0,
+	EAIParamType__Int              = 1,
+	EAIParamType__Bool             = 2,
+	EAIParamType__MAX              = 3
+};
+
+
+// Enum AIModule.EEnvQueryParam
+enum class EEnvQueryParam : uint8_t
+{
+	EEnvQueryParam__Float          = 0,
+	EEnvQueryParam__Int            = 1,
+	EEnvQueryParam__Bool           = 2,
+	EEnvQueryParam__EEnvQueryParam_MAX = 3
+};
+
+
+// Enum AIModule.EEnvQueryRunMode
+enum class EEnvQueryRunMode : uint8_t
+{
+	EEnvQueryRunMode__SingleResult = 0,
+	EEnvQueryRunMode__RandomBest5Pct = 1,
+	EEnvQueryRunMode__RandomBest25Pct = 2,
+	EEnvQueryRunMode__AllMatching  = 3,
+	EEnvQueryRunMode__EEnvQueryRunMode_MAX = 4
+};
+
+
+// Enum AIModule.EEnvTestScoreOperator
+enum class EEnvTestScoreOperator : uint8_t
+{
+	EEnvTestScoreOperator__AverageScore = 0,
+	EEnvTestScoreOperator__MinScore = 1,
+	EEnvTestScoreOperator__MaxScore = 2,
+	EEnvTestScoreOperator__EEnvTestScoreOperator_MAX = 3
+};
+
+
+// Enum AIModule.EEnvTestFilterOperator
+enum class EEnvTestFilterOperator : uint8_t
+{
+	EEnvTestFilterOperator__AllPass = 0,
+	EEnvTestFilterOperator__AnyPass = 1,
+	EEnvTestFilterOperator__EEnvTestFilterOperator_MAX = 2
+};
+
+
+// Enum AIModule.EEnvTestCost
+enum class EEnvTestCost : uint8_t
+{
+	EEnvTestCost__Low              = 0,
+	EEnvTestCost__Medium           = 1,
+	EEnvTestCost__High             = 2,
+	EEnvTestCost__EEnvTestCost_MAX = 3
+};
+
+
+// Enum AIModule.EEnvTestWeight
+enum class EEnvTestWeight : uint8_t
+{
+	EEnvTestWeight__None           = 0,
+	EEnvTestWeight__Square         = 1,
+	EEnvTestWeight__Inverse        = 2,
+	EEnvTestWeight__Unused         = 3,
+	EEnvTestWeight__Constant       = 4,
+	EEnvTestWeight__Skip           = 5,
+	EEnvTestWeight__EEnvTestWeight_MAX = 6
+};
+
+
+// Enum AIModule.EEnvTestScoreEquation
+enum class EEnvTestScoreEquation : uint8_t
+{
+	EEnvTestScoreEquation__Linear  = 0,
+	EEnvTestScoreEquation__Square  = 1,
+	EEnvTestScoreEquation__InverseLinear = 2,
+	EEnvTestScoreEquation__SquareRoot = 3,
+	EEnvTestScoreEquation__Constant = 4,
+	EEnvTestScoreEquation__EEnvTestScoreEquation_MAX = 5
+};
+
+
+// Enum AIModule.EEnvTestFilterType
+enum class EEnvTestFilterType : uint8_t
+{
+	EEnvTestFilterType__Minimum    = 0,
+	EEnvTestFilterType__Maximum    = 1,
+	EEnvTestFilterType__Range      = 2,
+	EEnvTestFilterType__Match      = 3,
+	EEnvTestFilterType__EEnvTestFilterType_MAX = 4
+};
+
+
+// Enum AIModule.EEnvTestPurpose
+enum class EEnvTestPurpose : uint8_t
+{
+	EEnvTestPurpose__Filter        = 0,
+	EEnvTestPurpose__Score         = 1,
+	EEnvTestPurpose__FilterAndScore = 2,
+	EEnvTestPurpose__EEnvTestPurpose_MAX = 3
+};
+
+
+// Enum AIModule.EEnvQueryHightlightMode
+enum class EEnvQueryHightlightMode : uint8_t
+{
+	EEnvQueryHightlightMode__All   = 0,
+	EEnvQueryHightlightMode__Best5Pct = 1,
+	EEnvQueryHightlightMode__Best25Pct = 2,
+	EEnvQueryHightlightMode__EEnvQueryHightlightMode_MAX = 3
+};
+
+
+// Enum AIModule.ETeamAttitude
+enum class ETeamAttitude : uint8_t
+{
+	ETeamAttitude__Friendly        = 0,
+	ETeamAttitude__Neutral         = 1,
+	ETeamAttitude__Hostile         = 2,
+	ETeamAttitude__ETeamAttitude_MAX = 3
+};
+
+
+// Enum AIModule.EPathFollowingRequestResult
+enum class EPathFollowingRequestResult : uint8_t
+{
+	EPathFollowingRequestResult__Failed = 0,
+	EPathFollowingRequestResult__AlreadyAtGoal = 1,
+	EPathFollowingRequestResult__RequestSuccessful = 2,
+	EPathFollowingRequestResult__EPathFollowingRequestResult_MAX = 3
+};
+
+
+// Enum AIModule.EPathFollowingAction
+enum class EPathFollowingAction : uint8_t
+{
+	EPathFollowingAction__Error    = 0,
+	EPathFollowingAction__NoMove   = 1,
+	EPathFollowingAction__DirectMove = 2,
+	EPathFollowingAction__PartialPath = 3,
+	EPathFollowingAction__PathToGoal = 4,
+	EPathFollowingAction__EPathFollowingAction_MAX = 5
+};
+
+
+// Enum AIModule.EPathFollowingStatus
+enum class EPathFollowingStatus : uint8_t
+{
+	EPathFollowingStatus__Idle     = 0,
+	EPathFollowingStatus__Waiting  = 1,
+	EPathFollowingStatus__Paused   = 2,
+	EPathFollowingStatus__Moving   = 3,
+	EPathFollowingStatus__EPathFollowingStatus_MAX = 4
+};
+
+
+// Enum AIModule.EPawnActionFailHandling
+enum class EPawnActionFailHandling : uint8_t
+{
+	EPawnActionFailHandling__RequireSuccess = 0,
+	EPawnActionFailHandling__IgnoreFailure = 1,
+	EPawnActionFailHandling__EPawnActionFailHandling_MAX = 2
+};
+
+
+// Enum AIModule.EPawnSubActionTriggeringPolicy
+enum class EPawnSubActionTriggeringPolicy : uint8_t
+{
+	EPawnSubActionTriggeringPolicy__CopyBeforeTriggering = 0,
+	EPawnSubActionTriggeringPolicy__ReuseInstances = 1,
+	EPawnSubActionTriggeringPolicy__EPawnSubActionTriggeringPolicy_MAX = 2
+};
+
+
+// Enum AIModule.EPawnActionMoveMode
+enum class EPawnActionMoveMode : uint8_t
+{
+	EPawnActionMoveMode__UsePathfinding = 0,
+	EPawnActionMoveMode__StraightLine = 1,
+	EPawnActionMoveMode__EPawnActionMoveMode_MAX = 2
+};
+
+
+
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// ScriptStruct AIModule.BlackboardKeySelector
+// 0x0020
+struct FBlackboardKeySelector
+{
+	TArray<class UBlackboardKeyType*>                  AllowedTypes;                                             // 0x0000(0x000C) (Edit, BlueprintVisible, ZeroConstructor, Transient)
+	unsigned char                                      UnknownData00[0x4];                                       // 0x000C(0x0004) MISSED OFFSET
+	struct FName                                       SelectedKeyName;                                          // 0x0010(0x0008) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnTemplate, IsPlainOldData)
+	class UClass*                                      SelectedKeyType;                                          // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnTemplate, Transient, IsPlainOldData)
+	unsigned char                                      SelectedKeyID;                                            // 0x001C(0x0001) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnTemplate, Transient, IsPlainOldData)
+	unsigned char                                      bNoneIsAllowedValue : 1;                                  // 0x001D(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      UnknownData01[0x2];                                       // 0x001E(0x0002) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.AIRequestID
+// 0x0004
+struct FAIRequestID
+{
+	uint32_t                                           RequestID;                                                // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AIModule.AIStimulus
+// 0x0048
+struct FAIStimulus
+{
+	float                                              Age;                                                      // 0x0000(0x0004) (BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              ExpirationAge;                                            // 0x0004(0x0004) (BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              Strength;                                                 // 0x0008(0x0004) (BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	struct FVector                                     StimulusLocation;                                         // 0x000C(0x000C) (BlueprintVisible, IsPlainOldData)
+	struct FVector                                     ReceiverLocation;                                         // 0x0018(0x000C) (BlueprintVisible, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x4];                                       // 0x0024(0x0004) MISSED OFFSET
+	struct FName                                       Tag;                                                      // 0x0028(0x0008) (BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData01[0x10];                                      // 0x0030(0x0010) MISSED OFFSET
+	unsigned char                                      UnknownData02 : 1;                                        // 0x0040(0x0001)
+	unsigned char                                      bSuccessfullySensed : 1;                                  // 0x0040(0x0001) (BlueprintVisible)
+	unsigned char                                      UnknownData03[0x7];                                       // 0x0041(0x0007) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.ActorPerceptionBlueprintInfo
+// 0x0014
+struct FActorPerceptionBlueprintInfo
+{
+	class AActor*                                      Target;                                                   // 0x0000(0x0004) (BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	TArray<struct FAIStimulus>                         LastSensedStimuli;                                        // 0x0004(0x000C) (BlueprintVisible, ZeroConstructor)
+	unsigned char                                      bIsHostile : 1;                                           // 0x0010(0x0001) (BlueprintVisible)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x0011(0x0003) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.AIDamageEvent
+// 0x0024
+struct FAIDamageEvent
+{
+	float                                              Amount;                                                   // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	struct FVector                                     Location;                                                 // 0x0004(0x000C) (Edit, BlueprintVisible, IsPlainOldData)
+	struct FVector                                     HitLocation;                                              // 0x0010(0x000C) (Edit, BlueprintVisible, IsPlainOldData)
+	class AActor*                                      DamagedActor;                                             // 0x001C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	class AActor*                                      Instigator;                                               // 0x0020(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AIModule.AINoiseEvent
+// 0x0030
+struct FAINoiseEvent
+{
+	unsigned char                                      UnknownData00[0x4];                                       // 0x0000(0x0004) MISSED OFFSET
+	struct FVector                                     NoiseLocation;                                            // 0x0004(0x000C) (Edit, BlueprintVisible, IsPlainOldData)
+	float                                              Loudness;                                                 // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              MaxRange;                                                 // 0x0014(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	class AActor*                                      Instigator;                                               // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData01[0x4];                                       // 0x001C(0x0004) MISSED OFFSET
+	struct FName                                       Tag;                                                      // 0x0020(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData02[0x8];                                       // 0x0028(0x0008) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.AIPredictionEvent
+// 0x000C
+struct FAIPredictionEvent
+{
+	class AActor*                                      Requestor;                                                // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData)
+	class AActor*                                      PredictedActor;                                           // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x4];                                       // 0x0008(0x0004) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.AITeamStimulusEvent
+// 0x0030
+struct FAITeamStimulusEvent
+{
+	unsigned char                                      UnknownData00[0x28];                                      // 0x0000(0x0028) MISSED OFFSET
+	class AActor*                                      Broadcaster;                                              // 0x0028(0x0004) (ZeroConstructor, IsPlainOldData)
+	class AActor*                                      Enemy;                                                    // 0x002C(0x0004) (ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AIModule.AITouchEvent
+// 0x0014
+struct FAITouchEvent
+{
+	unsigned char                                      UnknownData00[0xC];                                       // 0x0000(0x000C) MISSED OFFSET
+	class AActor*                                      TouchReceiver;                                            // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData)
+	class AActor*                                      OtherActor;                                               // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AIModule.AISenseAffiliationFilter
+// 0x0004
+struct FAISenseAffiliationFilter
+{
+	unsigned char                                      bDetectEnemies : 1;                                       // 0x0000(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly)
+	unsigned char                                      bDetectNeutrals : 1;                                      // 0x0000(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly)
+	unsigned char                                      bDetectFriendlies : 1;                                    // 0x0000(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x0001(0x0003) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.AIMoveRequest
+// 0x0028
+struct FAIMoveRequest
+{
+	class AActor*                                      GoalActor;                                                // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x24];                                      // 0x0004(0x0024) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.BTDecoratorLogic
+// 0x0004
+struct FBTDecoratorLogic
+{
+	TEnumAsByte<EBTDecoratorLogic>                     Operation;                                                // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x1];                                       // 0x0001(0x0001) MISSED OFFSET
+	uint16_t                                           Number;                                                   // 0x0002(0x0002) (ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AIModule.BehaviorTreeTemplateInfo
+// 0x000C
+struct FBehaviorTreeTemplateInfo
+{
+	class UBehaviorTree*                               Asset;                                                    // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData)
+	class UBTCompositeNode*                            Template;                                                 // 0x0004(0x0004) (ZeroConstructor, Transient, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x4];                                       // 0x0008(0x0004) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.BlackboardEntry
+// 0x0010
+struct FBlackboardEntry
+{
+	struct FName                                       EntryName;                                                // 0x0000(0x0008) (Edit, ZeroConstructor, IsPlainOldData)
+	class UBlackboardKeyType*                          KeyType;                                                  // 0x0008(0x0004) (Edit, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData)
+	unsigned char                                      bInstanceSynced : 1;                                      // 0x000C(0x0001) (Edit)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x000D(0x0003) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.BTCompositeChild
+// 0x0020
+struct FBTCompositeChild
+{
+	class UBTCompositeNode*                            ChildComposite;                                           // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData)
+	class UBTTaskNode*                                 ChildTask;                                                // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData)
+	TArray<class UBTDecorator*>                        Decorators;                                               // 0x0008(0x000C) (ZeroConstructor)
+	TArray<struct FBTDecoratorLogic>                   DecoratorOps;                                             // 0x0014(0x000C) (ZeroConstructor)
+};
+
+// ScriptStruct AIModule.AIDataProviderValue
+// 0x0018
+struct FAIDataProviderValue
+{
+	unsigned char                                      UnknownData00[0x4];                                       // 0x0000(0x0004) MISSED OFFSET
+	class UProperty*                                   CachedProperty;                                           // 0x0004(0x0004) (ZeroConstructor, Transient, IsPlainOldData)
+	class UAIDataProvider*                             DataBinding;                                              // 0x0008(0x0004) (Edit, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData)
+	unsigned char                                      UnknownData01[0x4];                                       // 0x000C(0x0004) MISSED OFFSET
+	struct FName                                       DataField;                                                // 0x0010(0x0008) (Edit, ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AIModule.AIDataProviderTypedValue
+// 0x0008 (0x0020 - 0x0018)
+struct FAIDataProviderTypedValue : public FAIDataProviderValue
+{
+	class UClass*                                      PropertyType;                                             // 0x0018(0x0004) (ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x4];                                       // 0x001C(0x0004) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.AIDataProviderFloatValue
+// 0x0000 (0x0020 - 0x0020)
+struct FAIDataProviderFloatValue : public FAIDataProviderTypedValue
+{
+	float                                              DefaultValue;                                             // 0x001C(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AIModule.AIDynamicParam
+// 0x0030
+struct FAIDynamicParam
+{
+	struct FName                                       ParamName;                                                // 0x0000(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData)
+	EAIParamType                                       ParamType;                                                // 0x0008(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x0009(0x0003) MISSED OFFSET
+	float                                              Value;                                                    // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	struct FBlackboardKeySelector                      BBKey;                                                    // 0x0010(0x0020) (Edit, BlueprintVisible)
+};
+
+// ScriptStruct AIModule.EQSParametrizedQueryExecutionRequest
+// 0x0038
+struct FEQSParametrizedQueryExecutionRequest
+{
+	class UEnvQuery*                                   QueryTemplate;                                            // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	TArray<struct FAIDynamicParam>                     QueryConfig;                                              // 0x0004(0x000C) (Edit, ZeroConstructor)
+	struct FBlackboardKeySelector                      EQSQueryBlackboardKey;                                    // 0x0010(0x0020) (Edit)
+	TEnumAsByte<EEnvQueryRunMode>                      RunMode;                                                  // 0x0030(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      bUseBBKeyForQueryTemplate : 1;                            // 0x0031(0x0001) (Edit)
+	unsigned char                                      UnknownData00[0x6];                                       // 0x0032(0x0006) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.EnvNamedValue
+// 0x0010
+struct FEnvNamedValue
+{
+	struct FName                                       ParamName;                                                // 0x0000(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	EAIParamType                                       ParamType;                                                // 0x0008(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x0009(0x0003) MISSED OFFSET
+	float                                              Value;                                                    // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AIModule.CrowdAvoidanceConfig
+// 0x001C
+struct FCrowdAvoidanceConfig
+{
+	float                                              VelocityBias;                                             // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	float                                              DesiredVelocityWeight;                                    // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	float                                              CurrentVelocityWeight;                                    // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	float                                              SideBiasWeight;                                           // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	float                                              ImpactTimeWeight;                                         // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	float                                              ImpactTimeRange;                                          // 0x0014(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      CustomPatternIdx;                                         // 0x0018(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      AdaptiveDivisions;                                        // 0x0019(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      AdaptiveRings;                                            // 0x001A(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      AdaptiveDepth;                                            // 0x001B(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AIModule.CrowdAvoidanceSamplingPattern
+// 0x0018
+struct FCrowdAvoidanceSamplingPattern
+{
+	TArray<float>                                      Angles;                                                   // 0x0000(0x000C) (Edit, ZeroConstructor)
+	TArray<float>                                      Radii;                                                    // 0x000C(0x000C) (Edit, ZeroConstructor)
+};
+
+// ScriptStruct AIModule.AIDataProviderBoolValue
+// 0x0000 (0x0020 - 0x0020)
+struct FAIDataProviderBoolValue : public FAIDataProviderTypedValue
+{
+	bool                                               DefaultValue;                                             // 0x001C(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x001D(0x0003) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.EnvTraceData
+// 0x0028
+struct FEnvTraceData
+{
+	int                                                VersionNum;                                               // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData)
+	class UClass*                                      NavigationFilter;                                         // 0x0004(0x0004) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	float                                              ProjectDown;                                              // 0x0008(0x0004) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	float                                              ProjectUp;                                                // 0x000C(0x0004) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	float                                              ExtentX;                                                  // 0x0010(0x0004) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	float                                              ExtentY;                                                  // 0x0014(0x0004) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	float                                              ExtentZ;                                                  // 0x0018(0x0004) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	float                                              PostProjectionVerticalOffset;                             // 0x001C(0x0004) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	TEnumAsByte<ETraceTypeQuery>                       TraceChannel;                                             // 0x0020(0x0001) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	TEnumAsByte<ECollisionChannel>                     SerializedChannel;                                        // 0x0021(0x0001) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	TEnumAsByte<EEnvTraceShape>                        TraceShape;                                               // 0x0022(0x0001) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	TEnumAsByte<EEnvQueryTrace>                        TraceMode;                                                // 0x0023(0x0001) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	unsigned char                                      bTraceComplex : 1;                                        // 0x0024(0x0001) (Edit, DisableEditOnInstance)
+	unsigned char                                      bOnlyBlockingHits : 1;                                    // 0x0024(0x0001) (Edit, DisableEditOnInstance)
+	unsigned char                                      bCanTraceOnNavMesh : 1;                                   // 0x0024(0x0001) (Edit, DisableEditOnInstance)
+	unsigned char                                      bCanTraceOnGeometry : 1;                                  // 0x0024(0x0001) (Edit, DisableEditOnInstance)
+	unsigned char                                      bCanDisableTrace : 1;                                     // 0x0024(0x0001) (Edit, DisableEditOnInstance)
+	unsigned char                                      bCanProjectDown : 1;                                      // 0x0024(0x0001) (Edit, DisableEditOnInstance)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x0025(0x0003) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.AIDataProviderIntValue
+// 0x0000 (0x0020 - 0x0020)
+struct FAIDataProviderIntValue : public FAIDataProviderTypedValue
+{
+	int                                                DefaultValue;                                             // 0x001C(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AIModule.EnvDirection
+// 0x0010
+struct FEnvDirection
+{
+	class UClass*                                      LineFrom;                                                 // 0x0000(0x0004) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	class UClass*                                      LineTo;                                                   // 0x0004(0x0004) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	class UClass*                                      Rotation;                                                 // 0x0008(0x0004) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	TEnumAsByte<EEnvDirection>                         DirMode;                                                  // 0x000C(0x0001) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x000D(0x0003) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.EnvQueryInstanceCache
+// 0x0170
+struct FEnvQueryInstanceCache
+{
+	class UEnvQuery*                                   Template;                                                 // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x16C];                                     // 0x0004(0x016C) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.EnvOverlapData
+// 0x001C
+struct FEnvOverlapData
+{
+	float                                              ExtentX;                                                  // 0x0000(0x0004) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	float                                              ExtentY;                                                  // 0x0004(0x0004) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	float                                              ExtentZ;                                                  // 0x0008(0x0004) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	struct FVector                                     ShapeOffset;                                              // 0x000C(0x000C) (Edit, DisableEditOnInstance, IsPlainOldData)
+	TEnumAsByte<ECollisionChannel>                     OverlapChannel;                                           // 0x0018(0x0001) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	TEnumAsByte<EEnvOverlapShape>                      OverlapShape;                                             // 0x0019(0x0001) (Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	unsigned char                                      bOnlyBlockingHits : 1;                                    // 0x001A(0x0001) (Edit, DisableEditOnInstance)
+	unsigned char                                      bOverlapComplex : 1;                                      // 0x001A(0x0001) (Edit, DisableEditOnInstance)
+	unsigned char                                      UnknownData00[0x1];                                       // 0x001B(0x0001) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.PawnActionStack
+// 0x0004
+struct FPawnActionStack
+{
+	class UPawnAction*                                 TopAction;                                                // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AIModule.PawnActionEvent
+// 0x0010
+struct FPawnActionEvent
+{
+	class UPawnAction*                                 Action;                                                   // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0xC];                                       // 0x0004(0x000C) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.AIDataProviderStructValue
+// 0x0010 (0x0028 - 0x0018)
+struct FAIDataProviderStructValue : public FAIDataProviderValue
+{
+	unsigned char                                      UnknownData00[0x10];                                      // 0x0018(0x0010) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.AISightEvent
+// 0x0010
+struct FAISightEvent
+{
+	unsigned char                                      UnknownData00[0x8];                                       // 0x0000(0x0008) MISSED OFFSET
+	class AActor*                                      SeenActor;                                                // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData)
+	class AActor*                                      Observer;                                                 // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AIModule.EnvQueryRequest
+// 0x0048
+struct FEnvQueryRequest
+{
+	class UEnvQuery*                                   QueryTemplate;                                            // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData)
+	class UObject*                                     Owner;                                                    // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData)
+	class UWorld*                                      World;                                                    // 0x0008(0x0004) (ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x3C];                                      // 0x000C(0x003C) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.EnvQueryResult
+// 0x0030
+struct FEnvQueryResult
+{
+	unsigned char                                      UnknownData00[0xC];                                       // 0x0000(0x000C) MISSED OFFSET
+	class UClass*                                      ItemType;                                                 // 0x000C(0x0004) (BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData01[0x10];                                      // 0x0010(0x0010) MISSED OFFSET
+	int                                                OptionIndex;                                              // 0x0020(0x0004) (BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData)
+	int                                                QueryID;                                                  // 0x0024(0x0004) (BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData02[0x8];                                       // 0x0028(0x0008) MISSED OFFSET
+};
+
+// ScriptStruct AIModule.GenericTeamId
+// 0x0001
+struct FGenericTeamId
+{
+	unsigned char                                      TeamID;                                                   // 0x0000(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+};
+
+}
+

结构体/数据/SDK/PUBGM_ActorSequence_classes.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Classes
+//---------------------------------------------------------------------------
+
+// Class ActorSequence.ActorSequence
+// 0x0020 (0x02A0 - 0x0280)
+class UActorSequence : public UMovieSceneSequence
+{
+public:
+	unsigned char                                      UnknownData00[0x20];                                      // 0x0280(0x0020) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class ActorSequence.ActorSequence");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class ActorSequence.ActorSequenceComponent
+// 0x0028 (0x00E8 - 0x00C0)
+class UActorSequenceComponent : public UActorComponent
+{
+public:
+	unsigned char                                      UnknownData00[0x1C];                                      // 0x00C0(0x001C) MISSED OFFSET
+	class UActorSequence*                              Sequence;                                                 // 0x00DC(0x0004) (Edit, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData)
+	class UActorSequencePlayer*                        SequencePlayer;                                           // 0x00E0(0x0004) (BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, IsPlainOldData)
+	bool                                               bAutoPlay;                                                // 0x00E4(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData01[0x3];                                       // 0x00E5(0x0003) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class ActorSequence.ActorSequenceComponent");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class ActorSequence.ActorSequencePlayer
+// 0x0000 (0x06A0 - 0x06A0)
+class UActorSequencePlayer : public UMovieSceneSequencePlayer
+{
+public:
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class ActorSequence.ActorSequencePlayer");
+		return pStaticClass;
+	}
+
+};
+
+
+}
+

结构体/数据/SDK/PUBGM_ActorSequence_functions.cpp

@@ -0,0 +1,15 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_ActorSequence_parameters.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_ActorSequence_structs.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Enums
+//---------------------------------------------------------------------------
+
+// Enum ActorSequence.EActorSequenceObjectReferenceType
+enum class EActorSequenceObjectReferenceType : uint8_t
+{
+	EActorSequenceObjectReferenceType__ContextActor = 0,
+	EActorSequenceObjectReferenceType__ExternalActor = 1,
+	EActorSequenceObjectReferenceType__Component = 2,
+	EActorSequenceObjectReferenceType__EActorSequenceObjectReferenceType_MAX = 3
+};
+
+
+
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// ScriptStruct ActorSequence.ActorSequenceObjectReference
+// 0x0020
+struct FActorSequenceObjectReference
+{
+	EActorSequenceObjectReferenceType                  Type;                                                     // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x0001(0x0003) MISSED OFFSET
+	struct FGuid                                       ActorId;                                                  // 0x0004(0x0010) (IsPlainOldData)
+	struct FString                                     PathToComponent;                                          // 0x0014(0x000C) (ZeroConstructor)
+};
+
+// ScriptStruct ActorSequence.ActorSequenceObjectReferences
+// 0x000C
+struct FActorSequenceObjectReferences
+{
+	TArray<struct FActorSequenceObjectReference>       Array;                                                    // 0x0000(0x000C) (ZeroConstructor)
+};
+
+// ScriptStruct ActorSequence.ActorSequenceObjectReferenceMap
+// 0x0018
+struct FActorSequenceObjectReferenceMap
+{
+	TArray<struct FGuid>                               BindingIds;                                               // 0x0000(0x000C) (ZeroConstructor)
+	TArray<struct FActorSequenceObjectReferences>      References;                                               // 0x000C(0x000C) (ZeroConstructor)
+};
+
+}
+

结构体/数据/SDK/PUBGM_AkAudio_classes.hpp

@@ -0,0 +1,589 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Classes
+//---------------------------------------------------------------------------
+
+// Class AkAudio.AkAcousticPortal
+// 0x0010 (0x02F0 - 0x02E0)
+class AAkAcousticPortal : public AVolume
+{
+public:
+	float                                              Gain;                                                     // 0x02E0(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	EAkAcousticPortalState                             InitialState;                                             // 0x02E4(0x0001) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0xB];                                       // 0x02E5(0x000B) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.AkAcousticPortal");
+		return pStaticClass;
+	}
+
+
+	void OpenPortal();
+	EAkAcousticPortalState GetCurrentState();
+	void ClosePortal();
+};
+
+
+// Class AkAudio.AkAcousticTexture
+// 0x0004 (0x0020 - 0x001C)
+class UAkAcousticTexture : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0x4];                                       // 0x001C(0x0004) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.AkAcousticTexture");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.AkAmbientSound
+// 0x0010 (0x02C8 - 0x02B8)
+class AAkAmbientSound : public AActor
+{
+public:
+	class UAkAudioEvent*                               AkAudioEvent;                                             // 0x02B8(0x0004) (ZeroConstructor, Deprecated, IsPlainOldData)
+	class UAkComponent*                                AkComponent;                                              // 0x02BC(0x0004) (Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, IsPlainOldData)
+	bool                                               StopWhenOwnerIsDestroyed;                                 // 0x02C0(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	bool                                               AutoPost;                                                 // 0x02C1(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x6];                                       // 0x02C2(0x0006) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.AkAmbientSound");
+		return pStaticClass;
+	}
+
+
+	void StopAmbientSound();
+	void StartAmbientSound();
+};
+
+
+// Class AkAudio.AkAudioBank
+// 0x0004 (0x0020 - 0x001C)
+class UAkAudioBank : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0x4];                                       // 0x001C(0x0004) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.AkAudioBank");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.AkAudioEvent
+// 0x0014 (0x0030 - 0x001C)
+class UAkAudioEvent : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0x4];                                       // 0x001C(0x0004) MISSED OFFSET
+	float                                              MaxAttenuationRadius;                                     // 0x0020(0x0004) (BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData)
+	bool                                               IsInfinite;                                               // 0x0024(0x0001) (BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData01[0x3];                                       // 0x0025(0x0003) MISSED OFFSET
+	float                                              MinimumDuration;                                          // 0x0028(0x0004) (BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData)
+	float                                              MaximumDuration;                                          // 0x002C(0x0004) (BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData)
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.AkAudioEvent");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.AkAuxBus
+// 0x000C (0x0028 - 0x001C)
+class UAkAuxBus : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0xC];                                       // 0x001C(0x000C) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.AkAuxBus");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.AkComponent
+// 0x0200 (0x04C0 - 0x02C0)
+class UAkComponent : public USceneComponent
+{
+public:
+	class UAkAuxBus*                                   EarlyReflectionAuxBus;                                    // 0x02C0(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	struct FString                                     EarlyReflectionAuxBusName;                                // 0x02C4(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	int                                                EarlyReflectionOrder;                                     // 0x02D0(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData)
+	float                                              EarlyReflectionBusSendGain;                               // 0x02D4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              EarlyReflectionMaxPathLength;                             // 0x02D8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x4];                                       // 0x02DC(0x0004) MISSED OFFSET
+	unsigned char                                      EnableSpotReflectors : 1;                                 // 0x02E0(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      DrawFirstOrderReflections : 1;                            // 0x02E0(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      DrawSecondOrderReflections : 1;                           // 0x02E0(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      DrawHigherOrderReflections : 1;                           // 0x02E0(0x0001) (Edit, BlueprintVisible)
+	bool                                               StopWhenOwnerDestroyed;                                   // 0x02E1(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      bIsUpdateEmmiterTransform : 1;                            // 0x02E2(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      UnknownData01[0x1];                                       // 0x02E3(0x0001) MISSED OFFSET
+	float                                              AttenuationScalingFactor;                                 // 0x02E4(0x0004) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData)
+	float                                              OcclusionRefreshInterval;                                 // 0x02E8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	class UAkAudioEvent*                               AkAudioEvent;                                             // 0x02EC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	struct FString                                     EventName;                                                // 0x02F0(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	unsigned char                                      UnknownData02[0x1C4];                                     // 0x02FC(0x01C4) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.AkComponent");
+		return pStaticClass;
+	}
+
+
+	void UseReverbVolumes(bool inUseReverbVolumes);
+	void UseEarlyReflections(class UAkAuxBus* AuxBus, bool Left, bool Right, bool Floor, bool Ceiling, bool Back, bool Front, bool SpotReflectors, const struct FString& AuxBusName);
+	void Stop();
+	void SetSwitch(const struct FString& SwitchGroup, const struct FString& SwitchState);
+	void SetStopWhenOwnerDestroyed(bool bStopWhenOwnerDestroyed);
+	void SetRTPCValueGlobally(const struct FString& RTPC, float Value);
+	void SetRTPCValue(const struct FString& RTPC, float Value, int InterpolationTimeMs);
+	void SetOutputBusVolume(float BusVolume);
+	void SetListeners(TArray<class UAkComponent*> Listeners);
+	void SetEarlyReflectionOrder(int NewEarlyReflectionOrder);
+	void SetAutoDestroy(bool in_AutoDestroy);
+	void SetAttenuationScalingFactor(float Value);
+	void PostTrigger(const struct FString& Trigger);
+	int PostAssociatedAkEvent();
+	int PostAkEventByName(const struct FString& in_EventName);
+	int PostAkEvent(class UAkAudioEvent* AkEvent, const struct FString& in_EventName);
+	float GetAttenuationRadius();
+};
+
+
+// Class AkAudio.AkGameplayStatics
+// 0x0000 (0x0020 - 0x0020)
+class UAkGameplayStatics : public UBlueprintFunctionLibrary
+{
+public:
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.AkGameplayStatics");
+		return pStaticClass;
+	}
+
+
+	static void WakeupFromSuspend();
+	static void UseReverbVolumes(bool inUseReverbVolumes, class AActor* Actor);
+	static void UseEarlyReflections(class AActor* Actor, class UAkAuxBus* AuxBus, bool Left, bool Right, bool Floor, bool Ceiling, bool Back, bool Front, bool SpotReflectors, const struct FString& AuxBusName);
+	static void UnloadBankByName(const struct FString& BankName);
+	static void UnloadBank(class UAkAudioBank* Bank, const struct FString& BankName);
+	static void Suspend();
+	static void StopProfilerCapture();
+	static void StopOutputCapture();
+	static void StopAllAmbientSounds(class UObject* WorldContextObject);
+	static void StopAll();
+	static void StopActor(class AActor* Actor);
+	static void StartProfilerCapture(const struct FString& Filename);
+	static void StartOutputCapture(const struct FString& Filename);
+	static void StartAllAmbientSounds(class UObject* WorldContextObject);
+	static class UAkComponent* SpawnAkComponentAtLocation(class UObject* WorldContextObject, class UAkAudioEvent* AkEvent, class UAkAuxBus* EarlyReflectionsBus, const struct FVector& Location, const struct FRotator& Orientation, bool AutoPost, const struct FString& EventName, const struct FString& EarlyReflectionsBusName, bool AutoDestroy);
+	static void ShowAKComponentPosition(bool _IsShow);
+	static void SetSwitch(const struct FName& SwitchGroup, const struct FName& SwitchState, class AActor* Actor);
+	static void SetState(const struct FName& StateGroup, const struct FName& State);
+	static void SetRTPCValue(const struct FName& RTPC, float Value, int InterpolationTimeMs, class AActor* Actor);
+	static void SetPanningRule(EPanningRule PanRule);
+	static void SetOutputBusVolume(float BusVolume, class AActor* Actor);
+	static void SetOcclusionScalingFactor(float ScalingFactor);
+	static void SetOcclusionRefreshInterval(float RefreshInterval, class AActor* Actor);
+	static void SetBusConfig(const struct FString& BusName, EAkChannelConfiguration ChannelConfiguration);
+	static void PostTrigger(const struct FName& Trigger, class AActor* Actor);
+	static void PostEventByName(const struct FString& EventName, class AActor* Actor, bool bStopWhenAttachedToDestroyed);
+	static int PostEventAttached(class UAkAudioEvent* AkEvent, class AActor* Actor, const struct FName& AttachPointName, bool bStopWhenAttachedToDestroyed, const struct FString& EventName);
+	static void PostEventAtLocationByName(const struct FString& EventName, const struct FVector& Location, const struct FRotator& Orientation, class UObject* WorldContextObject);
+	static int PostEventAtLocation(class UAkAudioEvent* AkEvent, const struct FVector& Location, const struct FRotator& Orientation, const struct FString& EventName, class UObject* WorldContextObject);
+	static int PostEvent(class UAkAudioEvent* AkEvent, class AActor* Actor, bool bStopWhenAttachedToDestroyed, const struct FString& EventName);
+	static void LoadInitBank();
+	static void LoadBanks(TArray<class UAkAudioBank*> SoundBanks, bool SynchronizeSoundBanks);
+	static void LoadBankByName(const struct FString& BankName);
+	static void LoadBank(class UAkAudioBank* Bank, const struct FString& BankName);
+	static bool IsGame(class UObject* WorldContextObject);
+	static bool IsEditor();
+	static float GetOcclusionScalingFactor();
+	static class UAkComponent* GetAkComponent(class USceneComponent* AttachToComponent, const struct FName& AttachPointName, const struct FVector& Location, TEnumAsByte<EAttachLocation> LocationType);
+	static void ClearBanks();
+	static void AKSetRTPCValue(const struct FString& RTPC, float Value, bool in_bBypassInternalValueInterpolation);
+	static void AddOutputCaptureMarker(const struct FString& MarkerText);
+};
+
+
+// Class AkAudio.AkLateReverbComponent
+// 0x0030 (0x02F0 - 0x02C0)
+class UAkLateReverbComponent : public USceneComponent
+{
+public:
+	unsigned char                                      bEnable : 1;                                              // 0x02C0(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x02C1(0x0003) MISSED OFFSET
+	class UAkAuxBus*                                   AuxBus;                                                   // 0x02C4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	struct FString                                     AuxBusName;                                               // 0x02C8(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	float                                              SendLevel;                                                // 0x02D4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              FadeRate;                                                 // 0x02D8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              Priority;                                                 // 0x02DC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData01[0x10];                                      // 0x02E0(0x0010) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.AkLateReverbComponent");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.AkReverbVolume
+// 0x0028 (0x0308 - 0x02E0)
+class AAkReverbVolume : public AVolume
+{
+public:
+	unsigned char                                      bEnabled : 1;                                             // 0x02E0(0x0001) (Deprecated)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x02E1(0x0003) MISSED OFFSET
+	class UAkAuxBus*                                   AuxBus;                                                   // 0x02E4(0x0004) (ZeroConstructor, Deprecated, IsPlainOldData)
+	struct FString                                     AuxBusName;                                               // 0x02E8(0x000C) (ZeroConstructor, Deprecated)
+	float                                              SendLevel;                                                // 0x02F4(0x0004) (ZeroConstructor, Deprecated, IsPlainOldData)
+	float                                              FadeRate;                                                 // 0x02F8(0x0004) (ZeroConstructor, Deprecated, IsPlainOldData)
+	float                                              Priority;                                                 // 0x02FC(0x0004) (ZeroConstructor, Deprecated, IsPlainOldData)
+	class UAkLateReverbComponent*                      LateReverbComponent;                                      // 0x0300(0x0004) (Edit, BlueprintVisible, ExportObject, ZeroConstructor, EditConst, InstancedReference, IsPlainOldData)
+	unsigned char                                      UnknownData01[0x4];                                       // 0x0304(0x0004) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.AkReverbVolume");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.AkRoomComponent
+// 0x0010 (0x02D0 - 0x02C0)
+class UAkRoomComponent : public USceneComponent
+{
+public:
+	unsigned char                                      bEnable : 1;                                              // 0x02C0(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      UnknownData00[0x7];                                       // 0x02C1(0x0007) MISSED OFFSET
+	float                                              Priority;                                                 // 0x02C8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData01[0x4];                                       // 0x02CC(0x0004) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.AkRoomComponent");
+		return pStaticClass;
+	}
+
+
+	void RemoveSpatialAudioRoom();
+	void AddSpatialAudioRoom();
+};
+
+
+// Class AkAudio.AkSettings
+// 0x0054 (0x0070 - 0x001C)
+class UAkSettings : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0x4];                                       // 0x001C(0x0004) MISSED OFFSET
+	struct FFilePath                                   WwiseProjectPath;                                         // 0x0020(0x000C) (Edit, Config)
+	struct FDirectoryPath                              WwiseWindowsInstallationPath;                             // 0x002C(0x000C) (Edit, Config)
+	struct FFilePath                                   WwiseMacInstallationPath;                                 // 0x0038(0x000C) (Edit, Config)
+	bool                                               SuppressWwiseProjectPathWarnings;                         // 0x0044(0x0001) (ZeroConstructor, Config, IsPlainOldData)
+	bool                                               UseAlternateObstructionOcclusionFeature;                  // 0x0045(0x0001) (Edit, ZeroConstructor, Config, IsPlainOldData)
+	unsigned char                                      UnknownData01[0x2A];                                      // 0x0046(0x002A) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.AkSettings");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.AkSpatialAudioVolume
+// 0x0010 (0x02F0 - 0x02E0)
+class AAkSpatialAudioVolume : public AVolume
+{
+public:
+	class UAkSurfaceReflectorSetComponent*             SurfaceReflectorSet;                                      // 0x02E0(0x0004) (Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, IsPlainOldData)
+	class UAkLateReverbComponent*                      LateReverb;                                               // 0x02E4(0x0004) (Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, IsPlainOldData)
+	class UAkRoomComponent*                            room;                                                     // 0x02E8(0x0004) (Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x4];                                       // 0x02EC(0x0004) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.AkSpatialAudioVolume");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.AkSpotReflector
+// 0x0020 (0x02D8 - 0x02B8)
+class AAkSpotReflector : public AActor
+{
+public:
+	class UAkAuxBus*                                   AuxBus;                                                   // 0x02B8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	struct FString                                     AuxBusName;                                               // 0x02BC(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	class UAkAcousticTexture*                          AcousticTexture;                                          // 0x02C8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              DistanceScalingFactor;                                    // 0x02CC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              Level;                                                    // 0x02D0(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x4];                                       // 0x02D4(0x0004) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.AkSpotReflector");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.AkSurfaceReflectorSetComponent
+// 0x0020 (0x02E0 - 0x02C0)
+class UAkSurfaceReflectorSetComponent : public USceneComponent
+{
+public:
+	unsigned char                                      bEnableSurfaceReflectors : 1;                             // 0x02C0(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x02C1(0x0003) MISSED OFFSET
+	TArray<struct FAkPoly>                             AcousticPolys;                                            // 0x02C4(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	unsigned char                                      UnknownData01[0x10];                                      // 0x02D0(0x0010) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.AkSurfaceReflectorSetComponent");
+		return pStaticClass;
+	}
+
+
+	void UpdateSurfaceReflectorSet();
+	void SendSurfaceReflectorSet();
+	void RemoveSurfaceReflectorSet();
+};
+
+
+// Class AkAudio.InterpTrackAkAudioEvent
+// 0x0010 (0x0070 - 0x0060)
+class UInterpTrackAkAudioEvent : public UInterpTrackVectorBase
+{
+public:
+	TArray<struct FAkAudioEventTrackKey>               Events;                                                   // 0x0060(0x000C) (ZeroConstructor)
+	unsigned char                                      bContinueEventOnMatineeEnd : 1;                           // 0x006C(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x006D(0x0003) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.InterpTrackAkAudioEvent");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.InterpTrackAkAudioRTPC
+// 0x0010 (0x0070 - 0x0060)
+class UInterpTrackAkAudioRTPC : public UInterpTrackFloatBase
+{
+public:
+	struct FString                                     Param;                                                    // 0x0060(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	unsigned char                                      bPlayOnReverse : 1;                                       // 0x006C(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      bContinueRTPCOnMatineeEnd : 1;                            // 0x006C(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x006D(0x0003) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.InterpTrackAkAudioRTPC");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.InterpTrackInstAkAudioEvent
+// 0x0000 (0x0020 - 0x0020)
+class UInterpTrackInstAkAudioEvent : public UInterpTrackInst
+{
+public:
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.InterpTrackInstAkAudioEvent");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.InterpTrackInstAkAudioRTPC
+// 0x0000 (0x0020 - 0x0020)
+class UInterpTrackInstAkAudioRTPC : public UInterpTrackInst
+{
+public:
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.InterpTrackInstAkAudioRTPC");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.MovieSceneAkAudioEventSection
+// 0x0010 (0x0100 - 0x00F0)
+class UMovieSceneAkAudioEventSection : public UMovieSceneSection
+{
+public:
+	bool                                               StopAtSectionEnd;                                         // 0x00F0(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x00F1(0x0003) MISSED OFFSET
+	struct FString                                     EventName;                                                // 0x00F4(0x000C) (Edit, ZeroConstructor)
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.MovieSceneAkAudioEventSection");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.MovieSceneAkTrack
+// 0x0010 (0x00C0 - 0x00B0)
+class UMovieSceneAkTrack : public UMovieSceneTrack
+{
+public:
+	unsigned char                                      UnknownData00[0x4];                                       // 0x00B0(0x0004) MISSED OFFSET
+	unsigned char                                      bIsAMasterTrack : 1;                                      // 0x00B4(0x0001)
+	unsigned char                                      UnknownData01[0xB];                                       // 0x00B5(0x000B) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.MovieSceneAkTrack");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.MovieSceneAkAudioEventTrack
+// 0x0000 (0x00C0 - 0x00C0)
+class UMovieSceneAkAudioEventTrack : public UMovieSceneAkTrack
+{
+public:
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.MovieSceneAkAudioEventTrack");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.MovieSceneAkAudioRTPCSection
+// 0x0060 (0x0150 - 0x00F0)
+class UMovieSceneAkAudioRTPCSection : public UMovieSceneSection
+{
+public:
+	struct FString                                     Name;                                                     // 0x00F0(0x000C) (Edit, ZeroConstructor)
+	struct FRichCurve                                  FloatCurve;                                               // 0x00FC(0x0054)
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.MovieSceneAkAudioRTPCSection");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AkAudio.MovieSceneAkAudioRTPCTrack
+// 0x0000 (0x00C0 - 0x00C0)
+class UMovieSceneAkAudioRTPCTrack : public UMovieSceneAkTrack
+{
+public:
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AkAudio.MovieSceneAkAudioRTPCTrack");
+		return pStaticClass;
+	}
+
+};
+
+
+}
+

结构体/数据/SDK/PUBGM_AkAudio_parameters.hpp

@@ -0,0 +1,481 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+// Function AkAudio.AkAcousticPortal.OpenPortal
+struct AAkAcousticPortal_OpenPortal_Params
+{
+};
+
+// Function AkAudio.AkAcousticPortal.GetCurrentState
+struct AAkAcousticPortal_GetCurrentState_Params
+{
+	EAkAcousticPortalState                             ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AkAudio.AkAcousticPortal.ClosePortal
+struct AAkAcousticPortal_ClosePortal_Params
+{
+};
+
+// Function AkAudio.AkAmbientSound.StopAmbientSound
+struct AAkAmbientSound_StopAmbientSound_Params
+{
+};
+
+// Function AkAudio.AkAmbientSound.StartAmbientSound
+struct AAkAmbientSound_StartAmbientSound_Params
+{
+};
+
+// Function AkAudio.AkComponent.UseReverbVolumes
+struct UAkComponent_UseReverbVolumes_Params
+{
+	bool                                               inUseReverbVolumes;                                       // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkComponent.UseEarlyReflections
+struct UAkComponent_UseEarlyReflections_Params
+{
+	class UAkAuxBus*                                   AuxBus;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               Left;                                                     // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               Right;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               Floor;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               Ceiling;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               Back;                                                     // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               Front;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               SpotReflectors;                                           // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FString                                     AuxBusName;                                               // (Parm, ZeroConstructor)
+};
+
+// Function AkAudio.AkComponent.Stop
+struct UAkComponent_Stop_Params
+{
+};
+
+// Function AkAudio.AkComponent.SetSwitch
+struct UAkComponent_SetSwitch_Params
+{
+	struct FString                                     SwitchGroup;                                              // (Parm, ZeroConstructor)
+	struct FString                                     SwitchState;                                              // (Parm, ZeroConstructor)
+};
+
+// Function AkAudio.AkComponent.SetStopWhenOwnerDestroyed
+struct UAkComponent_SetStopWhenOwnerDestroyed_Params
+{
+	bool                                               bStopWhenOwnerDestroyed;                                  // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkComponent.SetRTPCValueGlobally
+struct UAkComponent_SetRTPCValueGlobally_Params
+{
+	struct FString                                     RTPC;                                                     // (Parm, ZeroConstructor)
+	float                                              Value;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkComponent.SetRTPCValue
+struct UAkComponent_SetRTPCValue_Params
+{
+	struct FString                                     RTPC;                                                     // (Parm, ZeroConstructor)
+	float                                              Value;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+	int                                                InterpolationTimeMs;                                      // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkComponent.SetOutputBusVolume
+struct UAkComponent_SetOutputBusVolume_Params
+{
+	float                                              BusVolume;                                                // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkComponent.SetListeners
+struct UAkComponent_SetListeners_Params
+{
+	TArray<class UAkComponent*>                        Listeners;                                                // (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
+};
+
+// Function AkAudio.AkComponent.SetEarlyReflectionOrder
+struct UAkComponent_SetEarlyReflectionOrder_Params
+{
+	int                                                NewEarlyReflectionOrder;                                  // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkComponent.SetAutoDestroy
+struct UAkComponent_SetAutoDestroy_Params
+{
+	bool                                               in_AutoDestroy;                                           // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkComponent.SetAttenuationScalingFactor
+struct UAkComponent_SetAttenuationScalingFactor_Params
+{
+	float                                              Value;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkComponent.PostTrigger
+struct UAkComponent_PostTrigger_Params
+{
+	struct FString                                     Trigger;                                                  // (Parm, ZeroConstructor)
+};
+
+// Function AkAudio.AkComponent.PostAssociatedAkEvent
+struct UAkComponent_PostAssociatedAkEvent_Params
+{
+	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AkAudio.AkComponent.PostAkEventByName
+struct UAkComponent_PostAkEventByName_Params
+{
+	struct FString                                     in_EventName;                                             // (Parm, ZeroConstructor)
+	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AkAudio.AkComponent.PostAkEvent
+struct UAkComponent_PostAkEvent_Params
+{
+	class UAkAudioEvent*                               AkEvent;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FString                                     in_EventName;                                             // (Parm, ZeroConstructor)
+	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AkAudio.AkComponent.GetAttenuationRadius
+struct UAkComponent_GetAttenuationRadius_Params
+{
+	float                                              ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.WakeupFromSuspend
+struct UAkGameplayStatics_WakeupFromSuspend_Params
+{
+};
+
+// Function AkAudio.AkGameplayStatics.UseReverbVolumes
+struct UAkGameplayStatics_UseReverbVolumes_Params
+{
+	bool                                               inUseReverbVolumes;                                       // (Parm, ZeroConstructor, IsPlainOldData)
+	class AActor*                                      Actor;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.UseEarlyReflections
+struct UAkGameplayStatics_UseEarlyReflections_Params
+{
+	class AActor*                                      Actor;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+	class UAkAuxBus*                                   AuxBus;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               Left;                                                     // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               Right;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               Floor;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               Ceiling;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               Back;                                                     // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               Front;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               SpotReflectors;                                           // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FString                                     AuxBusName;                                               // (Parm, ZeroConstructor)
+};
+
+// Function AkAudio.AkGameplayStatics.UnloadBankByName
+struct UAkGameplayStatics_UnloadBankByName_Params
+{
+	struct FString                                     BankName;                                                 // (Parm, ZeroConstructor)
+};
+
+// Function AkAudio.AkGameplayStatics.UnloadBank
+struct UAkGameplayStatics_UnloadBank_Params
+{
+	class UAkAudioBank*                                Bank;                                                     // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FString                                     BankName;                                                 // (Parm, ZeroConstructor)
+};
+
+// Function AkAudio.AkGameplayStatics.Suspend
+struct UAkGameplayStatics_Suspend_Params
+{
+};
+
+// Function AkAudio.AkGameplayStatics.StopProfilerCapture
+struct UAkGameplayStatics_StopProfilerCapture_Params
+{
+};
+
+// Function AkAudio.AkGameplayStatics.StopOutputCapture
+struct UAkGameplayStatics_StopOutputCapture_Params
+{
+};
+
+// Function AkAudio.AkGameplayStatics.StopAllAmbientSounds
+struct UAkGameplayStatics_StopAllAmbientSounds_Params
+{
+	class UObject*                                     WorldContextObject;                                       // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.StopAll
+struct UAkGameplayStatics_StopAll_Params
+{
+};
+
+// Function AkAudio.AkGameplayStatics.StopActor
+struct UAkGameplayStatics_StopActor_Params
+{
+	class AActor*                                      Actor;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.StartProfilerCapture
+struct UAkGameplayStatics_StartProfilerCapture_Params
+{
+	struct FString                                     Filename;                                                 // (Parm, ZeroConstructor)
+};
+
+// Function AkAudio.AkGameplayStatics.StartOutputCapture
+struct UAkGameplayStatics_StartOutputCapture_Params
+{
+	struct FString                                     Filename;                                                 // (Parm, ZeroConstructor)
+};
+
+// Function AkAudio.AkGameplayStatics.StartAllAmbientSounds
+struct UAkGameplayStatics_StartAllAmbientSounds_Params
+{
+	class UObject*                                     WorldContextObject;                                       // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.SpawnAkComponentAtLocation
+struct UAkGameplayStatics_SpawnAkComponentAtLocation_Params
+{
+	class UObject*                                     WorldContextObject;                                       // (Parm, ZeroConstructor, IsPlainOldData)
+	class UAkAudioEvent*                               AkEvent;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
+	class UAkAuxBus*                                   EarlyReflectionsBus;                                      // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FVector                                     Location;                                                 // (Parm, IsPlainOldData)
+	struct FRotator                                    Orientation;                                              // (Parm, IsPlainOldData)
+	bool                                               AutoPost;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FString                                     EventName;                                                // (Parm, ZeroConstructor)
+	struct FString                                     EarlyReflectionsBusName;                                  // (Parm, ZeroConstructor)
+	bool                                               AutoDestroy;                                              // (Parm, ZeroConstructor, IsPlainOldData)
+	class UAkComponent*                                ReturnValue;                                              // (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.ShowAKComponentPosition
+struct UAkGameplayStatics_ShowAKComponentPosition_Params
+{
+	bool                                               _IsShow;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.SetSwitch
+struct UAkGameplayStatics_SetSwitch_Params
+{
+	struct FName                                       SwitchGroup;                                              // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FName                                       SwitchState;                                              // (Parm, ZeroConstructor, IsPlainOldData)
+	class AActor*                                      Actor;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.SetState
+struct UAkGameplayStatics_SetState_Params
+{
+	struct FName                                       StateGroup;                                               // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FName                                       State;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.SetRTPCValue
+struct UAkGameplayStatics_SetRTPCValue_Params
+{
+	struct FName                                       RTPC;                                                     // (Parm, ZeroConstructor, IsPlainOldData)
+	float                                              Value;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+	int                                                InterpolationTimeMs;                                      // (Parm, ZeroConstructor, IsPlainOldData)
+	class AActor*                                      Actor;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.SetPanningRule
+struct UAkGameplayStatics_SetPanningRule_Params
+{
+	EPanningRule                                       PanRule;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.SetOutputBusVolume
+struct UAkGameplayStatics_SetOutputBusVolume_Params
+{
+	float                                              BusVolume;                                                // (Parm, ZeroConstructor, IsPlainOldData)
+	class AActor*                                      Actor;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.SetOcclusionScalingFactor
+struct UAkGameplayStatics_SetOcclusionScalingFactor_Params
+{
+	float                                              ScalingFactor;                                            // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.SetOcclusionRefreshInterval
+struct UAkGameplayStatics_SetOcclusionRefreshInterval_Params
+{
+	float                                              RefreshInterval;                                          // (Parm, ZeroConstructor, IsPlainOldData)
+	class AActor*                                      Actor;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.SetBusConfig
+struct UAkGameplayStatics_SetBusConfig_Params
+{
+	struct FString                                     BusName;                                                  // (Parm, ZeroConstructor)
+	EAkChannelConfiguration                            ChannelConfiguration;                                     // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.PostTrigger
+struct UAkGameplayStatics_PostTrigger_Params
+{
+	struct FName                                       Trigger;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
+	class AActor*                                      Actor;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.PostEventByName
+struct UAkGameplayStatics_PostEventByName_Params
+{
+	struct FString                                     EventName;                                                // (Parm, ZeroConstructor)
+	class AActor*                                      Actor;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               bStopWhenAttachedToDestroyed;                             // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.PostEventAttached
+struct UAkGameplayStatics_PostEventAttached_Params
+{
+	class UAkAudioEvent*                               AkEvent;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
+	class AActor*                                      Actor;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FName                                       AttachPointName;                                          // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               bStopWhenAttachedToDestroyed;                             // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FString                                     EventName;                                                // (Parm, ZeroConstructor)
+	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.PostEventAtLocationByName
+struct UAkGameplayStatics_PostEventAtLocationByName_Params
+{
+	struct FString                                     EventName;                                                // (Parm, ZeroConstructor)
+	struct FVector                                     Location;                                                 // (Parm, IsPlainOldData)
+	struct FRotator                                    Orientation;                                              // (Parm, IsPlainOldData)
+	class UObject*                                     WorldContextObject;                                       // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.PostEventAtLocation
+struct UAkGameplayStatics_PostEventAtLocation_Params
+{
+	class UAkAudioEvent*                               AkEvent;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FVector                                     Location;                                                 // (Parm, IsPlainOldData)
+	struct FRotator                                    Orientation;                                              // (Parm, IsPlainOldData)
+	struct FString                                     EventName;                                                // (Parm, ZeroConstructor)
+	class UObject*                                     WorldContextObject;                                       // (Parm, ZeroConstructor, IsPlainOldData)
+	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.PostEvent
+struct UAkGameplayStatics_PostEvent_Params
+{
+	class UAkAudioEvent*                               AkEvent;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
+	class AActor*                                      Actor;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               bStopWhenAttachedToDestroyed;                             // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FString                                     EventName;                                                // (Parm, ZeroConstructor)
+	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.LoadInitBank
+struct UAkGameplayStatics_LoadInitBank_Params
+{
+};
+
+// Function AkAudio.AkGameplayStatics.LoadBanks
+struct UAkGameplayStatics_LoadBanks_Params
+{
+	TArray<class UAkAudioBank*>                        SoundBanks;                                               // (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
+	bool                                               SynchronizeSoundBanks;                                    // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.LoadBankByName
+struct UAkGameplayStatics_LoadBankByName_Params
+{
+	struct FString                                     BankName;                                                 // (Parm, ZeroConstructor)
+};
+
+// Function AkAudio.AkGameplayStatics.LoadBank
+struct UAkGameplayStatics_LoadBank_Params
+{
+	class UAkAudioBank*                                Bank;                                                     // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FString                                     BankName;                                                 // (Parm, ZeroConstructor)
+};
+
+// Function AkAudio.AkGameplayStatics.IsGame
+struct UAkGameplayStatics_IsGame_Params
+{
+	class UObject*                                     WorldContextObject;                                       // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.IsEditor
+struct UAkGameplayStatics_IsEditor_Params
+{
+	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.GetOcclusionScalingFactor
+struct UAkGameplayStatics_GetOcclusionScalingFactor_Params
+{
+	float                                              ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.GetAkComponent
+struct UAkGameplayStatics_GetAkComponent_Params
+{
+	class USceneComponent*                             AttachToComponent;                                        // (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
+	struct FName                                       AttachPointName;                                          // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FVector                                     Location;                                                 // (Parm, IsPlainOldData)
+	TEnumAsByte<EAttachLocation>                       LocationType;                                             // (Parm, ZeroConstructor, IsPlainOldData)
+	class UAkComponent*                                ReturnValue;                                              // (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.ClearBanks
+struct UAkGameplayStatics_ClearBanks_Params
+{
+};
+
+// Function AkAudio.AkGameplayStatics.AKSetRTPCValue
+struct UAkGameplayStatics_AKSetRTPCValue_Params
+{
+	struct FString                                     RTPC;                                                     // (Parm, ZeroConstructor)
+	float                                              Value;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               in_bBypassInternalValueInterpolation;                     // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AkAudio.AkGameplayStatics.AddOutputCaptureMarker
+struct UAkGameplayStatics_AddOutputCaptureMarker_Params
+{
+	struct FString                                     MarkerText;                                               // (Parm, ZeroConstructor)
+};
+
+// Function AkAudio.AkRoomComponent.RemoveSpatialAudioRoom
+struct UAkRoomComponent_RemoveSpatialAudioRoom_Params
+{
+};
+
+// Function AkAudio.AkRoomComponent.AddSpatialAudioRoom
+struct UAkRoomComponent_AddSpatialAudioRoom_Params
+{
+};
+
+// Function AkAudio.AkSurfaceReflectorSetComponent.UpdateSurfaceReflectorSet
+struct UAkSurfaceReflectorSetComponent_UpdateSurfaceReflectorSet_Params
+{
+};
+
+// Function AkAudio.AkSurfaceReflectorSetComponent.SendSurfaceReflectorSet
+struct UAkSurfaceReflectorSetComponent_SendSurfaceReflectorSet_Params
+{
+};
+
+// Function AkAudio.AkSurfaceReflectorSetComponent.RemoveSurfaceReflectorSet
+struct UAkSurfaceReflectorSetComponent_RemoveSurfaceReflectorSet_Params
+{
+};
+
+}
+

结构体/数据/SDK/PUBGM_AkAudio_structs.hpp

@@ -0,0 +1,119 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Enums
+//---------------------------------------------------------------------------
+
+// Enum AkAudio.AkAcousticPortalState
+enum class EAkAcousticPortalState : uint8_t
+{
+	AkAcousticPortalState__Closed  = 0,
+	AkAcousticPortalState__Open    = 1,
+	AkAcousticPortalState__AkAcousticPortalState_MAX = 2
+};
+
+
+// Enum AkAudio.EReflectionFilterBits
+enum class EReflectionFilterBits : uint8_t
+{
+	EReflectionFilterBits__Wall    = 0,
+	EReflectionFilterBits__Ceiling = 1,
+	EReflectionFilterBits__Floor   = 2,
+	EReflectionFilterBits__EReflectionFilterBits_MAX = 3
+};
+
+
+// Enum AkAudio.PanningRule
+enum class EPanningRule : uint8_t
+{
+	PanningRule__PanningRule_Speakers = 0,
+	PanningRule__PanningRule_Headphones = 1,
+	PanningRule__PanningRule_MAX   = 2
+};
+
+
+// Enum AkAudio.AkChannelConfiguration
+enum class EAkChannelConfiguration : uint8_t
+{
+	AkChannelConfiguration__Ak_Parent = 0,
+	AkChannelConfiguration__Ak_1   = 1,
+	AkChannelConfiguration__Ak_2   = 2,
+	AkChannelConfiguration__Ak_3   = 3,
+	AkChannelConfiguration__Ak_4   = 4,
+	AkChannelConfiguration__Ak_5   = 5,
+	AkChannelConfiguration__Ak_7   = 6,
+	AkChannelConfiguration__Ak_5_1 = 7,
+	AkChannelConfiguration__Ak_7_1 = 8,
+	AkChannelConfiguration__Ak_7_101 = 9,
+	AkChannelConfiguration__Ak_Auro_9 = 10,
+	AkChannelConfiguration__Ak_Auro_10 = 11,
+	AkChannelConfiguration__Ak_Auro_11 = 12,
+	AkChannelConfiguration__Ak_Auro_13 = 13,
+	AkChannelConfiguration__Ak_Ambisonics_1st_order = 14,
+	AkChannelConfiguration__Ak_Ambisonics_2nd_order = 15,
+	AkChannelConfiguration__Ak_Ambisonics_3rd_order = 16,
+	AkChannelConfiguration__Ak_MAX = 17
+};
+
+
+
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// ScriptStruct AkAudio.AkPoly
+// 0x0008
+struct FAkPoly
+{
+	class UAkAcousticTexture*                          Texture;                                                  // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	bool                                               EnableSurface;                                            // 0x0004(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x0005(0x0003) MISSED OFFSET
+};
+
+// ScriptStruct AkAudio.AkAudioEventTrackKey
+// 0x0014
+struct FAkAudioEventTrackKey
+{
+	float                                              Time;                                                     // 0x0000(0x0004) (ZeroConstructor, IsPlainOldData)
+	class UAkAudioEvent*                               AkAudioEvent;                                             // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, EditConst, IsPlainOldData)
+	struct FString                                     EventName;                                                // 0x0008(0x000C) (Edit, BlueprintVisible, ZeroConstructor, EditConst)
+};
+
+// ScriptStruct AkAudio.AkAmbSoundCheckpointRecord
+// 0x0001
+struct FAkAmbSoundCheckpointRecord
+{
+	bool                                               bCurrentlyPlaying;                                        // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AkAudio.MovieSceneAkAudioEventTemplate
+// 0x0004 (0x0010 - 0x000C)
+struct FMovieSceneAkAudioEventTemplate : public FMovieSceneEvalTemplate
+{
+	class UMovieSceneAkAudioEventSection*              Section;                                                  // 0x000C(0x0004) (ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData)
+};
+
+// ScriptStruct AkAudio.MovieSceneAkAudioRTPCTemplate
+// 0x0004 (0x0010 - 0x000C)
+struct FMovieSceneAkAudioRTPCTemplate : public FMovieSceneEvalTemplate
+{
+	class UMovieSceneAkAudioRTPCSection*               Section;                                                  // 0x000C(0x0004) (ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData)
+};
+
+// ScriptStruct AkAudio.MovieSceneAkAudioRTPCSectionData
+// 0x0060
+struct FMovieSceneAkAudioRTPCSectionData
+{
+	struct FString                                     RTPCName;                                                 // 0x0000(0x000C) (ZeroConstructor)
+	struct FRichCurve                                  RTPCCurve;                                                // 0x000C(0x0054)
+};
+
+}
+

结构体/数据/SDK/PUBGM_AndroidDeviceProfileSelector_classes.hpp

@@ -0,0 +1,107 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Classes
+//---------------------------------------------------------------------------
+
+// Class AndroidDeviceProfileSelector.AndroidCommonDeviceProfileGradeScore
+// 0x001C (0x0038 - 0x001C)
+class UAndroidCommonDeviceProfileGradeScore : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0x4];                                       // 0x001C(0x0004) MISSED OFFSET
+	TArray<struct FGradeScoreProfileName>              GradeScoreProfileName;                                    // 0x0020(0x000C) (Edit, ZeroConstructor, Config)
+	TArray<float>                                      GradeScoreTypePercentage;                                 // 0x002C(0x000C) (Edit, ZeroConstructor, Config)
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AndroidDeviceProfileSelector.AndroidCommonDeviceProfileGradeScore");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AndroidDeviceProfileSelector.AndroidCommonDeviceProfileMatchingRules
+// 0x000C (0x0028 - 0x001C)
+class UAndroidCommonDeviceProfileMatchingRules : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0xC];                                       // 0x001C(0x000C) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AndroidDeviceProfileSelector.AndroidCommonDeviceProfileMatchingRules");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AndroidDeviceProfileSelector.AndroidCommonDeviceProfileWhiteList
+// 0x000C (0x0028 - 0x001C)
+class UAndroidCommonDeviceProfileWhiteList : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0xC];                                       // 0x001C(0x000C) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AndroidDeviceProfileSelector.AndroidCommonDeviceProfileWhiteList");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AndroidDeviceProfileSelector.AndroidDeviceProfileMatchingRules
+// 0x000C (0x0028 - 0x001C)
+class UAndroidDeviceProfileMatchingRules : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0xC];                                       // 0x001C(0x000C) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AndroidDeviceProfileSelector.AndroidDeviceProfileMatchingRules");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AndroidDeviceProfileSelector.AndroidJavaSurfaceViewDevices
+// 0x000C (0x0028 - 0x001C)
+class UAndroidJavaSurfaceViewDevices : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0xC];                                       // 0x001C(0x000C) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AndroidDeviceProfileSelector.AndroidJavaSurfaceViewDevices");
+		return pStaticClass;
+	}
+
+};
+
+
+}
+

结构体/数据/SDK/PUBGM_AndroidDeviceProfileSelector_functions.cpp

@@ -0,0 +1,15 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_AndroidDeviceProfileSelector_parameters.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_AndroidDeviceProfileSelector_structs.hpp

@@ -0,0 +1,133 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Enums
+//---------------------------------------------------------------------------
+
+// Enum AndroidDeviceProfileSelector.ECompareType
+enum class ECompareType : uint8_t
+{
+	CMP_Equal                      = 0,
+	CMP_Less                       = 1,
+	CMP_LessEqual                  = 2,
+	CMP_Greater                    = 3,
+	CMP_GreaterEqual               = 4,
+	CMP_NotEqual                   = 5,
+	CMP_Regex                      = 6,
+	CMP_MAX                        = 7
+};
+
+
+// Enum AndroidDeviceProfileSelector.ESourceType
+enum class ESourceType : uint8_t
+{
+	SRC_PreviousRegexMatch         = 0,
+	SRC_GpuFamily                  = 1,
+	SRC_GlVersion                  = 2,
+	SRC_AndroidVersion             = 3,
+	SRC_DeviceMake                 = 4,
+	SRC_DeviceModel                = 5,
+	SRC_VulkanVersion              = 6,
+	SRC_UsingHoudini               = 7,
+	SRC_VulkanAvailable            = 8,
+	SRC_MemorySizeInGB             = 9,
+	SRC_CPUCoreNum                 = 10,
+	SRC_CPUMaxFreq                 = 11,
+	SRC_GLExtensions               = 12,
+	SRC_MAX                        = 13
+};
+
+
+// Enum AndroidDeviceProfileSelector.EGradeScoreType
+enum class EGradeScoreType : uint8_t
+{
+	GST_GPU                        = 0,
+	GST_Memory                     = 1,
+	GST_CPUCore                    = 2,
+	GST_CPUFreq                    = 3,
+	GST_MAX                        = 4
+};
+
+
+// Enum AndroidDeviceProfileSelector.EGradeType
+enum class EGradeType : uint8_t
+{
+	GAT_Grade01                    = 0,
+	GAT_Grade02                    = 1,
+	GAT_Grade03                    = 2,
+	GAT_Grade04                    = 3,
+	GAT_Grade05                    = 4,
+	GAT_Grade06                    = 5,
+	GAT_Grade07                    = 6,
+	GAT_MAX                        = 7
+};
+
+
+
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// ScriptStruct AndroidDeviceProfileSelector.GradeScoreProfileName
+// 0x0010
+struct FGradeScoreProfileName
+{
+	struct FString                                     ProfileName;                                              // 0x0000(0x000C) (ZeroConstructor)
+	int                                                Score;                                                    // 0x000C(0x0004) (ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AndroidDeviceProfileSelector.GradeProfileMatchItem
+// 0x0010
+struct FGradeProfileMatchItem
+{
+	TEnumAsByte<ESourceType>                           SourceType;                                               // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData)
+	TEnumAsByte<ECompareType>                          CompareType;                                              // 0x0001(0x0001) (ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x2];                                       // 0x0002(0x0002) MISSED OFFSET
+	struct FString                                     MatchString;                                              // 0x0004(0x000C) (ZeroConstructor)
+};
+
+// ScriptStruct AndroidDeviceProfileSelector.GradeProfileMatch
+// 0x0014
+struct FGradeProfileMatch
+{
+	TEnumAsByte<EGradeScoreType>                       ScoreType;                                                // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x0001(0x0003) MISSED OFFSET
+	int                                                Score;                                                    // 0x0004(0x0004) (ZeroConstructor, IsPlainOldData)
+	TArray<struct FGradeProfileMatchItem>              Match;                                                    // 0x0008(0x000C) (ZeroConstructor)
+};
+
+// ScriptStruct AndroidDeviceProfileSelector.ProfileMatchItem
+// 0x0010
+struct FProfileMatchItem
+{
+	TEnumAsByte<ESourceType>                           SourceType;                                               // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData)
+	TEnumAsByte<ECompareType>                          CompareType;                                              // 0x0001(0x0001) (ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x2];                                       // 0x0002(0x0002) MISSED OFFSET
+	struct FString                                     MatchString;                                              // 0x0004(0x000C) (ZeroConstructor)
+};
+
+// ScriptStruct AndroidDeviceProfileSelector.ProfileMatch
+// 0x0018
+struct FProfileMatch
+{
+	struct FString                                     Profile;                                                  // 0x0000(0x000C) (ZeroConstructor)
+	TArray<struct FProfileMatchItem>                   Match;                                                    // 0x000C(0x000C) (ZeroConstructor)
+};
+
+// ScriptStruct AndroidDeviceProfileSelector.JavaSurfaceViewDevice
+// 0x0018
+struct FJavaSurfaceViewDevice
+{
+	struct FString                                     Manufacturer;                                             // 0x0000(0x000C) (ZeroConstructor)
+	struct FString                                     Model;                                                    // 0x000C(0x000C) (ZeroConstructor)
+};
+
+}
+

结构体/数据/SDK/PUBGM_AndroidMediaFactory_classes.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Classes
+//---------------------------------------------------------------------------
+
+// Class AndroidMediaFactory.AndroidMediaSettings
+// 0x0004 (0x0020 - 0x001C)
+class UAndroidMediaSettings : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0x4];                                       // 0x001C(0x0004) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AndroidMediaFactory.AndroidMediaSettings");
+		return pStaticClass;
+	}
+
+};
+
+
+}
+

结构体/数据/SDK/PUBGM_AndroidMediaFactory_functions.cpp

@@ -0,0 +1,15 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_AndroidMediaFactory_parameters.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_AndroidMediaFactory_structs.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+}
+

结构体/数据/SDK/PUBGM_AndroidPermission_classes.hpp

@@ -0,0 +1,53 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Classes
+//---------------------------------------------------------------------------
+
+// Class AndroidPermission.AndroidPermissionCallbackProxy
+// 0x0054 (0x0070 - 0x001C)
+class UAndroidPermissionCallbackProxy : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0x54];                                      // 0x001C(0x0054) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AndroidPermission.AndroidPermissionCallbackProxy");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AndroidPermission.AndroidPermissionFunctionLibrary
+// 0x0000 (0x0020 - 0x0020)
+class UAndroidPermissionFunctionLibrary : public UBlueprintFunctionLibrary
+{
+public:
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AndroidPermission.AndroidPermissionFunctionLibrary");
+		return pStaticClass;
+	}
+
+
+	static bool CheckPermission(const struct FString& permission);
+	static class UAndroidPermissionCallbackProxy* AcquirePermissions(TArray<struct FString> Permissions);
+};
+
+
+}
+

结构体/数据/SDK/PUBGM_AndroidPermission_functions.cpp

@@ -0,0 +1,69 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+// Function AndroidPermission.AndroidPermissionFunctionLibrary.CheckPermission
+// (Final, Native, Static, Public, BlueprintCallable)
+// Parameters:
+// struct FString                 permission                     (Parm, ZeroConstructor)
+// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+bool UAndroidPermissionFunctionLibrary::CheckPermission(const struct FString& permission)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AndroidPermission.AndroidPermissionFunctionLibrary.CheckPermission");
+
+	UAndroidPermissionFunctionLibrary_CheckPermission_Params params;
+	params.permission = permission;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AndroidPermission.AndroidPermissionFunctionLibrary.AcquirePermissions
+// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
+// Parameters:
+// TArray<struct FString>         Permissions                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
+// class UAndroidPermissionCallbackProxy* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+class UAndroidPermissionCallbackProxy* UAndroidPermissionFunctionLibrary::AcquirePermissions(TArray<struct FString> Permissions)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AndroidPermission.AndroidPermissionFunctionLibrary.AcquirePermissions");
+
+	UAndroidPermissionFunctionLibrary_AcquirePermissions_Params params;
+	params.Permissions = Permissions;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+}
+

结构体/数据/SDK/PUBGM_AndroidPermission_parameters.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+// Function AndroidPermission.AndroidPermissionFunctionLibrary.CheckPermission
+struct UAndroidPermissionFunctionLibrary_CheckPermission_Params
+{
+	struct FString                                     permission;                                               // (Parm, ZeroConstructor)
+	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AndroidPermission.AndroidPermissionFunctionLibrary.AcquirePermissions
+struct UAndroidPermissionFunctionLibrary_AcquirePermissions_Params
+{
+	TArray<struct FString>                             Permissions;                                              // (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
+	class UAndroidPermissionCallbackProxy*             ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+}
+

结构体/数据/SDK/PUBGM_AndroidPermission_structs.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+}
+

结构体/数据/SDK/PUBGM_AndroidRuntimeSettings_classes.hpp

@@ -0,0 +1,117 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Classes
+//---------------------------------------------------------------------------
+
+// Class AndroidRuntimeSettings.AndroidRuntimeSettings
+// 0x01AC (0x01C8 - 0x001C)
+class UAndroidRuntimeSettings : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0xC];                                       // 0x001C(0x000C) MISSED OFFSET
+	int                                                StoreVersion;                                             // 0x0028(0x0004) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	struct FString                                     ApplicationDisplayName;                                   // 0x002C(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	struct FString                                     VersionDisplayName;                                       // 0x0038(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	int                                                MinSDKVersion;                                            // 0x0044(0x0004) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	int                                                TargetSDKVersion;                                         // 0x0048(0x0004) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	TEnumAsByte<EAndroidInstallLocation>               InstallLocation;                                          // 0x004C(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bEnableGradle;                                            // 0x004D(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bPackageDataInsideApk;                                    // 0x004E(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bCreateAllPlatformsInstall;                               // 0x004F(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bDisableVerifyOBBOnStartUp;                               // 0x0050(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bUseExternalFilesDir;                                     // 0x0051(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	TEnumAsByte<EAndroidScreenOrientation>             Orientation;                                              // 0x0052(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	unsigned char                                      UnknownData01[0x1];                                       // 0x0053(0x0001) MISSED OFFSET
+	float                                              MaxAspectRatio;                                           // 0x0054(0x0004) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	TEnumAsByte<EAndroidAntVerbosity>                  AntVerbosity;                                             // 0x0058(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bFullScreen;                                              // 0x0059(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bEnableNewKeyboard;                                       // 0x005A(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	TEnumAsByte<EAndroidDepthBufferPreference>         DepthBufferPreference;                                    // 0x005B(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	TArray<struct FString>                             ExtraManifestNodeTags;                                    // 0x005C(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	TArray<struct FString>                             ExtraApplicationNodeTags;                                 // 0x0068(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	struct FString                                     ExtraApplicationSettings;                                 // 0x0074(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	TArray<struct FString>                             ExtraActivityNodeTags;                                    // 0x0080(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	struct FString                                     ExtraActivitySettings;                                    // 0x008C(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	TArray<struct FString>                             ExtraPermissions;                                         // 0x0098(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	bool                                               bAndroidVoiceEnabled;                                     // 0x00A4(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bPackageForGearVR;                                        // 0x00A5(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bRemoveOSIG;                                              // 0x00A6(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	unsigned char                                      UnknownData02[0x1];                                       // 0x00A7(0x0001) MISSED OFFSET
+	TArray<TEnumAsByte<EGoogleVRCaps>>                 GoogleVRCaps;                                             // 0x00A8(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	bool                                               bGoogleVRSustainedPerformance;                            // 0x00B4(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	unsigned char                                      UnknownData03[0x3];                                       // 0x00B5(0x0003) MISSED OFFSET
+	struct FString                                     KeyStore;                                                 // 0x00B8(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	struct FString                                     KeyAlias;                                                 // 0x00C4(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	struct FString                                     KeyStorePassword;                                         // 0x00D0(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	struct FString                                     KeyPassword;                                              // 0x00DC(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	bool                                               bBuildForArmV7;                                           // 0x00E8(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bBuildForArm64;                                           // 0x00E9(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bBuildForX86;                                             // 0x00EA(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bBuildForX8664;                                           // 0x00EB(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bBuildForES2;                                             // 0x00EC(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bBuildForES31;                                            // 0x00ED(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bSupportsVulkan;                                          // 0x00EE(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bBuildWithHiddenSymbolVisibility;                         // 0x00EF(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bEnableGooglePlaySupport;                                 // 0x00F0(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bUseGetAccounts;                                          // 0x00F1(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	unsigned char                                      UnknownData04[0x2];                                       // 0x00F2(0x0002) MISSED OFFSET
+	struct FString                                     GamesAppID;                                               // 0x00F4(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	TArray<struct FGooglePlayAchievementMapping>       AchievementMap;                                           // 0x0100(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	TArray<struct FGooglePlayLeaderboardMapping>       LeaderboardMap;                                           // 0x010C(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	bool                                               bSupportAdMob;                                            // 0x0118(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	unsigned char                                      UnknownData05[0x3];                                       // 0x0119(0x0003) MISSED OFFSET
+	struct FString                                     AdMobAdUnitID;                                            // 0x011C(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	TArray<struct FString>                             AdMobAdUnitIDs;                                           // 0x0128(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	struct FString                                     GooglePlayLicenseKey;                                     // 0x0134(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	struct FString                                     GCMClientSenderID;                                        // 0x0140(0x000C) (Edit, ZeroConstructor, Config, GlobalConfig)
+	bool                                               bShowLaunchImage;                                         // 0x014C(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	TEnumAsByte<EAndroidAudio>                         AndroidAudio;                                             // 0x014D(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	unsigned char                                      UnknownData06[0x2];                                       // 0x014E(0x0002) MISSED OFFSET
+	int                                                AudioSampleRate;                                          // 0x0150(0x0004) (Edit, ZeroConstructor, Config, IsPlainOldData)
+	int                                                AudioCallbackBufferFrameSize;                             // 0x0154(0x0004) (Edit, ZeroConstructor, Config, IsPlainOldData)
+	int                                                AudioNumBuffersToEnqueue;                                 // 0x0158(0x0004) (Edit, ZeroConstructor, Config, IsPlainOldData)
+	int                                                AudioMaxChannels;                                         // 0x015C(0x0004) (Edit, ZeroConstructor, Config, IsPlainOldData)
+	int                                                AudioNumSourceWorkers;                                    // 0x0160(0x0004) (Edit, ZeroConstructor, Config, IsPlainOldData)
+	struct FString                                     SpatializationPlugin;                                     // 0x0164(0x000C) (Edit, ZeroConstructor, Config)
+	struct FString                                     ReverbPlugin;                                             // 0x0170(0x000C) (Edit, ZeroConstructor, Config)
+	struct FString                                     OcclusionPlugin;                                          // 0x017C(0x000C) (Edit, ZeroConstructor, Config)
+	TEnumAsByte<EAndroidGraphicsDebugger>              AndroidGraphicsDebugger;                                  // 0x0188(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	unsigned char                                      UnknownData07[0x3];                                       // 0x0189(0x0003) MISSED OFFSET
+	struct FDirectoryPath                              MaliGraphicsDebuggerPath;                                 // 0x018C(0x000C) (Edit, Config, GlobalConfig)
+	struct FDirectoryPath                              RenderDocPath;                                            // 0x0198(0x000C) (Edit, Config, GlobalConfig)
+	bool                                               bMultiTargetFormat_ETC1;                                  // 0x01A4(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bMultiTargetFormat_ETC2;                                  // 0x01A5(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bMultiTargetFormat_DXT;                                   // 0x01A6(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bMultiTargetFormat_PVRTC;                                 // 0x01A7(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bMultiTargetFormat_ATC;                                   // 0x01A8(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	bool                                               bMultiTargetFormat_ASTC;                                  // 0x01A9(0x0001) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	unsigned char                                      UnknownData08[0x2];                                       // 0x01AA(0x0002) MISSED OFFSET
+	float                                              TextureFormatPriority_ETC1;                               // 0x01AC(0x0004) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	float                                              TextureFormatPriority_ETC2;                               // 0x01B0(0x0004) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	float                                              TextureFormatPriority_DXT;                                // 0x01B4(0x0004) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	float                                              TextureFormatPriority_PVRTC;                              // 0x01B8(0x0004) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	float                                              TextureFormatPriority_ATC;                                // 0x01BC(0x0004) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	float                                              TextureFormatPriority_ASTC;                               // 0x01C0(0x0004) (Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData)
+	unsigned char                                      UnknownData09[0x4];                                       // 0x01C4(0x0004) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AndroidRuntimeSettings.AndroidRuntimeSettings");
+		return pStaticClass;
+	}
+
+};
+
+
+}
+

结构体/数据/SDK/PUBGM_AndroidRuntimeSettings_functions.cpp

@@ -0,0 +1,15 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_AndroidRuntimeSettings_parameters.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_AndroidRuntimeSettings_structs.hpp

@@ -0,0 +1,123 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Enums
+//---------------------------------------------------------------------------
+
+// Enum AndroidRuntimeSettings.EAndroidGraphicsDebugger
+enum class EAndroidGraphicsDebugger : uint8_t
+{
+	EAndroidGraphicsDebugger__None = 0,
+	EAndroidGraphicsDebugger__Mali = 1,
+	EAndroidGraphicsDebugger__Adreno = 2,
+	EAndroidGraphicsDebugger__RenderDoc = 3,
+	EAndroidGraphicsDebugger__EAndroidGraphicsDebugger_MAX = 4
+};
+
+
+// Enum AndroidRuntimeSettings.EGoogleVRCaps
+enum class EGoogleVRCaps : uint8_t
+{
+	EGoogleVRCaps__Cardboard       = 0,
+	EGoogleVRCaps__Daydream33      = 1,
+	EGoogleVRCaps__Daydream63      = 2,
+	EGoogleVRCaps__EGoogleVRCaps_MAX = 3
+};
+
+
+// Enum AndroidRuntimeSettings.EGoogleVRMode
+enum class EGoogleVRMode : uint8_t
+{
+	EGoogleVRMode__Cardboard       = 0,
+	EGoogleVRMode__Daydream        = 1,
+	EGoogleVRMode__DaydreamAndCardboard = 2,
+	EGoogleVRMode__EGoogleVRMode_MAX = 3
+};
+
+
+// Enum AndroidRuntimeSettings.EAndroidAudio
+enum class EAndroidAudio : uint8_t
+{
+	EAndroidAudio__Default         = 0,
+	EAndroidAudio__OGG             = 1,
+	EAndroidAudio__ADPCM           = 2,
+	EAndroidAudio__EAndroidAudio_MAX = 3
+};
+
+
+// Enum AndroidRuntimeSettings.EAndroidInstallLocation
+enum class EAndroidInstallLocation : uint8_t
+{
+	EAndroidInstallLocation__InternalOnly = 0,
+	EAndroidInstallLocation__PreferExternal = 1,
+	EAndroidInstallLocation__Auto  = 2,
+	EAndroidInstallLocation__EAndroidInstallLocation_MAX = 3
+};
+
+
+// Enum AndroidRuntimeSettings.EAndroidDepthBufferPreference
+enum class EAndroidDepthBufferPreference : uint8_t
+{
+	EAndroidDepthBufferPreference__Default = 0,
+	EAndroidDepthBufferPreference__Bits16 = 1,
+	EAndroidDepthBufferPreference__Bits24 = 2,
+	EAndroidDepthBufferPreference__Bits32 = 3,
+	EAndroidDepthBufferPreference__EAndroidDepthBufferPreference_MAX = 4
+};
+
+
+// Enum AndroidRuntimeSettings.EAndroidScreenOrientation
+enum class EAndroidScreenOrientation : uint8_t
+{
+	EAndroidScreenOrientation__Portrait = 0,
+	EAndroidScreenOrientation__ReversePortrait = 1,
+	EAndroidScreenOrientation__SensorPortrait = 2,
+	EAndroidScreenOrientation__Landscape = 3,
+	EAndroidScreenOrientation__ReverseLandscape = 4,
+	EAndroidScreenOrientation__SensorLandscape = 5,
+	EAndroidScreenOrientation__Sensor = 6,
+	EAndroidScreenOrientation__FullSensor = 7,
+	EAndroidScreenOrientation__EAndroidScreenOrientation_MAX = 8
+};
+
+
+// Enum AndroidRuntimeSettings.EAndroidAntVerbosity
+enum class EAndroidAntVerbosity : uint8_t
+{
+	EAndroidAntVerbosity__Quiet    = 0,
+	EAndroidAntVerbosity__Normal   = 1,
+	EAndroidAntVerbosity__Verbose  = 2,
+	EAndroidAntVerbosity__EAndroidAntVerbosity_MAX = 3
+};
+
+
+
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// ScriptStruct AndroidRuntimeSettings.GooglePlayAchievementMapping
+// 0x0018
+struct FGooglePlayAchievementMapping
+{
+	struct FString                                     Name;                                                     // 0x0000(0x000C) (Edit, ZeroConstructor)
+	struct FString                                     AchievementID;                                            // 0x000C(0x000C) (Edit, ZeroConstructor)
+};
+
+// ScriptStruct AndroidRuntimeSettings.GooglePlayLeaderboardMapping
+// 0x0018
+struct FGooglePlayLeaderboardMapping
+{
+	struct FString                                     Name;                                                     // 0x0000(0x000C) (Edit, ZeroConstructor)
+	struct FString                                     LeaderboardID;                                            // 0x000C(0x000C) (Edit, ZeroConstructor)
+};
+
+}
+

结构体/数据/SDK/PUBGM_AnimGraphRuntime_classes.hpp

@@ -0,0 +1,134 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Classes
+//---------------------------------------------------------------------------
+
+// Class AnimGraphRuntime.AnimCustomInstance
+// 0x0000 (0x02F0 - 0x02F0)
+class UAnimCustomInstance : public UAnimInstance
+{
+public:
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AnimGraphRuntime.AnimCustomInstance");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AnimGraphRuntime.AnimNotify_PlayMontageNotify
+// 0x0008 (0x0030 - 0x0028)
+class UAnimNotify_PlayMontageNotify : public UAnimNotify
+{
+public:
+	struct FName                                       NotifyName;                                               // 0x0028(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData)
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AnimGraphRuntime.AnimNotify_PlayMontageNotify");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AnimGraphRuntime.AnimNotify_PlayMontageNotifyWindow
+// 0x0008 (0x0028 - 0x0020)
+class UAnimNotify_PlayMontageNotifyWindow : public UAnimNotifyState
+{
+public:
+	struct FName                                       NotifyName;                                               // 0x0020(0x0008) (Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData)
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AnimGraphRuntime.AnimNotify_PlayMontageNotifyWindow");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AnimGraphRuntime.AnimSequencerInstance
+// 0x0000 (0x02F0 - 0x02F0)
+class UAnimSequencerInstance : public UAnimCustomInstance
+{
+public:
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AnimGraphRuntime.AnimSequencerInstance");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AnimGraphRuntime.KismetAnimationLibrary
+// 0x0000 (0x0020 - 0x0020)
+class UKismetAnimationLibrary : public UBlueprintFunctionLibrary
+{
+public:
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AnimGraphRuntime.KismetAnimationLibrary");
+		return pStaticClass;
+	}
+
+
+	static void K2_TwoBoneIK(const struct FVector& RootPos, const struct FVector& JointPos, const struct FVector& EndPos, const struct FVector& JointTarget, const struct FVector& Effector, float MaxStretchScale, float StartStretchRatio, bool bAllowStretching, struct FVector* OutEndPos, struct FVector* OutJointPos);
+	static struct FTransform K2_LookAt(const struct FTransform& CurrentTransform, const struct FVector& TargetPosition, const struct FVector& LookAtVector, bool bUseUpVector, const struct FVector& UpVector, float ClampConeInDegree);
+};
+
+
+// Class AnimGraphRuntime.PlayMontageCallbackProxy
+// 0x00D4 (0x00F0 - 0x001C)
+class UPlayMontageCallbackProxy : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0xC];                                       // 0x001C(0x000C) MISSED OFFSET
+	struct FScriptMulticastDelegate                    OnBlendOut;                                               // 0x0028(0x000C) (ZeroConstructor, InstancedReference, BlueprintAssignable)
+	struct FScriptMulticastDelegate                    OnInterrupted;                                            // 0x0034(0x000C) (ZeroConstructor, InstancedReference, BlueprintAssignable)
+	struct FScriptMulticastDelegate                    OnNotifyBegin;                                            // 0x0040(0x000C) (ZeroConstructor, InstancedReference, BlueprintAssignable)
+	struct FScriptMulticastDelegate                    OnNotifyEnd;                                              // 0x004C(0x000C) (ZeroConstructor, InstancedReference, BlueprintAssignable)
+	unsigned char                                      UnknownData01[0x98];                                      // 0x0058(0x0098) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AnimGraphRuntime.PlayMontageCallbackProxy");
+		return pStaticClass;
+	}
+
+
+	void OnNotifyEndReceived(const struct FName& NotifyName, const struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload);
+	void OnNotifyBeginReceived(const struct FName& NotifyName, const struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload);
+	void OnMontageEnded(class UAnimMontage* Montage, bool bInterrupted);
+	void OnMontageBlendingOut(class UAnimMontage* Montage, bool bInterrupted);
+	static class UPlayMontageCallbackProxy* CreateProxyObjectForPlayMontage(class USkeletalMeshComponent* InSkeletalMeshComponent, class UAnimMontage* MontageToPlay, float PlayRate, float StartingPosition, const struct FName& StartingSection);
+};
+
+
+}
+

结构体/数据/SDK/PUBGM_AnimGraphRuntime_functions.cpp

@@ -0,0 +1,236 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+// Function AnimGraphRuntime.KismetAnimationLibrary.K2_TwoBoneIK
+// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
+// Parameters:
+// struct FVector                 RootPos                        (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+// struct FVector                 JointPos                       (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+// struct FVector                 EndPos                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+// struct FVector                 JointTarget                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+// struct FVector                 Effector                       (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+// struct FVector                 OutJointPos                    (Parm, OutParm, IsPlainOldData)
+// struct FVector                 OutEndPos                      (Parm, OutParm, IsPlainOldData)
+// bool                           bAllowStretching               (Parm, ZeroConstructor, IsPlainOldData)
+// float                          StartStretchRatio              (Parm, ZeroConstructor, IsPlainOldData)
+// float                          MaxStretchScale                (Parm, ZeroConstructor, IsPlainOldData)
+
+void UKismetAnimationLibrary::K2_TwoBoneIK(const struct FVector& RootPos, const struct FVector& JointPos, const struct FVector& EndPos, const struct FVector& JointTarget, const struct FVector& Effector, float MaxStretchScale, float StartStretchRatio, bool bAllowStretching, struct FVector* OutEndPos, struct FVector* OutJointPos)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AnimGraphRuntime.KismetAnimationLibrary.K2_TwoBoneIK");
+
+	UKismetAnimationLibrary_K2_TwoBoneIK_Params params;
+	params.RootPos = RootPos;
+	params.JointPos = JointPos;
+	params.EndPos = EndPos;
+	params.JointTarget = JointTarget;
+	params.Effector = Effector;
+	params.bAllowStretching = bAllowStretching;
+	params.StartStretchRatio = StartStretchRatio;
+	params.MaxStretchScale = MaxStretchScale;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	if (OutJointPos != nullptr)
+		*OutJointPos = params.OutJointPos;
+	if (OutEndPos != nullptr)
+		*OutEndPos = params.OutEndPos;
+}
+
+
+// Function AnimGraphRuntime.KismetAnimationLibrary.K2_LookAt
+// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
+// Parameters:
+// struct FTransform              CurrentTransform               (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+// struct FVector                 TargetPosition                 (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+// struct FVector                 LookAtVector                   (Parm, IsPlainOldData)
+// bool                           bUseUpVector                   (Parm, ZeroConstructor, IsPlainOldData)
+// struct FVector                 UpVector                       (Parm, IsPlainOldData)
+// float                          ClampConeInDegree              (Parm, ZeroConstructor, IsPlainOldData)
+// struct FTransform              ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)
+
+struct FTransform UKismetAnimationLibrary::K2_LookAt(const struct FTransform& CurrentTransform, const struct FVector& TargetPosition, const struct FVector& LookAtVector, bool bUseUpVector, const struct FVector& UpVector, float ClampConeInDegree)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AnimGraphRuntime.KismetAnimationLibrary.K2_LookAt");
+
+	UKismetAnimationLibrary_K2_LookAt_Params params;
+	params.CurrentTransform = CurrentTransform;
+	params.TargetPosition = TargetPosition;
+	params.LookAtVector = LookAtVector;
+	params.bUseUpVector = bUseUpVector;
+	params.UpVector = UpVector;
+	params.ClampConeInDegree = ClampConeInDegree;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AnimGraphRuntime.PlayMontageCallbackProxy.OnNotifyEndReceived
+// (Final, Native, Protected, HasOutParms)
+// Parameters:
+// struct FName                   NotifyName                     (Parm, ZeroConstructor, IsPlainOldData)
+// struct FBranchingPointNotifyPayload BranchingPointNotifyPayload    (ConstParm, Parm, OutParm, ReferenceParm)
+
+void UPlayMontageCallbackProxy::OnNotifyEndReceived(const struct FName& NotifyName, const struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AnimGraphRuntime.PlayMontageCallbackProxy.OnNotifyEndReceived");
+
+	UPlayMontageCallbackProxy_OnNotifyEndReceived_Params params;
+	params.NotifyName = NotifyName;
+	params.BranchingPointNotifyPayload = BranchingPointNotifyPayload;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AnimGraphRuntime.PlayMontageCallbackProxy.OnNotifyBeginReceived
+// (Final, Native, Protected, HasOutParms)
+// Parameters:
+// struct FName                   NotifyName                     (Parm, ZeroConstructor, IsPlainOldData)
+// struct FBranchingPointNotifyPayload BranchingPointNotifyPayload    (ConstParm, Parm, OutParm, ReferenceParm)
+
+void UPlayMontageCallbackProxy::OnNotifyBeginReceived(const struct FName& NotifyName, const struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AnimGraphRuntime.PlayMontageCallbackProxy.OnNotifyBeginReceived");
+
+	UPlayMontageCallbackProxy_OnNotifyBeginReceived_Params params;
+	params.NotifyName = NotifyName;
+	params.BranchingPointNotifyPayload = BranchingPointNotifyPayload;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AnimGraphRuntime.PlayMontageCallbackProxy.OnMontageEnded
+// (Final, Native, Protected)
+// Parameters:
+// class UAnimMontage*            Montage                        (Parm, ZeroConstructor, IsPlainOldData)
+// bool                           bInterrupted                   (Parm, ZeroConstructor, IsPlainOldData)
+
+void UPlayMontageCallbackProxy::OnMontageEnded(class UAnimMontage* Montage, bool bInterrupted)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AnimGraphRuntime.PlayMontageCallbackProxy.OnMontageEnded");
+
+	UPlayMontageCallbackProxy_OnMontageEnded_Params params;
+	params.Montage = Montage;
+	params.bInterrupted = bInterrupted;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AnimGraphRuntime.PlayMontageCallbackProxy.OnMontageBlendingOut
+// (Final, Native, Protected)
+// Parameters:
+// class UAnimMontage*            Montage                        (Parm, ZeroConstructor, IsPlainOldData)
+// bool                           bInterrupted                   (Parm, ZeroConstructor, IsPlainOldData)
+
+void UPlayMontageCallbackProxy::OnMontageBlendingOut(class UAnimMontage* Montage, bool bInterrupted)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AnimGraphRuntime.PlayMontageCallbackProxy.OnMontageBlendingOut");
+
+	UPlayMontageCallbackProxy_OnMontageBlendingOut_Params params;
+	params.Montage = Montage;
+	params.bInterrupted = bInterrupted;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AnimGraphRuntime.PlayMontageCallbackProxy.CreateProxyObjectForPlayMontage
+// (Final, Native, Static, Public, BlueprintCallable)
+// Parameters:
+// class USkeletalMeshComponent*  InSkeletalMeshComponent        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
+// class UAnimMontage*            MontageToPlay                  (Parm, ZeroConstructor, IsPlainOldData)
+// float                          PlayRate                       (Parm, ZeroConstructor, IsPlainOldData)
+// float                          StartingPosition               (Parm, ZeroConstructor, IsPlainOldData)
+// struct FName                   StartingSection                (Parm, ZeroConstructor, IsPlainOldData)
+// class UPlayMontageCallbackProxy* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+class UPlayMontageCallbackProxy* UPlayMontageCallbackProxy::CreateProxyObjectForPlayMontage(class USkeletalMeshComponent* InSkeletalMeshComponent, class UAnimMontage* MontageToPlay, float PlayRate, float StartingPosition, const struct FName& StartingSection)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AnimGraphRuntime.PlayMontageCallbackProxy.CreateProxyObjectForPlayMontage");
+
+	UPlayMontageCallbackProxy_CreateProxyObjectForPlayMontage_Params params;
+	params.InSkeletalMeshComponent = InSkeletalMeshComponent;
+	params.MontageToPlay = MontageToPlay;
+	params.PlayRate = PlayRate;
+	params.StartingPosition = StartingPosition;
+	params.StartingSection = StartingSection;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+}
+

结构体/数据/SDK/PUBGM_AnimGraphRuntime_parameters.hpp

@@ -0,0 +1,83 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+// Function AnimGraphRuntime.KismetAnimationLibrary.K2_TwoBoneIK
+struct UKismetAnimationLibrary_K2_TwoBoneIK_Params
+{
+	struct FVector                                     RootPos;                                                  // (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+	struct FVector                                     JointPos;                                                 // (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+	struct FVector                                     EndPos;                                                   // (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+	struct FVector                                     JointTarget;                                              // (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+	struct FVector                                     Effector;                                                 // (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+	struct FVector                                     OutJointPos;                                              // (Parm, OutParm, IsPlainOldData)
+	struct FVector                                     OutEndPos;                                                // (Parm, OutParm, IsPlainOldData)
+	bool                                               bAllowStretching;                                         // (Parm, ZeroConstructor, IsPlainOldData)
+	float                                              StartStretchRatio;                                        // (Parm, ZeroConstructor, IsPlainOldData)
+	float                                              MaxStretchScale;                                          // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AnimGraphRuntime.KismetAnimationLibrary.K2_LookAt
+struct UKismetAnimationLibrary_K2_LookAt_Params
+{
+	struct FTransform                                  CurrentTransform;                                         // (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+	struct FVector                                     TargetPosition;                                           // (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+	struct FVector                                     LookAtVector;                                             // (Parm, IsPlainOldData)
+	bool                                               bUseUpVector;                                             // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FVector                                     UpVector;                                                 // (Parm, IsPlainOldData)
+	float                                              ClampConeInDegree;                                        // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FTransform                                  ReturnValue;                                              // (Parm, OutParm, ReturnParm, IsPlainOldData)
+};
+
+// Function AnimGraphRuntime.PlayMontageCallbackProxy.OnNotifyEndReceived
+struct UPlayMontageCallbackProxy_OnNotifyEndReceived_Params
+{
+	struct FName                                       NotifyName;                                               // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FBranchingPointNotifyPayload                BranchingPointNotifyPayload;                              // (ConstParm, Parm, OutParm, ReferenceParm)
+};
+
+// Function AnimGraphRuntime.PlayMontageCallbackProxy.OnNotifyBeginReceived
+struct UPlayMontageCallbackProxy_OnNotifyBeginReceived_Params
+{
+	struct FName                                       NotifyName;                                               // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FBranchingPointNotifyPayload                BranchingPointNotifyPayload;                              // (ConstParm, Parm, OutParm, ReferenceParm)
+};
+
+// Function AnimGraphRuntime.PlayMontageCallbackProxy.OnMontageEnded
+struct UPlayMontageCallbackProxy_OnMontageEnded_Params
+{
+	class UAnimMontage*                                Montage;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               bInterrupted;                                             // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AnimGraphRuntime.PlayMontageCallbackProxy.OnMontageBlendingOut
+struct UPlayMontageCallbackProxy_OnMontageBlendingOut_Params
+{
+	class UAnimMontage*                                Montage;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               bInterrupted;                                             // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AnimGraphRuntime.PlayMontageCallbackProxy.CreateProxyObjectForPlayMontage
+struct UPlayMontageCallbackProxy_CreateProxyObjectForPlayMontage_Params
+{
+	class USkeletalMeshComponent*                      InSkeletalMeshComponent;                                  // (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
+	class UAnimMontage*                                MontageToPlay;                                            // (Parm, ZeroConstructor, IsPlainOldData)
+	float                                              PlayRate;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
+	float                                              StartingPosition;                                         // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FName                                       StartingSection;                                          // (Parm, ZeroConstructor, IsPlainOldData)
+	class UPlayMontageCallbackProxy*                   ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+}
+

结构体/数据/SDK/PUBGM_AnimationCore_classes.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+}
+

结构体/数据/SDK/PUBGM_AnimationCore_functions.cpp

@@ -0,0 +1,15 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_AnimationCore_parameters.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_AnimationCore_structs.hpp

@@ -0,0 +1,175 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Enums
+//---------------------------------------------------------------------------
+
+// Enum AnimationCore.ETransformConstraintType
+enum class ETransformConstraintType : uint8_t
+{
+	ETransformConstraintType__Translation = 0,
+	ETransformConstraintType__Rotation = 1,
+	ETransformConstraintType__Scale = 2,
+	ETransformConstraintType__Parent = 3,
+	ETransformConstraintType__ETransformConstraintType_MAX = 4
+};
+
+
+// Enum AnimationCore.EConstraintType
+enum class EConstraintType : uint8_t
+{
+	EConstraintType__Transform     = 0,
+	EConstraintType__Aim           = 1,
+	EConstraintType__MAX           = 2
+};
+
+
+
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// ScriptStruct AnimationCore.Axis
+// 0x0010
+struct FAxis
+{
+	struct FVector                                     Axis;                                                     // 0x0000(0x000C) (Edit, IsPlainOldData)
+	bool                                               bInLocalSpace;                                            // 0x000C(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x000D(0x0003) MISSED OFFSET
+};
+
+// ScriptStruct AnimationCore.ConstraintDescriptor
+// 0x0008
+struct FConstraintDescriptor
+{
+	EConstraintType                                    Type;                                                     // 0x0000(0x0001) (ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x7];                                       // 0x0001(0x0007) MISSED OFFSET
+};
+
+// ScriptStruct AnimationCore.ConstraintData
+// 0x0080
+struct FConstraintData
+{
+	struct FConstraintDescriptor                       Constraint;                                               // 0x0000(0x0008)
+	struct FName                                       TargetNode;                                               // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData)
+	float                                              Weight;                                                   // 0x0010(0x0004) (ZeroConstructor, IsPlainOldData)
+	bool                                               bMaintainOffset;                                          // 0x0014(0x0001) (ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0xB];                                       // 0x0015(0x000B) MISSED OFFSET
+	struct FTransform                                  Offset;                                                   // 0x0020(0x0030) (IsPlainOldData)
+	struct FTransform                                  CurrentTransform;                                         // 0x0050(0x0030) (Transient, IsPlainOldData)
+};
+
+// ScriptStruct AnimationCore.FilterOptionPerAxis
+// 0x0003
+struct FFilterOptionPerAxis
+{
+	bool                                               bX;                                                       // 0x0000(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	bool                                               bY;                                                       // 0x0001(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	bool                                               bZ;                                                       // 0x0002(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AnimationCore.ConstraintDescriptionEx
+// 0x0008
+struct FConstraintDescriptionEx
+{
+	unsigned char                                      UnknownData00[0x4];                                       // 0x0000(0x0004) MISSED OFFSET
+	struct FFilterOptionPerAxis                        AxesFilterOption;                                         // 0x0004(0x0003) (Edit)
+	unsigned char                                      UnknownData01[0x1];                                       // 0x0007(0x0001) MISSED OFFSET
+};
+
+// ScriptStruct AnimationCore.AimConstraintDescription
+// 0x0024 (0x002C - 0x0008)
+struct FAimConstraintDescription : public FConstraintDescriptionEx
+{
+	struct FAxis                                       LookAt_Axis;                                              // 0x0008(0x0010) (Edit)
+	struct FAxis                                       LookUp_Axis;                                              // 0x0018(0x0010) (Edit)
+	bool                                               bUseLookUp;                                               // 0x0028(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x0029(0x0003) MISSED OFFSET
+};
+
+// ScriptStruct AnimationCore.TransformConstraintDescription
+// 0x0000 (0x0008 - 0x0008)
+struct FTransformConstraintDescription : public FConstraintDescriptionEx
+{
+	ETransformConstraintType                           TransformType;                                            // 0x0007(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AnimationCore.ConstraintDescription
+// 0x000D
+struct FConstraintDescription
+{
+	bool                                               bTranslation;                                             // 0x0000(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	bool                                               bRotation;                                                // 0x0001(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	bool                                               bScale;                                                   // 0x0002(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	bool                                               bParent;                                                  // 0x0003(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	struct FFilterOptionPerAxis                        TranslationAxes;                                          // 0x0004(0x0003) (Edit, BlueprintVisible)
+	struct FFilterOptionPerAxis                        RotationAxes;                                             // 0x0007(0x0003) (Edit, BlueprintVisible)
+	struct FFilterOptionPerAxis                        ScaleAxes;                                                // 0x000A(0x0003) (Edit, BlueprintVisible)
+};
+
+// ScriptStruct AnimationCore.TransformConstraint
+// 0x0028
+struct FTransformConstraint
+{
+	struct FConstraintDescription                      Operator;                                                 // 0x0000(0x000D) (Edit, BlueprintVisible)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x000D(0x0003) MISSED OFFSET
+	struct FName                                       SourceNode;                                               // 0x0010(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	struct FName                                       TargetNode;                                               // 0x0018(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              Weight;                                                   // 0x0020(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	bool                                               bMaintainOffset;                                          // 0x0024(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData01[0x3];                                       // 0x0025(0x0003) MISSED OFFSET
+};
+
+// ScriptStruct AnimationCore.ConstraintOffset
+// 0x0060
+struct FConstraintOffset
+{
+	struct FVector                                     Translation;                                              // 0x0000(0x000C) (IsPlainOldData)
+	unsigned char                                      UnknownData00[0x4];                                       // 0x000C(0x0004) MISSED OFFSET
+	struct FQuat                                       Rotation;                                                 // 0x0010(0x0010) (IsPlainOldData)
+	struct FVector                                     Scale;                                                    // 0x0020(0x000C) (IsPlainOldData)
+	unsigned char                                      UnknownData01[0x4];                                       // 0x002C(0x0004) MISSED OFFSET
+	struct FTransform                                  Parent;                                                   // 0x0030(0x0030) (IsPlainOldData)
+};
+
+// ScriptStruct AnimationCore.NodeChain
+// 0x000C
+struct FNodeChain
+{
+	TArray<struct FName>                               Nodes;                                                    // 0x0000(0x000C) (ZeroConstructor)
+};
+
+// ScriptStruct AnimationCore.NodeObject
+// 0x0010
+struct FNodeObject
+{
+	struct FName                                       Name;                                                     // 0x0000(0x0008) (ZeroConstructor, IsPlainOldData)
+	struct FName                                       ParentName;                                               // 0x0008(0x0008) (ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct AnimationCore.NodeHierarchyData
+// 0x0054
+struct FNodeHierarchyData
+{
+	TArray<struct FNodeObject>                         Nodes;                                                    // 0x0000(0x000C) (ZeroConstructor)
+	TArray<struct FTransform>                          Transforms;                                               // 0x000C(0x000C) (ZeroConstructor)
+	TMap<struct FName, int>                            NodeNameToIndexMapping;                                   // 0x0018(0x0050) (ZeroConstructor)
+};
+
+// ScriptStruct AnimationCore.NodeHierarchyWithUserData
+// 0x0058
+struct FNodeHierarchyWithUserData
+{
+	unsigned char                                      UnknownData00[0x4];                                       // 0x0000(0x0004) MISSED OFFSET
+	struct FNodeHierarchyData                          Hierarchy;                                                // 0x0004(0x0054)
+};
+
+}
+

结构体/数据/SDK/PUBGM_ApexDestruction_classes.hpp

@@ -0,0 +1,112 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Classes
+//---------------------------------------------------------------------------
+
+// Class ApexDestruction.DestructibleActor
+// 0x0018 (0x02D0 - 0x02B8)
+class ADestructibleActor : public AActor
+{
+public:
+	class UDestructibleComponent*                      DestructibleComponent;                                    // 0x02B8(0x0004) (Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, IsPlainOldData)
+	unsigned char                                      bAffectNavigation : 1;                                    // 0x02BC(0x0001) (Edit, BlueprintVisible, Config)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x02BD(0x0003) MISSED OFFSET
+	struct FScriptMulticastDelegate                    OnActorFracture;                                          // 0x02C0(0x000C) (ZeroConstructor, InstancedReference, BlueprintAssignable)
+	unsigned char                                      UnknownData01[0x4];                                       // 0x02CC(0x0004) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class ApexDestruction.DestructibleActor");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class ApexDestruction.DestructibleComponent
+// 0x00B0 (0x07E0 - 0x0730)
+class UDestructibleComponent : public USkinnedMeshComponent
+{
+public:
+	unsigned char                                      UnknownData00[0x4];                                       // 0x0730(0x0004) MISSED OFFSET
+	unsigned char                                      bFractureEffectOverride : 1;                              // 0x0734(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      UnknownData01[0x3];                                       // 0x0735(0x0003) MISSED OFFSET
+	TArray<struct FFractureEffect>                     FractureEffects;                                          // 0x0738(0x000C) (Edit, BlueprintVisible, BlueprintReadOnly, EditFixedSize, ZeroConstructor)
+	bool                                               bEnableHardSleeping;                                      // 0x0744(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData02[0x3];                                       // 0x0745(0x0003) MISSED OFFSET
+	float                                              LargeChunkThreshold;                                      // 0x0748(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData03[0xC];                                       // 0x074C(0x000C) MISSED OFFSET
+	struct FScriptMulticastDelegate                    OnComponentFracture;                                      // 0x0758(0x000C) (ZeroConstructor, InstancedReference, BlueprintAssignable)
+	unsigned char                                      UnknownData04[0x7C];                                      // 0x0764(0x007C) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class ApexDestruction.DestructibleComponent");
+		return pStaticClass;
+	}
+
+
+	void SetDestructibleMesh(class UDestructibleMesh* NewMesh);
+	class UDestructibleMesh* GetDestructibleMesh();
+	void ApplyRadiusDamage(float BaseDamage, const struct FVector& HurtOrigin, float DamageRadius, float ImpulseStrength, bool bFullDamage);
+	void ApplyDamage(float DamageAmount, const struct FVector& HitLocation, const struct FVector& ImpulseDir, float ImpulseStrength);
+};
+
+
+// Class ApexDestruction.DestructibleFractureSettings
+// 0x0054 (0x0070 - 0x001C)
+class UDestructibleFractureSettings : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0x4];                                       // 0x001C(0x0004) MISSED OFFSET
+	struct FFractureMaterial                           FractureMaterialDesc;                                     // 0x0020(0x0024) (Edit, Transient)
+	int                                                RandomSeed;                                               // 0x0044(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	TArray<struct FVector>                             VoronoiSites;                                             // 0x0048(0x000C) (ZeroConstructor)
+	int                                                OriginalSubmeshCount;                                     // 0x0054(0x0004) (ZeroConstructor, IsPlainOldData)
+	TArray<class UMaterialInterface*>                  Materials;                                                // 0x0058(0x000C) (ZeroConstructor)
+	TArray<struct FDestructibleChunkParameters>        ChunkParameters;                                          // 0x0064(0x000C) (ZeroConstructor)
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class ApexDestruction.DestructibleFractureSettings");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class ApexDestruction.DestructibleMesh
+// 0x0088 (0x02A8 - 0x0220)
+class UDestructibleMesh : public USkeletalMesh
+{
+public:
+	struct FDestructibleParameters                     DefaultDestructibleParameters;                            // 0x0220(0x007C) (Edit)
+	TArray<struct FFractureEffect>                     FractureEffects;                                          // 0x029C(0x000C) (Edit, EditFixedSize, ZeroConstructor)
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class ApexDestruction.DestructibleMesh");
+		return pStaticClass;
+	}
+
+};
+
+
+}
+

结构体/数据/SDK/PUBGM_ApexDestruction_functions.cpp

@@ -0,0 +1,126 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+// Function ApexDestruction.DestructibleComponent.SetDestructibleMesh
+// (Final, Native, Public, BlueprintCallable)
+// Parameters:
+// class UDestructibleMesh*       NewMesh                        (Parm, ZeroConstructor, IsPlainOldData)
+
+void UDestructibleComponent::SetDestructibleMesh(class UDestructibleMesh* NewMesh)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function ApexDestruction.DestructibleComponent.SetDestructibleMesh");
+
+	UDestructibleComponent_SetDestructibleMesh_Params params;
+	params.NewMesh = NewMesh;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function ApexDestruction.DestructibleComponent.GetDestructibleMesh
+// (Final, Native, Public, BlueprintCallable)
+// Parameters:
+// class UDestructibleMesh*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+class UDestructibleMesh* UDestructibleComponent::GetDestructibleMesh()
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function ApexDestruction.DestructibleComponent.GetDestructibleMesh");
+
+	UDestructibleComponent_GetDestructibleMesh_Params params;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function ApexDestruction.DestructibleComponent.ApplyRadiusDamage
+// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
+// Parameters:
+// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
+// struct FVector                 HurtOrigin                     (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+// float                          DamageRadius                   (Parm, ZeroConstructor, IsPlainOldData)
+// float                          ImpulseStrength                (Parm, ZeroConstructor, IsPlainOldData)
+// bool                           bFullDamage                    (Parm, ZeroConstructor, IsPlainOldData)
+
+void UDestructibleComponent::ApplyRadiusDamage(float BaseDamage, const struct FVector& HurtOrigin, float DamageRadius, float ImpulseStrength, bool bFullDamage)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function ApexDestruction.DestructibleComponent.ApplyRadiusDamage");
+
+	UDestructibleComponent_ApplyRadiusDamage_Params params;
+	params.BaseDamage = BaseDamage;
+	params.HurtOrigin = HurtOrigin;
+	params.DamageRadius = DamageRadius;
+	params.ImpulseStrength = ImpulseStrength;
+	params.bFullDamage = bFullDamage;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function ApexDestruction.DestructibleComponent.ApplyDamage
+// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
+// Parameters:
+// float                          DamageAmount                   (Parm, ZeroConstructor, IsPlainOldData)
+// struct FVector                 HitLocation                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+// struct FVector                 ImpulseDir                     (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+// float                          ImpulseStrength                (Parm, ZeroConstructor, IsPlainOldData)
+
+void UDestructibleComponent::ApplyDamage(float DamageAmount, const struct FVector& HitLocation, const struct FVector& ImpulseDir, float ImpulseStrength)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function ApexDestruction.DestructibleComponent.ApplyDamage");
+
+	UDestructibleComponent_ApplyDamage_Params params;
+	params.DamageAmount = DamageAmount;
+	params.HitLocation = HitLocation;
+	params.ImpulseDir = ImpulseDir;
+	params.ImpulseStrength = ImpulseStrength;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+}
+

结构体/数据/SDK/PUBGM_ApexDestruction_parameters.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+// Function ApexDestruction.DestructibleComponent.SetDestructibleMesh
+struct UDestructibleComponent_SetDestructibleMesh_Params
+{
+	class UDestructibleMesh*                           NewMesh;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function ApexDestruction.DestructibleComponent.GetDestructibleMesh
+struct UDestructibleComponent_GetDestructibleMesh_Params
+{
+	class UDestructibleMesh*                           ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function ApexDestruction.DestructibleComponent.ApplyRadiusDamage
+struct UDestructibleComponent_ApplyRadiusDamage_Params
+{
+	float                                              BaseDamage;                                               // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FVector                                     HurtOrigin;                                               // (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+	float                                              DamageRadius;                                             // (Parm, ZeroConstructor, IsPlainOldData)
+	float                                              ImpulseStrength;                                          // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               bFullDamage;                                              // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function ApexDestruction.DestructibleComponent.ApplyDamage
+struct UDestructibleComponent_ApplyDamage_Params
+{
+	float                                              DamageAmount;                                             // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FVector                                     HitLocation;                                              // (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+	struct FVector                                     ImpulseDir;                                               // (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
+	float                                              ImpulseStrength;                                          // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+}
+

结构体/数据/SDK/PUBGM_ApexDestruction_structs.hpp

@@ -0,0 +1,134 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Enums
+//---------------------------------------------------------------------------
+
+// Enum ApexDestruction.EImpactDamageOverride
+enum class EImpactDamageOverride : uint8_t
+{
+	IDO_None                       = 0,
+	IDO_On                         = 1,
+	IDO_Off                        = 2,
+	IDO_MAX                        = 3
+};
+
+
+
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// ScriptStruct ApexDestruction.FractureMaterial
+// 0x0024
+struct FFractureMaterial
+{
+	struct FVector2D                                   UVScale;                                                  // 0x0000(0x0008) (Edit, IsPlainOldData)
+	struct FVector2D                                   UVOffset;                                                 // 0x0008(0x0008) (Edit, IsPlainOldData)
+	struct FVector                                     Tangent;                                                  // 0x0010(0x000C) (Edit, IsPlainOldData)
+	float                                              UAngle;                                                   // 0x001C(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	int                                                InteriorElementIndex;                                     // 0x0020(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct ApexDestruction.DestructibleChunkParameters
+// 0x0004
+struct FDestructibleChunkParameters
+{
+	bool                                               bIsSupportChunk;                                          // 0x0000(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+	bool                                               bDoNotFracture;                                           // 0x0001(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+	bool                                               bDoNotDamage;                                             // 0x0002(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+	bool                                               bDoNotCrumble;                                            // 0x0003(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct ApexDestruction.DestructibleDamageParameters
+// 0x001C
+struct FDestructibleDamageParameters
+{
+	float                                              DamageThreshold;                                          // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	float                                              DamageSpread;                                             // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	bool                                               bEnableImpactDamage;                                      // 0x0008(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x0009(0x0003) MISSED OFFSET
+	float                                              ImpactDamage;                                             // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	int                                                DefaultImpactDamageDepth;                                 // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	bool                                               bCustomImpactResistance;                                  // 0x0014(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData01[0x3];                                       // 0x0015(0x0003) MISSED OFFSET
+	float                                              ImpactResistance;                                         // 0x0018(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct ApexDestruction.DestructibleDebrisParameters
+// 0x002C
+struct FDestructibleDebrisParameters
+{
+	float                                              DebrisLifetimeMin;                                        // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	float                                              DebrisLifetimeMax;                                        // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	float                                              DebrisMaxSeparationMin;                                   // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	float                                              DebrisMaxSeparationMax;                                   // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	struct FBox                                        ValidBounds;                                              // 0x0010(0x001C) (Edit, IsPlainOldData)
+};
+
+// ScriptStruct ApexDestruction.DestructibleAdvancedParameters
+// 0x0010
+struct FDestructibleAdvancedParameters
+{
+	float                                              DamageCap;                                                // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	float                                              ImpactVelocityThreshold;                                  // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	float                                              MaxChunkSpeed;                                            // 0x0008(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	float                                              FractureImpulseScale;                                     // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct ApexDestruction.DestructibleSpecialHierarchyDepths
+// 0x0014
+struct FDestructibleSpecialHierarchyDepths
+{
+	int                                                SupportDepth;                                             // 0x0000(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	int                                                MinimumFractureDepth;                                     // 0x0004(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	bool                                               bEnableDebris;                                            // 0x0008(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x0009(0x0003) MISSED OFFSET
+	int                                                DebrisDepth;                                              // 0x000C(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	int                                                EssentialDepth;                                           // 0x0010(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct ApexDestruction.DestructibleDepthParameters
+// 0x0001
+struct FDestructibleDepthParameters
+{
+	TEnumAsByte<EImpactDamageOverride>                 ImpactDamageOverride;                                     // 0x0000(0x0001) (Edit, ZeroConstructor, IsPlainOldData)
+};
+
+// ScriptStruct ApexDestruction.DestructibleParametersFlag
+// 0x0004
+struct FDestructibleParametersFlag
+{
+	unsigned char                                      bAccumulateDamage : 1;                                    // 0x0000(0x0001) (Edit)
+	unsigned char                                      bAssetDefinedSupport : 1;                                 // 0x0000(0x0001) (Edit)
+	unsigned char                                      bWorldSupport : 1;                                        // 0x0000(0x0001) (Edit)
+	unsigned char                                      bDebrisTimeout : 1;                                       // 0x0000(0x0001) (Edit)
+	unsigned char                                      bDebrisMaxSeparation : 1;                                 // 0x0000(0x0001) (Edit)
+	unsigned char                                      bCrumbleSmallestChunks : 1;                               // 0x0000(0x0001) (Edit)
+	unsigned char                                      bAccurateRaycasts : 1;                                    // 0x0000(0x0001) (Edit)
+	unsigned char                                      bUseValidBounds : 1;                                      // 0x0000(0x0001) (Edit)
+	unsigned char                                      bFormExtendedStructures : 1;                              // 0x0001(0x0001) (Edit)
+	unsigned char                                      UnknownData00[0x2];                                       // 0x0002(0x0002) MISSED OFFSET
+};
+
+// ScriptStruct ApexDestruction.DestructibleParameters
+// 0x007C
+struct FDestructibleParameters
+{
+	struct FDestructibleDamageParameters               DamageParameters;                                         // 0x0000(0x001C) (Edit)
+	struct FDestructibleDebrisParameters               DebrisParameters;                                         // 0x001C(0x002C) (Edit)
+	struct FDestructibleAdvancedParameters             AdvancedParameters;                                       // 0x0048(0x0010) (Edit)
+	struct FDestructibleSpecialHierarchyDepths         SpecialHierarchyDepths;                                   // 0x0058(0x0014) (Edit)
+	TArray<struct FDestructibleDepthParameters>        DepthParameters;                                          // 0x006C(0x000C) (Edit, EditFixedSize, ZeroConstructor)
+	struct FDestructibleParametersFlag                 Flags;                                                    // 0x0078(0x0004) (Edit)
+};
+
+}
+

结构体/数据/SDK/PUBGM_AssetRegistry_classes.hpp

@@ -0,0 +1,94 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Classes
+//---------------------------------------------------------------------------
+
+// Class AssetRegistry.AssetRegistryImpl
+// 0x0874 (0x0890 - 0x001C)
+class UAssetRegistryImpl : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0x874];                                     // 0x001C(0x0874) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AssetRegistry.AssetRegistryImpl");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AssetRegistry.AssetRegistryHelpers
+// 0x0004 (0x0020 - 0x001C)
+class UAssetRegistryHelpers : public UObject
+{
+public:
+	unsigned char                                      UnknownData00[0x4];                                       // 0x001C(0x0004) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AssetRegistry.AssetRegistryHelpers");
+		return pStaticClass;
+	}
+
+
+	static struct FSoftObjectPath ToSoftObjectPath(const struct FAssetData& InAssetData);
+	static struct FARFilter SetFilterTagsAndValues(const struct FARFilter& InFilter, TArray<struct FTagAndValue> InTagsAndValues);
+	static bool IsValid(const struct FAssetData& InAssetData);
+	static bool IsUAsset(const struct FAssetData& InAssetData);
+	static bool IsRedirector(const struct FAssetData& InAssetData);
+	static bool IsAssetLoaded(const struct FAssetData& InAssetData);
+	static bool GetTagValue(const struct FAssetData& InAssetData, const struct FName& InTagName, struct FString* OutTagValue);
+	static struct FString GetFullName(const struct FAssetData& InAssetData);
+	static struct FString GetExportTextName(const struct FAssetData& InAssetData);
+	static class UClass* GetClass(const struct FAssetData& InAssetData);
+	static TScriptInterface<class UAssetRegistry> GetAssetRegistry();
+	static class UObject* GetAsset(const struct FAssetData& InAssetData);
+	static struct FAssetData CreateAssetData(class UObject* InAsset, bool bAllowBlueprintClass);
+};
+
+
+// Class AssetRegistry.AssetRegistry
+// 0x0000 (0x0020 - 0x0020)
+class UAssetRegistry : public UInterface
+{
+public:
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AssetRegistry.AssetRegistry");
+		return pStaticClass;
+	}
+
+
+	void RunAssetsThroughFilter(const struct FARFilter& Filter, TArray<struct FAssetData>* AssetDataList);
+	bool IsLoadingAssets();
+	bool HasAssets(const struct FName& PackagePath, bool bRecursive);
+	void GetSubPaths(const struct FString& InBasePath, bool bInRecurse, TArray<struct FString>* OutPathList);
+	bool GetAssetsByPath(const struct FName& PackagePath, bool bRecursive, bool bIncludeOnlyOnDiskAssets, TArray<struct FAssetData>* OutAssetData);
+	bool GetAssetsByPackageName(const struct FName& PackageName, bool bIncludeOnlyOnDiskAssets, TArray<struct FAssetData>* OutAssetData);
+	bool GetAssetsByClass(const struct FName& ClassName, bool bSearchSubClasses, TArray<struct FAssetData>* OutAssetData);
+	bool GetAssets(const struct FARFilter& Filter, TArray<struct FAssetData>* OutAssetData);
+	struct FAssetData GetAssetByObjectPath(const struct FName& ObjectPath, bool bIncludeOnlyOnDiskAssets);
+	void GetAllCachedPaths(TArray<struct FString>* OutPathList);
+	bool GetAllAssets(bool bIncludeOnlyOnDiskAssets, TArray<struct FAssetData>* OutAssetData);
+};
+
+
+}
+

结构体/数据/SDK/PUBGM_AssetRegistry_functions.cpp

@@ -0,0 +1,704 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+// Function AssetRegistry.AssetRegistryHelpers.ToSoftObjectPath
+// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
+// Parameters:
+// struct FAssetData              InAssetData                    (ConstParm, Parm, OutParm, ReferenceParm)
+// struct FSoftObjectPath         ReturnValue                    (Parm, OutParm, ReturnParm)
+
+struct FSoftObjectPath UAssetRegistryHelpers::ToSoftObjectPath(const struct FAssetData& InAssetData)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistryHelpers.ToSoftObjectPath");
+
+	UAssetRegistryHelpers_ToSoftObjectPath_Params params;
+	params.InAssetData = InAssetData;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistryHelpers.SetFilterTagsAndValues
+// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
+// Parameters:
+// struct FARFilter               InFilter                       (ConstParm, Parm, OutParm, ReferenceParm)
+// TArray<struct FTagAndValue>    InTagsAndValues                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
+// struct FARFilter               ReturnValue                    (Parm, OutParm, ReturnParm)
+
+struct FARFilter UAssetRegistryHelpers::SetFilterTagsAndValues(const struct FARFilter& InFilter, TArray<struct FTagAndValue> InTagsAndValues)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistryHelpers.SetFilterTagsAndValues");
+
+	UAssetRegistryHelpers_SetFilterTagsAndValues_Params params;
+	params.InFilter = InFilter;
+	params.InTagsAndValues = InTagsAndValues;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistryHelpers.IsValid
+// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
+// Parameters:
+// struct FAssetData              InAssetData                    (ConstParm, Parm, OutParm, ReferenceParm)
+// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+bool UAssetRegistryHelpers::IsValid(const struct FAssetData& InAssetData)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistryHelpers.IsValid");
+
+	UAssetRegistryHelpers_IsValid_Params params;
+	params.InAssetData = InAssetData;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistryHelpers.IsUAsset
+// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
+// Parameters:
+// struct FAssetData              InAssetData                    (ConstParm, Parm, OutParm, ReferenceParm)
+// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+bool UAssetRegistryHelpers::IsUAsset(const struct FAssetData& InAssetData)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistryHelpers.IsUAsset");
+
+	UAssetRegistryHelpers_IsUAsset_Params params;
+	params.InAssetData = InAssetData;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistryHelpers.IsRedirector
+// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
+// Parameters:
+// struct FAssetData              InAssetData                    (ConstParm, Parm, OutParm, ReferenceParm)
+// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+bool UAssetRegistryHelpers::IsRedirector(const struct FAssetData& InAssetData)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistryHelpers.IsRedirector");
+
+	UAssetRegistryHelpers_IsRedirector_Params params;
+	params.InAssetData = InAssetData;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistryHelpers.IsAssetLoaded
+// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
+// Parameters:
+// struct FAssetData              InAssetData                    (ConstParm, Parm, OutParm, ReferenceParm)
+// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+bool UAssetRegistryHelpers::IsAssetLoaded(const struct FAssetData& InAssetData)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistryHelpers.IsAssetLoaded");
+
+	UAssetRegistryHelpers_IsAssetLoaded_Params params;
+	params.InAssetData = InAssetData;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistryHelpers.GetTagValue
+// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
+// Parameters:
+// struct FAssetData              InAssetData                    (ConstParm, Parm, OutParm, ReferenceParm)
+// struct FName                   InTagName                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
+// struct FString                 OutTagValue                    (Parm, OutParm, ZeroConstructor)
+// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+bool UAssetRegistryHelpers::GetTagValue(const struct FAssetData& InAssetData, const struct FName& InTagName, struct FString* OutTagValue)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistryHelpers.GetTagValue");
+
+	UAssetRegistryHelpers_GetTagValue_Params params;
+	params.InAssetData = InAssetData;
+	params.InTagName = InTagName;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	if (OutTagValue != nullptr)
+		*OutTagValue = params.OutTagValue;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistryHelpers.GetFullName
+// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
+// Parameters:
+// struct FAssetData              InAssetData                    (ConstParm, Parm, OutParm, ReferenceParm)
+// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)
+
+struct FString UAssetRegistryHelpers::GetFullName(const struct FAssetData& InAssetData)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistryHelpers.GetFullName");
+
+	UAssetRegistryHelpers_GetFullName_Params params;
+	params.InAssetData = InAssetData;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistryHelpers.GetExportTextName
+// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
+// Parameters:
+// struct FAssetData              InAssetData                    (ConstParm, Parm, OutParm, ReferenceParm)
+// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)
+
+struct FString UAssetRegistryHelpers::GetExportTextName(const struct FAssetData& InAssetData)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistryHelpers.GetExportTextName");
+
+	UAssetRegistryHelpers_GetExportTextName_Params params;
+	params.InAssetData = InAssetData;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistryHelpers.GetClass
+// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
+// Parameters:
+// struct FAssetData              InAssetData                    (ConstParm, Parm, OutParm, ReferenceParm)
+// class UClass*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+class UClass* UAssetRegistryHelpers::GetClass(const struct FAssetData& InAssetData)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistryHelpers.GetClass");
+
+	UAssetRegistryHelpers_GetClass_Params params;
+	params.InAssetData = InAssetData;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistryHelpers.GetAssetRegistry
+// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
+// Parameters:
+// TScriptInterface<class UAssetRegistry> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+TScriptInterface<class UAssetRegistry> UAssetRegistryHelpers::GetAssetRegistry()
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistryHelpers.GetAssetRegistry");
+
+	UAssetRegistryHelpers_GetAssetRegistry_Params params;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistryHelpers.GetAsset
+// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
+// Parameters:
+// struct FAssetData              InAssetData                    (ConstParm, Parm, OutParm, ReferenceParm)
+// class UObject*                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+class UObject* UAssetRegistryHelpers::GetAsset(const struct FAssetData& InAssetData)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistryHelpers.GetAsset");
+
+	UAssetRegistryHelpers_GetAsset_Params params;
+	params.InAssetData = InAssetData;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistryHelpers.CreateAssetData
+// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
+// Parameters:
+// class UObject*                 InAsset                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+// bool                           bAllowBlueprintClass           (Parm, ZeroConstructor, IsPlainOldData)
+// struct FAssetData              ReturnValue                    (Parm, OutParm, ReturnParm)
+
+struct FAssetData UAssetRegistryHelpers::CreateAssetData(class UObject* InAsset, bool bAllowBlueprintClass)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistryHelpers.CreateAssetData");
+
+	UAssetRegistryHelpers_CreateAssetData_Params params;
+	params.InAsset = InAsset;
+	params.bAllowBlueprintClass = bAllowBlueprintClass;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistry.RunAssetsThroughFilter
+// (Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
+// Parameters:
+// TArray<struct FAssetData>      AssetDataList                  (Parm, OutParm, ZeroConstructor)
+// struct FARFilter               Filter                         (ConstParm, Parm, OutParm, ReferenceParm)
+
+void UAssetRegistry::RunAssetsThroughFilter(const struct FARFilter& Filter, TArray<struct FAssetData>* AssetDataList)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistry.RunAssetsThroughFilter");
+
+	UAssetRegistry_RunAssetsThroughFilter_Params params;
+	params.Filter = Filter;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	if (AssetDataList != nullptr)
+		*AssetDataList = params.AssetDataList;
+}
+
+
+// Function AssetRegistry.AssetRegistry.IsLoadingAssets
+// (Native, Public, BlueprintCallable, BlueprintPure, Const)
+// Parameters:
+// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+bool UAssetRegistry::IsLoadingAssets()
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistry.IsLoadingAssets");
+
+	UAssetRegistry_IsLoadingAssets_Params params;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistry.HasAssets
+// (Native, Public, BlueprintCallable, BlueprintPure, Const)
+// Parameters:
+// struct FName                   PackagePath                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+// bool                           bRecursive                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+bool UAssetRegistry::HasAssets(const struct FName& PackagePath, bool bRecursive)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistry.HasAssets");
+
+	UAssetRegistry_HasAssets_Params params;
+	params.PackagePath = PackagePath;
+	params.bRecursive = bRecursive;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistry.GetSubPaths
+// (Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
+// Parameters:
+// struct FString                 InBasePath                     (Parm, ZeroConstructor)
+// TArray<struct FString>         OutPathList                    (Parm, OutParm, ZeroConstructor)
+// bool                           bInRecurse                     (Parm, ZeroConstructor, IsPlainOldData)
+
+void UAssetRegistry::GetSubPaths(const struct FString& InBasePath, bool bInRecurse, TArray<struct FString>* OutPathList)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistry.GetSubPaths");
+
+	UAssetRegistry_GetSubPaths_Params params;
+	params.InBasePath = InBasePath;
+	params.bInRecurse = bInRecurse;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	if (OutPathList != nullptr)
+		*OutPathList = params.OutPathList;
+}
+
+
+// Function AssetRegistry.AssetRegistry.GetAssetsByPath
+// (Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
+// Parameters:
+// struct FName                   PackagePath                    (Parm, ZeroConstructor, IsPlainOldData)
+// TArray<struct FAssetData>      OutAssetData                   (Parm, OutParm, ZeroConstructor)
+// bool                           bRecursive                     (Parm, ZeroConstructor, IsPlainOldData)
+// bool                           bIncludeOnlyOnDiskAssets       (Parm, ZeroConstructor, IsPlainOldData)
+// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+bool UAssetRegistry::GetAssetsByPath(const struct FName& PackagePath, bool bRecursive, bool bIncludeOnlyOnDiskAssets, TArray<struct FAssetData>* OutAssetData)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistry.GetAssetsByPath");
+
+	UAssetRegistry_GetAssetsByPath_Params params;
+	params.PackagePath = PackagePath;
+	params.bRecursive = bRecursive;
+	params.bIncludeOnlyOnDiskAssets = bIncludeOnlyOnDiskAssets;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	if (OutAssetData != nullptr)
+		*OutAssetData = params.OutAssetData;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistry.GetAssetsByPackageName
+// (Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
+// Parameters:
+// struct FName                   PackageName                    (Parm, ZeroConstructor, IsPlainOldData)
+// TArray<struct FAssetData>      OutAssetData                   (Parm, OutParm, ZeroConstructor)
+// bool                           bIncludeOnlyOnDiskAssets       (Parm, ZeroConstructor, IsPlainOldData)
+// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+bool UAssetRegistry::GetAssetsByPackageName(const struct FName& PackageName, bool bIncludeOnlyOnDiskAssets, TArray<struct FAssetData>* OutAssetData)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistry.GetAssetsByPackageName");
+
+	UAssetRegistry_GetAssetsByPackageName_Params params;
+	params.PackageName = PackageName;
+	params.bIncludeOnlyOnDiskAssets = bIncludeOnlyOnDiskAssets;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	if (OutAssetData != nullptr)
+		*OutAssetData = params.OutAssetData;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistry.GetAssetsByClass
+// (Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
+// Parameters:
+// struct FName                   ClassName                      (Parm, ZeroConstructor, IsPlainOldData)
+// TArray<struct FAssetData>      OutAssetData                   (Parm, OutParm, ZeroConstructor)
+// bool                           bSearchSubClasses              (Parm, ZeroConstructor, IsPlainOldData)
+// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+bool UAssetRegistry::GetAssetsByClass(const struct FName& ClassName, bool bSearchSubClasses, TArray<struct FAssetData>* OutAssetData)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistry.GetAssetsByClass");
+
+	UAssetRegistry_GetAssetsByClass_Params params;
+	params.ClassName = ClassName;
+	params.bSearchSubClasses = bSearchSubClasses;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	if (OutAssetData != nullptr)
+		*OutAssetData = params.OutAssetData;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistry.GetAssets
+// (Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
+// Parameters:
+// struct FARFilter               Filter                         (ConstParm, Parm, OutParm, ReferenceParm)
+// TArray<struct FAssetData>      OutAssetData                   (Parm, OutParm, ZeroConstructor)
+// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+bool UAssetRegistry::GetAssets(const struct FARFilter& Filter, TArray<struct FAssetData>* OutAssetData)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistry.GetAssets");
+
+	UAssetRegistry_GetAssets_Params params;
+	params.Filter = Filter;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	if (OutAssetData != nullptr)
+		*OutAssetData = params.OutAssetData;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistry.GetAssetByObjectPath
+// (Native, Public, BlueprintCallable, BlueprintPure, Const)
+// Parameters:
+// struct FName                   ObjectPath                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+// bool                           bIncludeOnlyOnDiskAssets       (Parm, ZeroConstructor, IsPlainOldData)
+// struct FAssetData              ReturnValue                    (Parm, OutParm, ReturnParm)
+
+struct FAssetData UAssetRegistry::GetAssetByObjectPath(const struct FName& ObjectPath, bool bIncludeOnlyOnDiskAssets)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistry.GetAssetByObjectPath");
+
+	UAssetRegistry_GetAssetByObjectPath_Params params;
+	params.ObjectPath = ObjectPath;
+	params.bIncludeOnlyOnDiskAssets = bIncludeOnlyOnDiskAssets;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AssetRegistry.AssetRegistry.GetAllCachedPaths
+// (Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
+// Parameters:
+// TArray<struct FString>         OutPathList                    (Parm, OutParm, ZeroConstructor)
+
+void UAssetRegistry::GetAllCachedPaths(TArray<struct FString>* OutPathList)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistry.GetAllCachedPaths");
+
+	UAssetRegistry_GetAllCachedPaths_Params params;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	if (OutPathList != nullptr)
+		*OutPathList = params.OutPathList;
+}
+
+
+// Function AssetRegistry.AssetRegistry.GetAllAssets
+// (Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
+// Parameters:
+// TArray<struct FAssetData>      OutAssetData                   (Parm, OutParm, ZeroConstructor)
+// bool                           bIncludeOnlyOnDiskAssets       (Parm, ZeroConstructor, IsPlainOldData)
+// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+bool UAssetRegistry::GetAllAssets(bool bIncludeOnlyOnDiskAssets, TArray<struct FAssetData>* OutAssetData)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AssetRegistry.AssetRegistry.GetAllAssets");
+
+	UAssetRegistry_GetAllAssets_Params params;
+	params.bIncludeOnlyOnDiskAssets = bIncludeOnlyOnDiskAssets;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	if (OutAssetData != nullptr)
+		*OutAssetData = params.OutAssetData;
+
+	return params.ReturnValue;
+}
+
+
+}
+

结构体/数据/SDK/PUBGM_AssetRegistry_parameters.hpp

@@ -0,0 +1,198 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+// Function AssetRegistry.AssetRegistryHelpers.ToSoftObjectPath
+struct UAssetRegistryHelpers_ToSoftObjectPath_Params
+{
+	struct FAssetData                                  InAssetData;                                              // (ConstParm, Parm, OutParm, ReferenceParm)
+	struct FSoftObjectPath                             ReturnValue;                                              // (Parm, OutParm, ReturnParm)
+};
+
+// Function AssetRegistry.AssetRegistryHelpers.SetFilterTagsAndValues
+struct UAssetRegistryHelpers_SetFilterTagsAndValues_Params
+{
+	struct FARFilter                                   InFilter;                                                 // (ConstParm, Parm, OutParm, ReferenceParm)
+	TArray<struct FTagAndValue>                        InTagsAndValues;                                          // (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
+	struct FARFilter                                   ReturnValue;                                              // (Parm, OutParm, ReturnParm)
+};
+
+// Function AssetRegistry.AssetRegistryHelpers.IsValid
+struct UAssetRegistryHelpers_IsValid_Params
+{
+	struct FAssetData                                  InAssetData;                                              // (ConstParm, Parm, OutParm, ReferenceParm)
+	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AssetRegistry.AssetRegistryHelpers.IsUAsset
+struct UAssetRegistryHelpers_IsUAsset_Params
+{
+	struct FAssetData                                  InAssetData;                                              // (ConstParm, Parm, OutParm, ReferenceParm)
+	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AssetRegistry.AssetRegistryHelpers.IsRedirector
+struct UAssetRegistryHelpers_IsRedirector_Params
+{
+	struct FAssetData                                  InAssetData;                                              // (ConstParm, Parm, OutParm, ReferenceParm)
+	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AssetRegistry.AssetRegistryHelpers.IsAssetLoaded
+struct UAssetRegistryHelpers_IsAssetLoaded_Params
+{
+	struct FAssetData                                  InAssetData;                                              // (ConstParm, Parm, OutParm, ReferenceParm)
+	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AssetRegistry.AssetRegistryHelpers.GetTagValue
+struct UAssetRegistryHelpers_GetTagValue_Params
+{
+	struct FAssetData                                  InAssetData;                                              // (ConstParm, Parm, OutParm, ReferenceParm)
+	struct FName                                       InTagName;                                                // (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
+	struct FString                                     OutTagValue;                                              // (Parm, OutParm, ZeroConstructor)
+	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AssetRegistry.AssetRegistryHelpers.GetFullName
+struct UAssetRegistryHelpers_GetFullName_Params
+{
+	struct FAssetData                                  InAssetData;                                              // (ConstParm, Parm, OutParm, ReferenceParm)
+	struct FString                                     ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
+};
+
+// Function AssetRegistry.AssetRegistryHelpers.GetExportTextName
+struct UAssetRegistryHelpers_GetExportTextName_Params
+{
+	struct FAssetData                                  InAssetData;                                              // (ConstParm, Parm, OutParm, ReferenceParm)
+	struct FString                                     ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
+};
+
+// Function AssetRegistry.AssetRegistryHelpers.GetClass
+struct UAssetRegistryHelpers_GetClass_Params
+{
+	struct FAssetData                                  InAssetData;                                              // (ConstParm, Parm, OutParm, ReferenceParm)
+	class UClass*                                      ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AssetRegistry.AssetRegistryHelpers.GetAssetRegistry
+struct UAssetRegistryHelpers_GetAssetRegistry_Params
+{
+	TScriptInterface<class UAssetRegistry>             ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AssetRegistry.AssetRegistryHelpers.GetAsset
+struct UAssetRegistryHelpers_GetAsset_Params
+{
+	struct FAssetData                                  InAssetData;                                              // (ConstParm, Parm, OutParm, ReferenceParm)
+	class UObject*                                     ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AssetRegistry.AssetRegistryHelpers.CreateAssetData
+struct UAssetRegistryHelpers_CreateAssetData_Params
+{
+	class UObject*                                     InAsset;                                                  // (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               bAllowBlueprintClass;                                     // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FAssetData                                  ReturnValue;                                              // (Parm, OutParm, ReturnParm)
+};
+
+// Function AssetRegistry.AssetRegistry.RunAssetsThroughFilter
+struct UAssetRegistry_RunAssetsThroughFilter_Params
+{
+	TArray<struct FAssetData>                          AssetDataList;                                            // (Parm, OutParm, ZeroConstructor)
+	struct FARFilter                                   Filter;                                                   // (ConstParm, Parm, OutParm, ReferenceParm)
+};
+
+// Function AssetRegistry.AssetRegistry.IsLoadingAssets
+struct UAssetRegistry_IsLoadingAssets_Params
+{
+	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AssetRegistry.AssetRegistry.HasAssets
+struct UAssetRegistry_HasAssets_Params
+{
+	struct FName                                       PackagePath;                                              // (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               bRecursive;                                               // (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AssetRegistry.AssetRegistry.GetSubPaths
+struct UAssetRegistry_GetSubPaths_Params
+{
+	struct FString                                     InBasePath;                                               // (Parm, ZeroConstructor)
+	TArray<struct FString>                             OutPathList;                                              // (Parm, OutParm, ZeroConstructor)
+	bool                                               bInRecurse;                                               // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AssetRegistry.AssetRegistry.GetAssetsByPath
+struct UAssetRegistry_GetAssetsByPath_Params
+{
+	struct FName                                       PackagePath;                                              // (Parm, ZeroConstructor, IsPlainOldData)
+	TArray<struct FAssetData>                          OutAssetData;                                             // (Parm, OutParm, ZeroConstructor)
+	bool                                               bRecursive;                                               // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               bIncludeOnlyOnDiskAssets;                                 // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AssetRegistry.AssetRegistry.GetAssetsByPackageName
+struct UAssetRegistry_GetAssetsByPackageName_Params
+{
+	struct FName                                       PackageName;                                              // (Parm, ZeroConstructor, IsPlainOldData)
+	TArray<struct FAssetData>                          OutAssetData;                                             // (Parm, OutParm, ZeroConstructor)
+	bool                                               bIncludeOnlyOnDiskAssets;                                 // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AssetRegistry.AssetRegistry.GetAssetsByClass
+struct UAssetRegistry_GetAssetsByClass_Params
+{
+	struct FName                                       ClassName;                                                // (Parm, ZeroConstructor, IsPlainOldData)
+	TArray<struct FAssetData>                          OutAssetData;                                             // (Parm, OutParm, ZeroConstructor)
+	bool                                               bSearchSubClasses;                                        // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AssetRegistry.AssetRegistry.GetAssets
+struct UAssetRegistry_GetAssets_Params
+{
+	struct FARFilter                                   Filter;                                                   // (ConstParm, Parm, OutParm, ReferenceParm)
+	TArray<struct FAssetData>                          OutAssetData;                                             // (Parm, OutParm, ZeroConstructor)
+	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AssetRegistry.AssetRegistry.GetAssetByObjectPath
+struct UAssetRegistry_GetAssetByObjectPath_Params
+{
+	struct FName                                       ObjectPath;                                               // (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               bIncludeOnlyOnDiskAssets;                                 // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FAssetData                                  ReturnValue;                                              // (Parm, OutParm, ReturnParm)
+};
+
+// Function AssetRegistry.AssetRegistry.GetAllCachedPaths
+struct UAssetRegistry_GetAllCachedPaths_Params
+{
+	TArray<struct FString>                             OutPathList;                                              // (Parm, OutParm, ZeroConstructor)
+};
+
+// Function AssetRegistry.AssetRegistry.GetAllAssets
+struct UAssetRegistry_GetAllAssets_Params
+{
+	TArray<struct FAssetData>                          OutAssetData;                                             // (Parm, OutParm, ZeroConstructor)
+	bool                                               bIncludeOnlyOnDiskAssets;                                 // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+}
+

结构体/数据/SDK/PUBGM_AssetRegistry_structs.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// ScriptStruct AssetRegistry.AssetData
+// 0x0040
+struct FAssetData
+{
+	struct FName                                       ObjectPath;                                               // 0x0000(0x0008) (BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, IsPlainOldData)
+	struct FName                                       PackageName;                                              // 0x0008(0x0008) (BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, IsPlainOldData)
+	struct FName                                       PackagePath;                                              // 0x0010(0x0008) (BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, IsPlainOldData)
+	struct FName                                       AssetName;                                                // 0x0018(0x0008) (BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, IsPlainOldData)
+	struct FName                                       AssetClass;                                               // 0x0020(0x0008) (BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x18];                                      // 0x0028(0x0018) MISSED OFFSET
+};
+
+// ScriptStruct AssetRegistry.ARFilter
+// 0x00AC
+struct FARFilter
+{
+	TArray<struct FName>                               PackageNames;                                             // 0x0000(0x000C) (BlueprintVisible, ZeroConstructor, Transient)
+	TArray<struct FName>                               PackagePaths;                                             // 0x000C(0x000C) (BlueprintVisible, ZeroConstructor, Transient)
+	TArray<struct FName>                               ObjectPaths;                                              // 0x0018(0x000C) (BlueprintVisible, ZeroConstructor, Transient)
+	TArray<struct FName>                               ClassNames;                                               // 0x0024(0x000C) (BlueprintVisible, ZeroConstructor, Transient)
+	unsigned char                                      UnknownData00[0x3C];                                      // 0x0030(0x003C) MISSED OFFSET
+	unsigned char                                      UnknownData01[0x3C];                                      // 0x0030(0x003C) UNKNOWN PROPERTY: SetProperty AssetRegistry.ARFilter.RecursiveClassesExclusionSet
+	bool                                               bRecursivePaths;                                          // 0x00A8(0x0001) (BlueprintVisible, ZeroConstructor, Transient, IsPlainOldData)
+	bool                                               bRecursiveClasses;                                        // 0x00A9(0x0001) (BlueprintVisible, ZeroConstructor, Transient, IsPlainOldData)
+	bool                                               bIncludeOnlyOnDiskAssets;                                 // 0x00AA(0x0001) (BlueprintVisible, ZeroConstructor, Transient, IsPlainOldData)
+	unsigned char                                      UnknownData02[0x1];                                       // 0x00AB(0x0001) MISSED OFFSET
+};
+
+// ScriptStruct AssetRegistry.TagAndValue
+// 0x0018
+struct FTagAndValue
+{
+	struct FName                                       Tag;                                                      // 0x0000(0x0008) (BlueprintVisible, ZeroConstructor, Transient, IsPlainOldData)
+	struct FString                                     Value;                                                    // 0x0008(0x000C) (BlueprintVisible, ZeroConstructor, Transient)
+	unsigned char                                      UnknownData00[0x4];                                       // 0x0014(0x0004) MISSED OFFSET
+};
+
+// ScriptStruct AssetRegistry.AssetBundleEntry
+// 0x0028
+struct FAssetBundleEntry
+{
+	struct FPrimaryAssetId                             BundleScope;                                              // 0x0000(0x0010)
+	struct FName                                       BundleName;                                               // 0x0010(0x0008) (ZeroConstructor, IsPlainOldData)
+	TArray<struct FSoftObjectPath>                     BundleAssets;                                             // 0x0018(0x000C) (ZeroConstructor)
+	unsigned char                                      UnknownData00[0x4];                                       // 0x0024(0x0004) MISSED OFFSET
+};
+
+// ScriptStruct AssetRegistry.AssetBundleData
+// 0x000C
+struct FAssetBundleData
+{
+	TArray<struct FAssetBundleEntry>                   Bundles;                                                  // 0x0000(0x000C) (ZeroConstructor)
+};
+
+}
+

结构体/数据/SDK/PUBGM_AudioMixer_classes.hpp

@@ -0,0 +1,161 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Classes
+//---------------------------------------------------------------------------
+
+// Class AudioMixer.AudioMixerBlueprintLibrary
+// 0x0000 (0x0020 - 0x0020)
+class UAudioMixerBlueprintLibrary : public UBlueprintFunctionLibrary
+{
+public:
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AudioMixer.AudioMixerBlueprintLibrary");
+		return pStaticClass;
+	}
+
+
+	static void SetBypassSourceEffectChainEntry(class UObject* WorldContextObject, class USoundEffectSourcePresetChain* PresetChain, int EntryIndex, bool bBypassed);
+	static void RemoveSourceEffectFromPresetChain(class UObject* WorldContextObject, class USoundEffectSourcePresetChain* PresetChain, int EntryIndex);
+	static void RemoveMasterSubmixEffect(class UObject* WorldContextObject, class USoundEffectSubmixPreset* SubmixEffectPreset);
+	static int GetNumberOfEntriesInSourceEffectChain(class UObject* WorldContextObject, class USoundEffectSourcePresetChain* PresetChain);
+	static void ClearMasterSubmixEffects(class UObject* WorldContextObject);
+	static void AddSourceEffectToPresetChain(class UObject* WorldContextObject, class USoundEffectSourcePresetChain* PresetChain, const struct FSourceEffectChainEntry& Entry);
+	static void AddMasterSubmixEffect(class UObject* WorldContextObject, class USoundEffectSubmixPreset* SubmixEffectPreset);
+};
+
+
+// Class AudioMixer.SubmixEffectDynamicsProcessorPreset
+// 0x0050 (0x0080 - 0x0030)
+class USubmixEffectDynamicsProcessorPreset : public USoundEffectSubmixPreset
+{
+public:
+	unsigned char                                      UnknownData00[0x28];                                      // 0x0030(0x0028) MISSED OFFSET
+	struct FSubmixEffectDynamicsProcessorSettings      Settings;                                                 // 0x0058(0x0028) (Edit, BlueprintVisible)
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AudioMixer.SubmixEffectDynamicsProcessorPreset");
+		return pStaticClass;
+	}
+
+
+	void SetSettings(const struct FSubmixEffectDynamicsProcessorSettings& InSettings);
+};
+
+
+// Class AudioMixer.SubmixEffectSubmixEQPreset
+// 0x0018 (0x0048 - 0x0030)
+class USubmixEffectSubmixEQPreset : public USoundEffectSubmixPreset
+{
+public:
+	unsigned char                                      UnknownData00[0xC];                                       // 0x0030(0x000C) MISSED OFFSET
+	struct FSubmixEffectSubmixEQSettings               Settings;                                                 // 0x003C(0x000C) (Edit, BlueprintVisible)
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AudioMixer.SubmixEffectSubmixEQPreset");
+		return pStaticClass;
+	}
+
+
+	void SetSettings(const struct FSubmixEffectSubmixEQSettings& InSettings);
+};
+
+
+// Class AudioMixer.SubmixEffectReverbPreset
+// 0x0060 (0x0090 - 0x0030)
+class USubmixEffectReverbPreset : public USoundEffectSubmixPreset
+{
+public:
+	unsigned char                                      UnknownData00[0x30];                                      // 0x0030(0x0030) MISSED OFFSET
+	struct FSubmixEffectReverbSettings                 Settings;                                                 // 0x0060(0x0030) (Edit, BlueprintVisible)
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AudioMixer.SubmixEffectReverbPreset");
+		return pStaticClass;
+	}
+
+
+	void SetSettingsWithReverbEffect(class UReverbEffect* InReverbEffect, float WetLevel);
+	void SetSettings(const struct FSubmixEffectReverbSettings& InSettings);
+};
+
+
+// Class AudioMixer.SynthSound
+// 0x0010 (0x0260 - 0x0250)
+class USynthSound : public USoundWaveProcedural
+{
+public:
+	unsigned char                                      UnknownData00[0x10];                                      // 0x0250(0x0010) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AudioMixer.SynthSound");
+		return pStaticClass;
+	}
+
+};
+
+
+// Class AudioMixer.SynthComponent
+// 0x0270 (0x0530 - 0x02C0)
+class USynthComponent : public USceneComponent
+{
+public:
+	unsigned char                                      bAutoDestroy : 1;                                         // 0x02C0(0x0001)
+	unsigned char                                      bStopWhenOwnerDestroyed : 1;                              // 0x02C0(0x0001)
+	unsigned char                                      bAllowSpatialization : 1;                                 // 0x02C0(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      bOverrideAttenuation : 1;                                 // 0x02C0(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x02C1(0x0003) MISSED OFFSET
+	class USoundAttenuation*                           AttenuationSettings;                                      // 0x02C4(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	struct FSoundAttenuationSettings                   AttenuationOverrides;                                     // 0x02C8(0x0214) (Edit, BlueprintVisible)
+	class USoundConcurrency*                           ConcurrencySettings;                                      // 0x04DC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	class USoundClass*                                 SoundClass;                                               // 0x04E0(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	class USoundEffectSourcePresetChain*               SourceEffectChain;                                        // 0x04E4(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	class USoundSubmix*                                SoundSubmix;                                              // 0x04E8(0x0004) (Edit, ZeroConstructor, IsPlainOldData)
+	TArray<struct FSoundSubmixSendInfo>                SoundSubmixSends;                                         // 0x04EC(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	unsigned char                                      bIsUISound : 1;                                           // 0x04F8(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      UnknownData01[0x7];                                       // 0x04F9(0x0007) MISSED OFFSET
+	class USynthSound*                                 Synth;                                                    // 0x0500(0x0004) (ZeroConstructor, Transient, IsPlainOldData)
+	class UAudioComponent*                             AudioComponent;                                           // 0x0504(0x0004) (ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData)
+	unsigned char                                      UnknownData02[0x28];                                      // 0x0508(0x0028) MISSED OFFSET
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("Class AudioMixer.SynthComponent");
+		return pStaticClass;
+	}
+
+
+	void Stop();
+	void Start();
+	void SetSubmixSend(class USoundSubmix* Submix, float SendLevel);
+	bool IsPlaying();
+};
+
+
+}
+

结构体/数据/SDK/PUBGM_AudioMixer_functions.cpp

@@ -0,0 +1,397 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+// Function AudioMixer.AudioMixerBlueprintLibrary.SetBypassSourceEffectChainEntry
+// (Final, Native, Static, Public, BlueprintCallable)
+// Parameters:
+// class UObject*                 WorldContextObject             (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+// class USoundEffectSourcePresetChain* PresetChain                    (Parm, ZeroConstructor, IsPlainOldData)
+// int                            EntryIndex                     (Parm, ZeroConstructor, IsPlainOldData)
+// bool                           bBypassed                      (Parm, ZeroConstructor, IsPlainOldData)
+
+void UAudioMixerBlueprintLibrary::SetBypassSourceEffectChainEntry(class UObject* WorldContextObject, class USoundEffectSourcePresetChain* PresetChain, int EntryIndex, bool bBypassed)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AudioMixer.AudioMixerBlueprintLibrary.SetBypassSourceEffectChainEntry");
+
+	UAudioMixerBlueprintLibrary_SetBypassSourceEffectChainEntry_Params params;
+	params.WorldContextObject = WorldContextObject;
+	params.PresetChain = PresetChain;
+	params.EntryIndex = EntryIndex;
+	params.bBypassed = bBypassed;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AudioMixer.AudioMixerBlueprintLibrary.RemoveSourceEffectFromPresetChain
+// (Final, Native, Static, Public, BlueprintCallable)
+// Parameters:
+// class UObject*                 WorldContextObject             (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+// class USoundEffectSourcePresetChain* PresetChain                    (Parm, ZeroConstructor, IsPlainOldData)
+// int                            EntryIndex                     (Parm, ZeroConstructor, IsPlainOldData)
+
+void UAudioMixerBlueprintLibrary::RemoveSourceEffectFromPresetChain(class UObject* WorldContextObject, class USoundEffectSourcePresetChain* PresetChain, int EntryIndex)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AudioMixer.AudioMixerBlueprintLibrary.RemoveSourceEffectFromPresetChain");
+
+	UAudioMixerBlueprintLibrary_RemoveSourceEffectFromPresetChain_Params params;
+	params.WorldContextObject = WorldContextObject;
+	params.PresetChain = PresetChain;
+	params.EntryIndex = EntryIndex;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AudioMixer.AudioMixerBlueprintLibrary.RemoveMasterSubmixEffect
+// (Final, Native, Static, Public, BlueprintCallable)
+// Parameters:
+// class UObject*                 WorldContextObject             (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+// class USoundEffectSubmixPreset* SubmixEffectPreset             (Parm, ZeroConstructor, IsPlainOldData)
+
+void UAudioMixerBlueprintLibrary::RemoveMasterSubmixEffect(class UObject* WorldContextObject, class USoundEffectSubmixPreset* SubmixEffectPreset)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AudioMixer.AudioMixerBlueprintLibrary.RemoveMasterSubmixEffect");
+
+	UAudioMixerBlueprintLibrary_RemoveMasterSubmixEffect_Params params;
+	params.WorldContextObject = WorldContextObject;
+	params.SubmixEffectPreset = SubmixEffectPreset;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AudioMixer.AudioMixerBlueprintLibrary.GetNumberOfEntriesInSourceEffectChain
+// (Final, Native, Static, Public, BlueprintCallable)
+// Parameters:
+// class UObject*                 WorldContextObject             (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+// class USoundEffectSourcePresetChain* PresetChain                    (Parm, ZeroConstructor, IsPlainOldData)
+// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+int UAudioMixerBlueprintLibrary::GetNumberOfEntriesInSourceEffectChain(class UObject* WorldContextObject, class USoundEffectSourcePresetChain* PresetChain)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AudioMixer.AudioMixerBlueprintLibrary.GetNumberOfEntriesInSourceEffectChain");
+
+	UAudioMixerBlueprintLibrary_GetNumberOfEntriesInSourceEffectChain_Params params;
+	params.WorldContextObject = WorldContextObject;
+	params.PresetChain = PresetChain;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+// Function AudioMixer.AudioMixerBlueprintLibrary.ClearMasterSubmixEffects
+// (Final, Native, Static, Public, BlueprintCallable)
+// Parameters:
+// class UObject*                 WorldContextObject             (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+
+void UAudioMixerBlueprintLibrary::ClearMasterSubmixEffects(class UObject* WorldContextObject)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AudioMixer.AudioMixerBlueprintLibrary.ClearMasterSubmixEffects");
+
+	UAudioMixerBlueprintLibrary_ClearMasterSubmixEffects_Params params;
+	params.WorldContextObject = WorldContextObject;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AudioMixer.AudioMixerBlueprintLibrary.AddSourceEffectToPresetChain
+// (Final, Native, Static, Public, BlueprintCallable)
+// Parameters:
+// class UObject*                 WorldContextObject             (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+// class USoundEffectSourcePresetChain* PresetChain                    (Parm, ZeroConstructor, IsPlainOldData)
+// struct FSourceEffectChainEntry Entry                          (Parm, IsPlainOldData)
+
+void UAudioMixerBlueprintLibrary::AddSourceEffectToPresetChain(class UObject* WorldContextObject, class USoundEffectSourcePresetChain* PresetChain, const struct FSourceEffectChainEntry& Entry)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AudioMixer.AudioMixerBlueprintLibrary.AddSourceEffectToPresetChain");
+
+	UAudioMixerBlueprintLibrary_AddSourceEffectToPresetChain_Params params;
+	params.WorldContextObject = WorldContextObject;
+	params.PresetChain = PresetChain;
+	params.Entry = Entry;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AudioMixer.AudioMixerBlueprintLibrary.AddMasterSubmixEffect
+// (Final, Native, Static, Public, BlueprintCallable)
+// Parameters:
+// class UObject*                 WorldContextObject             (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+// class USoundEffectSubmixPreset* SubmixEffectPreset             (Parm, ZeroConstructor, IsPlainOldData)
+
+void UAudioMixerBlueprintLibrary::AddMasterSubmixEffect(class UObject* WorldContextObject, class USoundEffectSubmixPreset* SubmixEffectPreset)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AudioMixer.AudioMixerBlueprintLibrary.AddMasterSubmixEffect");
+
+	UAudioMixerBlueprintLibrary_AddMasterSubmixEffect_Params params;
+	params.WorldContextObject = WorldContextObject;
+	params.SubmixEffectPreset = SubmixEffectPreset;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	static auto defaultObj = StaticClass()->GetDefaultObject();
+	defaultObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AudioMixer.SubmixEffectDynamicsProcessorPreset.SetSettings
+// (Final, Native, Public, HasOutParms, BlueprintCallable)
+// Parameters:
+// struct FSubmixEffectDynamicsProcessorSettings InSettings                     (ConstParm, Parm, OutParm, ReferenceParm)
+
+void USubmixEffectDynamicsProcessorPreset::SetSettings(const struct FSubmixEffectDynamicsProcessorSettings& InSettings)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AudioMixer.SubmixEffectDynamicsProcessorPreset.SetSettings");
+
+	USubmixEffectDynamicsProcessorPreset_SetSettings_Params params;
+	params.InSettings = InSettings;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AudioMixer.SubmixEffectSubmixEQPreset.SetSettings
+// (Final, Native, Public, HasOutParms, BlueprintCallable)
+// Parameters:
+// struct FSubmixEffectSubmixEQSettings InSettings                     (ConstParm, Parm, OutParm, ReferenceParm)
+
+void USubmixEffectSubmixEQPreset::SetSettings(const struct FSubmixEffectSubmixEQSettings& InSettings)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AudioMixer.SubmixEffectSubmixEQPreset.SetSettings");
+
+	USubmixEffectSubmixEQPreset_SetSettings_Params params;
+	params.InSettings = InSettings;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AudioMixer.SubmixEffectReverbPreset.SetSettingsWithReverbEffect
+// (Final, Native, Public, BlueprintCallable)
+// Parameters:
+// class UReverbEffect*           InReverbEffect                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+// float                          WetLevel                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+
+void USubmixEffectReverbPreset::SetSettingsWithReverbEffect(class UReverbEffect* InReverbEffect, float WetLevel)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AudioMixer.SubmixEffectReverbPreset.SetSettingsWithReverbEffect");
+
+	USubmixEffectReverbPreset_SetSettingsWithReverbEffect_Params params;
+	params.InReverbEffect = InReverbEffect;
+	params.WetLevel = WetLevel;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AudioMixer.SubmixEffectReverbPreset.SetSettings
+// (Final, Native, Public, HasOutParms, BlueprintCallable)
+// Parameters:
+// struct FSubmixEffectReverbSettings InSettings                     (ConstParm, Parm, OutParm, ReferenceParm)
+
+void USubmixEffectReverbPreset::SetSettings(const struct FSubmixEffectReverbSettings& InSettings)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AudioMixer.SubmixEffectReverbPreset.SetSettings");
+
+	USubmixEffectReverbPreset_SetSettings_Params params;
+	params.InSettings = InSettings;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AudioMixer.SynthComponent.Stop
+// (Final, Native, Public, BlueprintCallable)
+
+void USynthComponent::Stop()
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AudioMixer.SynthComponent.Stop");
+
+	USynthComponent_Stop_Params params;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AudioMixer.SynthComponent.Start
+// (Final, Native, Public, BlueprintCallable)
+
+void USynthComponent::Start()
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AudioMixer.SynthComponent.Start");
+
+	USynthComponent_Start_Params params;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AudioMixer.SynthComponent.SetSubmixSend
+// (Final, Native, Public, BlueprintCallable)
+// Parameters:
+// class USoundSubmix*            Submix                         (Parm, ZeroConstructor, IsPlainOldData)
+// float                          SendLevel                      (Parm, ZeroConstructor, IsPlainOldData)
+
+void USynthComponent::SetSubmixSend(class USoundSubmix* Submix, float SendLevel)
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AudioMixer.SynthComponent.SetSubmixSend");
+
+	USynthComponent_SetSubmixSend_Params params;
+	params.Submix = Submix;
+	params.SendLevel = SendLevel;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+}
+
+
+// Function AudioMixer.SynthComponent.IsPlaying
+// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
+// Parameters:
+// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+
+bool USynthComponent::IsPlaying()
+{
+	static UFunction *pFunc = 0;
+	if (!pFunc)
+		pFunc  = UObject::FindObject<UFunction>("Function AudioMixer.SynthComponent.IsPlaying");
+
+	USynthComponent_IsPlaying_Params params;
+
+	auto flags = pFunc->FunctionFlags;
+	pFunc->FunctionFlags |= 0x400;
+
+	UObject *currentObj = (UObject *) this;
+	currentObj->ProcessEvent(pFunc, &params);
+
+	pFunc->FunctionFlags = flags;
+
+	return params.ReturnValue;
+}
+
+
+}
+

结构体/数据/SDK/PUBGM_AudioMixer_parameters.hpp

@@ -0,0 +1,118 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+// Function AudioMixer.AudioMixerBlueprintLibrary.SetBypassSourceEffectChainEntry
+struct UAudioMixerBlueprintLibrary_SetBypassSourceEffectChainEntry_Params
+{
+	class UObject*                                     WorldContextObject;                                       // (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+	class USoundEffectSourcePresetChain*               PresetChain;                                              // (Parm, ZeroConstructor, IsPlainOldData)
+	int                                                EntryIndex;                                               // (Parm, ZeroConstructor, IsPlainOldData)
+	bool                                               bBypassed;                                                // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AudioMixer.AudioMixerBlueprintLibrary.RemoveSourceEffectFromPresetChain
+struct UAudioMixerBlueprintLibrary_RemoveSourceEffectFromPresetChain_Params
+{
+	class UObject*                                     WorldContextObject;                                       // (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+	class USoundEffectSourcePresetChain*               PresetChain;                                              // (Parm, ZeroConstructor, IsPlainOldData)
+	int                                                EntryIndex;                                               // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AudioMixer.AudioMixerBlueprintLibrary.RemoveMasterSubmixEffect
+struct UAudioMixerBlueprintLibrary_RemoveMasterSubmixEffect_Params
+{
+	class UObject*                                     WorldContextObject;                                       // (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+	class USoundEffectSubmixPreset*                    SubmixEffectPreset;                                       // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AudioMixer.AudioMixerBlueprintLibrary.GetNumberOfEntriesInSourceEffectChain
+struct UAudioMixerBlueprintLibrary_GetNumberOfEntriesInSourceEffectChain_Params
+{
+	class UObject*                                     WorldContextObject;                                       // (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+	class USoundEffectSourcePresetChain*               PresetChain;                                              // (Parm, ZeroConstructor, IsPlainOldData)
+	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+// Function AudioMixer.AudioMixerBlueprintLibrary.ClearMasterSubmixEffects
+struct UAudioMixerBlueprintLibrary_ClearMasterSubmixEffects_Params
+{
+	class UObject*                                     WorldContextObject;                                       // (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AudioMixer.AudioMixerBlueprintLibrary.AddSourceEffectToPresetChain
+struct UAudioMixerBlueprintLibrary_AddSourceEffectToPresetChain_Params
+{
+	class UObject*                                     WorldContextObject;                                       // (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+	class USoundEffectSourcePresetChain*               PresetChain;                                              // (Parm, ZeroConstructor, IsPlainOldData)
+	struct FSourceEffectChainEntry                     Entry;                                                    // (Parm, IsPlainOldData)
+};
+
+// Function AudioMixer.AudioMixerBlueprintLibrary.AddMasterSubmixEffect
+struct UAudioMixerBlueprintLibrary_AddMasterSubmixEffect_Params
+{
+	class UObject*                                     WorldContextObject;                                       // (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+	class USoundEffectSubmixPreset*                    SubmixEffectPreset;                                       // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AudioMixer.SubmixEffectDynamicsProcessorPreset.SetSettings
+struct USubmixEffectDynamicsProcessorPreset_SetSettings_Params
+{
+	struct FSubmixEffectDynamicsProcessorSettings      InSettings;                                               // (ConstParm, Parm, OutParm, ReferenceParm)
+};
+
+// Function AudioMixer.SubmixEffectSubmixEQPreset.SetSettings
+struct USubmixEffectSubmixEQPreset_SetSettings_Params
+{
+	struct FSubmixEffectSubmixEQSettings               InSettings;                                               // (ConstParm, Parm, OutParm, ReferenceParm)
+};
+
+// Function AudioMixer.SubmixEffectReverbPreset.SetSettingsWithReverbEffect
+struct USubmixEffectReverbPreset_SetSettingsWithReverbEffect_Params
+{
+	class UReverbEffect*                               InReverbEffect;                                           // (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+	float                                              WetLevel;                                                 // (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AudioMixer.SubmixEffectReverbPreset.SetSettings
+struct USubmixEffectReverbPreset_SetSettings_Params
+{
+	struct FSubmixEffectReverbSettings                 InSettings;                                               // (ConstParm, Parm, OutParm, ReferenceParm)
+};
+
+// Function AudioMixer.SynthComponent.Stop
+struct USynthComponent_Stop_Params
+{
+};
+
+// Function AudioMixer.SynthComponent.Start
+struct USynthComponent_Start_Params
+{
+};
+
+// Function AudioMixer.SynthComponent.SetSubmixSend
+struct USynthComponent_SetSubmixSend_Params
+{
+	class USoundSubmix*                                Submix;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
+	float                                              SendLevel;                                                // (Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function AudioMixer.SynthComponent.IsPlaying
+struct USynthComponent_IsPlaying_Params
+{
+	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
+};
+
+}
+

结构体/数据/SDK/PUBGM_AudioMixer_structs.hpp

@@ -0,0 +1,99 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:40 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Enums
+//---------------------------------------------------------------------------
+
+// Enum AudioMixer.ESubmixEffectDynamicsPeakMode
+enum class ESubmixEffectDynamicsPeakMode : uint8_t
+{
+	ESubmixEffectDynamicsPeakMode__MeanSquared = 0,
+	ESubmixEffectDynamicsPeakMode__RootMeanSquared = 1,
+	ESubmixEffectDynamicsPeakMode__Peak = 2,
+	ESubmixEffectDynamicsPeakMode__Count = 3,
+	ESubmixEffectDynamicsPeakMode__ESubmixEffectDynamicsPeakMode_MAX = 4
+};
+
+
+// Enum AudioMixer.ESubmixEffectDynamicsProcessorType
+enum class ESubmixEffectDynamicsProcessorType : uint8_t
+{
+	ESubmixEffectDynamicsProcessorType__Compressor = 0,
+	ESubmixEffectDynamicsProcessorType__Limiter = 1,
+	ESubmixEffectDynamicsProcessorType__Expander = 2,
+	ESubmixEffectDynamicsProcessorType__Gate = 3,
+	ESubmixEffectDynamicsProcessorType__Count = 4,
+	ESubmixEffectDynamicsProcessorType__ESubmixEffectDynamicsProcessorType_MAX = 5
+};
+
+
+
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// ScriptStruct AudioMixer.SubmixEffectDynamicsProcessorSettings
+// 0x0028
+struct FSubmixEffectDynamicsProcessorSettings
+{
+	ESubmixEffectDynamicsProcessorType                 DynamicsProcessorType;                                    // 0x0000(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	ESubmixEffectDynamicsPeakMode                      PeakMode;                                                 // 0x0001(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x2];                                       // 0x0002(0x0002) MISSED OFFSET
+	float                                              LookAheadMsec;                                            // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              AttackTimeMsec;                                           // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              ReleaseTimeMsec;                                          // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              ThresholdDb;                                              // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              Ratio;                                                    // 0x0014(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              KneeBandwidthDb;                                          // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              InputGainDb;                                              // 0x001C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              OutputGainDb;                                             // 0x0020(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      bChannelLinked : 1;                                       // 0x0024(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      bAnalogMode : 1;                                          // 0x0024(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      UnknownData01[0x3];                                       // 0x0025(0x0003) MISSED OFFSET
+};
+
+// ScriptStruct AudioMixer.SubmixEffectEQBand
+// 0x0010
+struct FSubmixEffectEQBand
+{
+	float                                              Frequency;                                                // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              Bandwidth;                                                // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              GainDb;                                                   // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      bEnabled : 1;                                             // 0x000C(0x0001) (Edit, BlueprintVisible)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x000D(0x0003) MISSED OFFSET
+};
+
+// ScriptStruct AudioMixer.SubmixEffectSubmixEQSettings
+// 0x000C
+struct FSubmixEffectSubmixEQSettings
+{
+	TArray<struct FSubmixEffectEQBand>                 EQBands;                                                  // 0x0000(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+};
+
+// ScriptStruct AudioMixer.SubmixEffectReverbSettings
+// 0x0030
+struct FSubmixEffectReverbSettings
+{
+	float                                              Density;                                                  // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              Diffusion;                                                // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              Gain;                                                     // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              GainHF;                                                   // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              DecayTime;                                                // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              DecayHFRatio;                                             // 0x0014(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              ReflectionsGain;                                          // 0x0018(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              ReflectionsDelay;                                         // 0x001C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              LateGain;                                                 // 0x0020(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              LateDelay;                                                // 0x0024(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              AirAbsorptionGainHF;                                      // 0x0028(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	float                                              WetLevel;                                                 // 0x002C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+};
+
+}
+

结构体/数据/SDK/PUBGM_Authorization_BP_classes.hpp

@@ -0,0 +1,134 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:52 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Classes
+//---------------------------------------------------------------------------
+
+// WidgetBlueprintGeneratedClass Authorization_BP.Authorization_BP_C
+// 0x00F8 (0x0368 - 0x0270)
+class UAuthorization_BP_C : public UUAEUserWidget
+{
+public:
+	struct FPointerToUberGraphFrame                    UberGraphFrame;                                           // 0x0270(0x0004) (Transient, DuplicateTransient)
+	class UWidgetAnimation*                            LOGO_anima;                                               // 0x0274(0x0004) (BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UWidgetSwitcher*                             AuthTypeSwitcher;                                         // 0x0278(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UButton*                                     Button_1;                                                 // 0x027C(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UButton*                                     Button_2;                                                 // 0x0280(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UButton*                                     Button_3;                                                 // 0x0284(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UButton*                                     Button_Button_VisitorEnter;                               // 0x0288(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UButton*                                     Button_Help;                                              // 0x028C(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UButton*                                     Button_LeavePlane;                                        // 0x0290(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UButton*                                     Button_LoginOut;                                          // 0x0294(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UButton*                                     Button_Policy;                                            // 0x0298(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UButton*                                     Button_QQ;                                                // 0x029C(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UButton*                                     Button_Repair;                                            // 0x02A0(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UButton*                                     Button_Service;                                           // 0x02A4(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UButton*                                     Button_WX;                                                // 0x02A8(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UCheckBox*                                   CheckBox_Agree;                                           // 0x02AC(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UGridPanel*                                  GridPanel_IPX;                                            // 0x02B0(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UHorizontalBox*                              HorizontalBox_autoHide_2;                                 // 0x02B4(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UHorizontalBox*                              HorizontalBox_autoHide_3;                                 // 0x02B8(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UHorizontalBox*                              QQBox;                                                    // 0x02BC(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UHorizontalBox*                              QQPswdBox;                                                // 0x02C0(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UMultiLineEditableTextBox*                   Text_ID;                                                  // 0x02C4(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UEditableText*                               Text_Pswd;                                                // 0x02C8(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UTextBlock*                                  TextBlock_7;                                              // 0x02CC(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UTextBlock*                                  TextBlock_9;                                              // 0x02D0(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UTextBlock*                                  TextBlock_11;                                             // 0x02D4(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UTextBlock*                                  TextBlock_12;                                             // 0x02D8(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UTextBlock*                                  TextBlock_14;                                             // 0x02DC(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UTextBlock*                                  TextBlock_15;                                             // 0x02E0(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UTextBlock*                                  TextBlock_Version;                                        // 0x02E4(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UVerticalBox*                                VerticalBox_autoHide_4;                                   // 0x02E8(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	class UButton*                                     Windows_Login;                                            // 0x02EC(0x0004) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
+	bool                                               m_checked;                                                // 0x02F0(0x0001) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x02F1(0x0003) MISSED OFFSET
+	struct FString                                     PlatformName;                                             // 0x02F4(0x000C) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance)
+	class Abp_authorization_C*                         bp_auth;                                                  // 0x0300(0x0004) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnTemplate, DisableEditOnInstance, IsPlainOldData)
+	struct FScriptMulticastDelegate                    startGameSounds;                                          // 0x0304(0x000C) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, BlueprintAssignable)
+	int                                                LoginCount;                                               // 0x0310(0x0004) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	class UPlayerPrefs_C*                              MyPlayerPrefs;                                            // 0x0314(0x0004) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	struct FString                                     SlotName;                                                 // 0x0318(0x000C) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance)
+	class Abp_global_C*                                bpGlobal;                                                 // 0x0324(0x0004) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnTemplate, DisableEditOnInstance, IsPlainOldData)
+	int                                                tempFpsIndex;                                             // 0x0328(0x0004) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	TMap<int, int>                                     FpsToIndex;                                               // 0x032C(0x0050) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance)
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("WidgetBlueprintGeneratedClass Authorization_BP.Authorization_BP_C");
+		return pStaticClass;
+	}
+
+
+	void ShowHelpBtn();
+	void SetSettingVars(class USettingConfig_C* Config);
+	void IsServiceAccepted(bool* accept);
+	void SetCheckBox(bool isCheck);
+	void SetScreenLightness(class USettingConfig_C* Config);
+	void SetLocalSavedQuickMsgSetting();
+	void SetServiceAndPolicyCallType(int calltype);
+	void SetServiceAndPolicyChecked();
+	void ReleaseLoginButtons();
+	void BlockLoginButtons();
+	void updateLoginButtons();
+	void HideHelpBtn();
+	void GetMaxSupportFps(int* maxFpsIndex);
+	void SendPictureSetting();
+	void CheckRendingSafe();
+	void RefreshGameVersion();
+	void ShowEffects(bool Is_show);
+	void UIShow2();
+	void ShowUI();
+	void InitAuthorizationUI();
+	void InitLoginUI();
+	void doAutoLogin();
+	void UpdateRelatedSetting();
+	void DoUpdate();
+	void SetFpsByIndex(int Index);
+	void InitFps(class USettingConfig_C* settingConfig);
+	void SetLbsOffAndDisableMicphone(class USettingConfig_C* settingObj);
+	void InitVoiceSetting(class USettingConfig_C* settingObj);
+	void SetSoudsSetting(const struct FName& ParamName, float ParamValue);
+	void InitUserSetting();
+	void setLoginLimit();
+	void addLoginCount();
+	void clearLoginCount();
+	void redoAutoAuthorization();
+	void doAuthorization();
+	void hideButtons();
+	void showButtons();
+	void QuitGame();
+	void hideAuthorizationUI();
+	void startAuthorization();
+	void showAuthorizationUI();
+	void BndEvt__Button_Login_K2Node_ComponentBoundEvent_249_OnButtonClickedEvent__DelegateSignature();
+	void BndEvt__Button_Button_VisitorEnter0_K2Node_ComponentBoundEvent_0_OnButtonClickedEvent__DelegateSignature();
+	void BndEvt__Button_QQ2_K2Node_ComponentBoundEvent_1_OnButtonClickedEvent__DelegateSignature();
+	void BndEvt__Button_WX1_K2Node_ComponentBoundEvent_2_OnButtonClickedEvent__DelegateSignature();
+	void BndEvt__CheckBox_0_K2Node_ComponentBoundEvent_3_OnCheckBoxComponentStateChanged__DelegateSignature(bool bIsChecked);
+	void BndEvt__Button_Service3_K2Node_ComponentBoundEvent_4_OnButtonClickedEvent__DelegateSignature();
+	void StartAutoAuthorization();
+	void BndEvt__Button_1_K2Node_ComponentBoundEvent_34_OnButtonClickedEvent__DelegateSignature();
+	void BndEvt__Button_2_K2Node_ComponentBoundEvent_51_OnButtonClickedEvent__DelegateSignature();
+	void BndEvt__Button_LeavePlane_K2Node_ComponentBoundEvent_112_OnButtonClickedEvent__DelegateSignature();
+	void BndEvt__Button_Help_K2Node_ComponentBoundEvent_129_OnButtonClickedEvent__DelegateSignature();
+	void BndEvt__Button_LoginOut_K2Node_ComponentBoundEvent_62_OnButtonClickedEvent__DelegateSignature();
+	void BndEvt__Button_Repair_K2Node_ComponentBoundEvent_37_OnButtonClickedEvent__DelegateSignature();
+	void BndEvt__Button_Policy_K2Node_ComponentBoundEvent_146_OnButtonClickedEvent__DelegateSignature();
+	void Construct();
+	void ExecuteUbergraph_Authorization_BP(int EntryPoint);
+	void startGameSounds__DelegateSignature();
+};
+
+
+}
+

结构体/数据/SDK/PUBGM_Authorization_BP_parameters.hpp

@@ -0,0 +1,322 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:52 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+// Function Authorization_BP.Authorization_BP_C.ShowHelpBtn
+struct UAuthorization_BP_C_ShowHelpBtn_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.SetSettingVars
+struct UAuthorization_BP_C_SetSettingVars_Params
+{
+	class USettingConfig_C*                            Config;                                                   // (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function Authorization_BP.Authorization_BP_C.IsServiceAccepted
+struct UAuthorization_BP_C_IsServiceAccepted_Params
+{
+	bool                                               accept;                                                   // (Parm, OutParm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function Authorization_BP.Authorization_BP_C.SetCheckBox
+struct UAuthorization_BP_C_SetCheckBox_Params
+{
+	bool                                               isCheck;                                                  // (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function Authorization_BP.Authorization_BP_C.SetScreenLightness
+struct UAuthorization_BP_C_SetScreenLightness_Params
+{
+	class USettingConfig_C*                            Config;                                                   // (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function Authorization_BP.Authorization_BP_C.SetLocalSavedQuickMsgSetting
+struct UAuthorization_BP_C_SetLocalSavedQuickMsgSetting_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.SetServiceAndPolicyCallType
+struct UAuthorization_BP_C_SetServiceAndPolicyCallType_Params
+{
+	int                                                calltype;                                                 // (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function Authorization_BP.Authorization_BP_C.SetServiceAndPolicyChecked
+struct UAuthorization_BP_C_SetServiceAndPolicyChecked_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.ReleaseLoginButtons
+struct UAuthorization_BP_C_ReleaseLoginButtons_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.BlockLoginButtons
+struct UAuthorization_BP_C_BlockLoginButtons_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.updateLoginButtons
+struct UAuthorization_BP_C_updateLoginButtons_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.HideHelpBtn
+struct UAuthorization_BP_C_HideHelpBtn_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.GetMaxSupportFps
+struct UAuthorization_BP_C_GetMaxSupportFps_Params
+{
+	int                                                maxFpsIndex;                                              // (Parm, OutParm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function Authorization_BP.Authorization_BP_C.SendPictureSetting
+struct UAuthorization_BP_C_SendPictureSetting_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.CheckRendingSafe
+struct UAuthorization_BP_C_CheckRendingSafe_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.RefreshGameVersion
+struct UAuthorization_BP_C_RefreshGameVersion_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.ShowEffects
+struct UAuthorization_BP_C_ShowEffects_Params
+{
+	bool                                               Is_show;                                                  // (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function Authorization_BP.Authorization_BP_C.UIShow2
+struct UAuthorization_BP_C_UIShow2_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.ShowUI
+struct UAuthorization_BP_C_ShowUI_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.InitAuthorizationUI
+struct UAuthorization_BP_C_InitAuthorizationUI_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.InitLoginUI
+struct UAuthorization_BP_C_InitLoginUI_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.doAutoLogin
+struct UAuthorization_BP_C_doAutoLogin_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.UpdateRelatedSetting
+struct UAuthorization_BP_C_UpdateRelatedSetting_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.DoUpdate
+struct UAuthorization_BP_C_DoUpdate_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.SetFpsByIndex
+struct UAuthorization_BP_C_SetFpsByIndex_Params
+{
+	int                                                Index;                                                    // (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function Authorization_BP.Authorization_BP_C.InitFps
+struct UAuthorization_BP_C_InitFps_Params
+{
+	class USettingConfig_C*                            settingConfig;                                            // (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function Authorization_BP.Authorization_BP_C.SetLbsOffAndDisableMicphone
+struct UAuthorization_BP_C_SetLbsOffAndDisableMicphone_Params
+{
+	class USettingConfig_C*                            settingObj;                                               // (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function Authorization_BP.Authorization_BP_C.InitVoiceSetting
+struct UAuthorization_BP_C_InitVoiceSetting_Params
+{
+	class USettingConfig_C*                            settingObj;                                               // (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function Authorization_BP.Authorization_BP_C.SetSoudsSetting
+struct UAuthorization_BP_C_SetSoudsSetting_Params
+{
+	struct FName                                       ParamName;                                                // (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
+	float                                              ParamValue;                                               // (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function Authorization_BP.Authorization_BP_C.InitUserSetting
+struct UAuthorization_BP_C_InitUserSetting_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.setLoginLimit
+struct UAuthorization_BP_C_setLoginLimit_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.addLoginCount
+struct UAuthorization_BP_C_addLoginCount_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.clearLoginCount
+struct UAuthorization_BP_C_clearLoginCount_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.redoAutoAuthorization
+struct UAuthorization_BP_C_redoAutoAuthorization_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.doAuthorization
+struct UAuthorization_BP_C_doAuthorization_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.hideButtons
+struct UAuthorization_BP_C_hideButtons_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.showButtons
+struct UAuthorization_BP_C_showButtons_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.QuitGame
+struct UAuthorization_BP_C_QuitGame_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.hideAuthorizationUI
+struct UAuthorization_BP_C_hideAuthorizationUI_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.startAuthorization
+struct UAuthorization_BP_C_startAuthorization_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.showAuthorizationUI
+struct UAuthorization_BP_C_showAuthorizationUI_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.BndEvt__Button_Login_K2Node_ComponentBoundEvent_249_OnButtonClickedEvent__DelegateSignature
+struct UAuthorization_BP_C_BndEvt__Button_Login_K2Node_ComponentBoundEvent_249_OnButtonClickedEvent__DelegateSignature_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.BndEvt__Button_Button_VisitorEnter0_K2Node_ComponentBoundEvent_0_OnButtonClickedEvent__DelegateSignature
+struct UAuthorization_BP_C_BndEvt__Button_Button_VisitorEnter0_K2Node_ComponentBoundEvent_0_OnButtonClickedEvent__DelegateSignature_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.BndEvt__Button_QQ2_K2Node_ComponentBoundEvent_1_OnButtonClickedEvent__DelegateSignature
+struct UAuthorization_BP_C_BndEvt__Button_QQ2_K2Node_ComponentBoundEvent_1_OnButtonClickedEvent__DelegateSignature_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.BndEvt__Button_WX1_K2Node_ComponentBoundEvent_2_OnButtonClickedEvent__DelegateSignature
+struct UAuthorization_BP_C_BndEvt__Button_WX1_K2Node_ComponentBoundEvent_2_OnButtonClickedEvent__DelegateSignature_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.BndEvt__CheckBox_0_K2Node_ComponentBoundEvent_3_OnCheckBoxComponentStateChanged__DelegateSignature
+struct UAuthorization_BP_C_BndEvt__CheckBox_0_K2Node_ComponentBoundEvent_3_OnCheckBoxComponentStateChanged__DelegateSignature_Params
+{
+	bool                                               bIsChecked;                                               // (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function Authorization_BP.Authorization_BP_C.BndEvt__Button_Service3_K2Node_ComponentBoundEvent_4_OnButtonClickedEvent__DelegateSignature
+struct UAuthorization_BP_C_BndEvt__Button_Service3_K2Node_ComponentBoundEvent_4_OnButtonClickedEvent__DelegateSignature_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.StartAutoAuthorization
+struct UAuthorization_BP_C_StartAutoAuthorization_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.BndEvt__Button_1_K2Node_ComponentBoundEvent_34_OnButtonClickedEvent__DelegateSignature
+struct UAuthorization_BP_C_BndEvt__Button_1_K2Node_ComponentBoundEvent_34_OnButtonClickedEvent__DelegateSignature_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.BndEvt__Button_2_K2Node_ComponentBoundEvent_51_OnButtonClickedEvent__DelegateSignature
+struct UAuthorization_BP_C_BndEvt__Button_2_K2Node_ComponentBoundEvent_51_OnButtonClickedEvent__DelegateSignature_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.BndEvt__Button_LeavePlane_K2Node_ComponentBoundEvent_112_OnButtonClickedEvent__DelegateSignature
+struct UAuthorization_BP_C_BndEvt__Button_LeavePlane_K2Node_ComponentBoundEvent_112_OnButtonClickedEvent__DelegateSignature_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.BndEvt__Button_Help_K2Node_ComponentBoundEvent_129_OnButtonClickedEvent__DelegateSignature
+struct UAuthorization_BP_C_BndEvt__Button_Help_K2Node_ComponentBoundEvent_129_OnButtonClickedEvent__DelegateSignature_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.BndEvt__Button_LoginOut_K2Node_ComponentBoundEvent_62_OnButtonClickedEvent__DelegateSignature
+struct UAuthorization_BP_C_BndEvt__Button_LoginOut_K2Node_ComponentBoundEvent_62_OnButtonClickedEvent__DelegateSignature_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.BndEvt__Button_Repair_K2Node_ComponentBoundEvent_37_OnButtonClickedEvent__DelegateSignature
+struct UAuthorization_BP_C_BndEvt__Button_Repair_K2Node_ComponentBoundEvent_37_OnButtonClickedEvent__DelegateSignature_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.BndEvt__Button_Policy_K2Node_ComponentBoundEvent_146_OnButtonClickedEvent__DelegateSignature
+struct UAuthorization_BP_C_BndEvt__Button_Policy_K2Node_ComponentBoundEvent_146_OnButtonClickedEvent__DelegateSignature_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.Construct
+struct UAuthorization_BP_C_Construct_Params
+{
+};
+
+// Function Authorization_BP.Authorization_BP_C.ExecuteUbergraph_Authorization_BP
+struct UAuthorization_BP_C_ExecuteUbergraph_Authorization_BP_Params
+{
+	int                                                EntryPoint;                                               // (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
+};
+
+// Function Authorization_BP.Authorization_BP_C.startGameSounds__DelegateSignature
+struct UAuthorization_BP_C_startGameSounds__DelegateSignature_Params
+{
+};
+
+}
+

结构体/数据/SDK/PUBGM_Authorization_BP_structs.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:52 2025
+
+namespace SDK
+{
+}
+

结构体/数据/SDK/PUBGM_BP_SAVEGAME_UIElemLayout_classes.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:52 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Classes
+//---------------------------------------------------------------------------
+
+// BlueprintGeneratedClass BP_SAVEGAME_UIElemLayout.BP_SAVEGAME_UIElemLayout_C
+// 0x00F8 (0x0118 - 0x0020)
+class UBP_SAVEGAME_UIElemLayout_C : public USaveGame
+{
+public:
+	TMap<int, struct FBP_STRUCT_UIElemLayoutDetail>    LayoutDetailDict1;                                        // 0x0020(0x0050) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance)
+	TMap<int, struct FBP_STRUCT_UIElemLayoutDetail>    LayoutDetailDict2;                                        // 0x005C(0x0050) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance)
+	TMap<int, struct FBP_STRUCT_UIElemLayoutDetail>    LayoutDetailDict3;                                        // 0x0098(0x0050) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance)
+	bool                                               IsDataValid1;                                             // 0x00D4(0x0001) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	bool                                               IsDataValid2;                                             // 0x00D5(0x0001) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	bool                                               IsDataValid3;                                             // 0x00D6(0x0001) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x1];                                       // 0x00D7(0x0001) MISSED OFFSET
+	float                                              RushTriggerLength1;                                       // 0x00D8(0x0004) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	float                                              RushTriggerLength2;                                       // 0x00DC(0x0004) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	float                                              RushTriggerLength3;                                       // 0x00E0(0x0004) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+	struct FString                                     SaveSlotName;                                             // 0x00E4(0x000C) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance)
+	struct FString                                     LayoutName1;                                              // 0x00F0(0x000C) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance)
+	struct FString                                     LayoutName2;                                              // 0x00FC(0x000C) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance)
+	struct FString                                     LayoutName3;                                              // 0x0108(0x000C) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance)
+	int                                                TimeTag;                                                  // 0x0114(0x0004) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
+
+	static UClass* StaticClass()
+	{
+        static UClass *pStaticClass = 0;
+        if (!pStaticClass)
+            pStaticClass = UObject::FindClass("BlueprintGeneratedClass BP_SAVEGAME_UIElemLayout.BP_SAVEGAME_UIElemLayout_C");
+		return pStaticClass;
+	}
+
+};
+
+
+}
+

结构体/数据/SDK/PUBGM_BP_SAVEGAME_UIElemLayout_functions.cpp

@@ -0,0 +1,15 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:52 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_SAVEGAME_UIElemLayout_parameters.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:52 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_SAVEGAME_UIElemLayout_structs.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:52 2025
+
+namespace SDK
+{
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActButtonInfo_classes.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:50 2025
+
+namespace SDK
+{
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActButtonInfo_functions.cpp

@@ -0,0 +1,15 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:50 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActButtonInfo_parameters.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:50 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActButtonInfo_structs.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:50 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// UserDefinedStruct BP_STRUCT_ActButtonInfo.BP_STRUCT_ActButtonInfo
+// 0x002C
+struct FBP_STRUCT_ActButtonInfo
+{
+	int                                                Btn_Type_0_72A7BDDA4D539877791B30B19CB97C5E;              // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	struct FString                                     Btn_TypeName_1_C1631EF849C229989F4201B7B2E4F5B5;          // 0x0004(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	int                                                ActID_2_89F1DAB74AE5AF1F611CE4AC8F9FAE25;                 // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	struct FString                                     Btn_Name_3_CB1FB8C54883B36537B88AA8946E6E9B;              // 0x0014(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	bool                                               IsRedPoint_4_4762A09D4D3A7BDD1094AE91409A4294;            // 0x0020(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x0021(0x0003) MISSED OFFSET
+	int                                                Btn_Tab_Num_5_11086F8025E813FE02005F990CEB832D;           // 0x0024(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	int                                                RedPoint_Type_6_5442EEC06638EC63042412B909CB83E5;         // 0x0028(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+};
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActiveAwardInfo_classes.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:50 2025
+
+namespace SDK
+{
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActiveAwardInfo_functions.cpp

@@ -0,0 +1,15 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:50 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActiveAwardInfo_parameters.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:50 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActiveAwardInfo_structs.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:50 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// UserDefinedStruct BP_STRUCT_ActiveAwardInfo.BP_STRUCT_ActiveAwardInfo
+// 0x0014
+struct FBP_STRUCT_ActiveAwardInfo
+{
+	struct FString                                     status_2_63049F3D4B573DE822E277BB11CF38C5;                // 0x0000(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	int                                                id_1_A0702D724E5C3EC2F83B4B9CB00D4F52;                    // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	int                                                value_3_CB44583242127623F9B90AA93F2B0AD4;                 // 0x0010(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+};
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActiveAwardItem_classes.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:44 2025
+
+namespace SDK
+{
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActiveAwardItem_functions.cpp

@@ -0,0 +1,15 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:44 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActiveAwardItem_parameters.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:44 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActiveAwardItem_structs.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:44 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// UserDefinedStruct BP_STRUCT_ActiveAwardItem.BP_STRUCT_ActiveAwardItem
+// 0x0018
+struct FBP_STRUCT_ActiveAwardItem
+{
+	TArray<struct FBP_STRUCT_TaskDropItem>             BP_ARRAY_FixItemList_9_073B04D24ABA4D580D1CAEB934268E72;  // 0x0000(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	TArray<struct FBP_STRUCT_TaskDropItem>             BP_ARRAY_RandomItemList_10_3D526F394D28F7AA28A03586B29F936A;// 0x000C(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+};
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivityAppointmentAwardInfo_classes.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:43 2025
+
+namespace SDK
+{
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivityAppointmentAwardInfo_functions.cpp

@@ -0,0 +1,15 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:43 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivityAppointmentAwardInfo_parameters.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:43 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivityAppointmentAwardInfo_structs.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:43 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// UserDefinedStruct BP_STRUCT_ActivityAppointmentAwardInfo.BP_STRUCT_ActivityAppointmentAwardInfo
+// 0x0010
+struct FBP_STRUCT_ActivityAppointmentAwardInfo
+{
+	int                                                ExpireTime_0_1CCBF2007FE51DCA72A285D50A985EF5;            // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	int                                                ItemID_1_55231A0045F8F1DA19E70AAF03377BC4;                // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	int                                                ItemCount_2_7144590079674C204131A89E07B95924;             // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	int                                                AwardStatus_3_18D44FC03986F6E95DC3C7E008818EE3;           // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+};
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivityAppointmentData_classes.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:43 2025
+
+namespace SDK
+{
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivityAppointmentData_functions.cpp

@@ -0,0 +1,15 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:43 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivityAppointmentData_parameters.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:43 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivityAppointmentData_structs.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:43 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// UserDefinedStruct BP_STRUCT_ActivityAppointmentData.BP_STRUCT_ActivityAppointmentData
+// 0x004C
+struct FBP_STRUCT_ActivityAppointmentData
+{
+	bool                                               IsDone_0_631163406102424D27398FE6003CB685;                // 0x0000(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData00[0x3];                                       // 0x0001(0x0003) MISSED OFFSET
+	struct FString                                     Desc_1_4FE1F280719381B027AA9AB400BF9793;                  // 0x0004(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	bool                                               IsOpened_2_082478807223E5AE17ECCB5B0D668484;              // 0x0010(0x0001) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	unsigned char                                      UnknownData01[0x3];                                       // 0x0011(0x0003) MISSED OFFSET
+	struct FString                                     Detail_4_4556A780718A9DEE102C06B90F97A74C;                // 0x0014(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	struct FString                                     Title_5_06B4F34060CCADB959EF7EEF0BEABB25;                 // 0x0020(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	struct FBP_STRUCT_AppointmentAward                 BP_STRUCT_AppointmentAward_7_4645DF804726E41C018481EE07A6C404;// 0x002C(0x0010) (Edit, BlueprintVisible)
+	struct FBP_STRUCT_ShareAward                       BP_STRUCT_ShareAward_8_2FE97880741D537C158DD69F0F746ED4;  // 0x003C(0x0010) (Edit, BlueprintVisible)
+};
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivityBtnDisplay_classes.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:42 2025
+
+namespace SDK
+{
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivityBtnDisplay_functions.cpp

@@ -0,0 +1,15 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:42 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivityBtnDisplay_parameters.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:42 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivityBtnDisplay_structs.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:42 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// UserDefinedStruct BP_STRUCT_ActivityBtnDisplay.BP_STRUCT_ActivityBtnDisplay
+// 0x003C
+struct FBP_STRUCT_ActivityBtnDisplay
+{
+	int                                                Priority_0_46159A294AD8CE52B8706D9F5544BD82;              // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	struct FString                                     ActivityName_1_BDDD54604B8656536C99C0A3F5074B3F;          // 0x0004(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	struct FString                                     IconPath_2_C79C7E02493AE6F3925939B80B14DE6D;              // 0x0010(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	struct FString                                     JumpUrl_3_883F04534B750337906ECABA456B4935;               // 0x001C(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	int                                                EndTime_4_197423154ADCB20E680D95A680D052BA;               // 0x0028(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	int                                                StartTime_5_BF12CD944EAB63ED3C270ABF863560AD;             // 0x002C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	int                                                HasToken_6_341FB6402DB0637736EEE6A503F4B0BE;              // 0x0030(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	int                                                Type_7_28A537807B3CB220160DD7A909F06B15;                  // 0x0034(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	int                                                HasRedPoint_8_0D865F40112014B7383DE17D04876144;           // 0x0038(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+};
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivityGroupInfo_classes.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:43 2025
+
+namespace SDK
+{
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivityGroupInfo_functions.cpp

@@ -0,0 +1,15 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:43 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivityGroupInfo_parameters.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:43 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivityGroupInfo_structs.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:43 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// UserDefinedStruct BP_STRUCT_ActivityGroupInfo.BP_STRUCT_ActivityGroupInfo
+// 0x004C
+struct FBP_STRUCT_ActivityGroupInfo
+{
+	int                                                type_0_D067354840D2B27A27F8838B84B660C8;                  // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	int                                                id_1_6CC5C2A24764550ECD1880B81A718F90;                    // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	int                                                button_id_2_DAC92545495BC629323B44BB8CA895E6;             // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	int                                                position_3_9E25B58544334B518AEEA0966BD19DD8;              // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	struct FString                                     icon_4_D0D214D7417C22863EB58CADE5E15C77;                  // 0x0010(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	struct FString                                     description_5_0C6C081A4282C827C2742ABFF98514A7;           // 0x001C(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	int                                                end_time_6_F124D037419BEE0C0E9895AA27C51133;              // 0x0028(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	struct FString                                     jump_to_7_EDD6D2364CC15A70A343D0AEBB2F8578;               // 0x002C(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	int                                                open_time_8_BA857826461842809675D4946CE2CECE;             // 0x0038(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	struct FString                                     title_9_0737801341804875EE22F29154492EC0;                 // 0x003C(0x000C) (Edit, BlueprintVisible, ZeroConstructor)
+	int                                                activity_id_10_CFE7932D48472BA7BD4200B4FB90DBD4;          // 0x0048(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+};
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivtyInfo_Click_classes.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:50 2025
+
+namespace SDK
+{
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivtyInfo_Click_functions.cpp

@@ -0,0 +1,15 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:50 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivtyInfo_Click_parameters.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:50 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivtyInfo_Click_structs.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:50 2025
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Script Structs
+//---------------------------------------------------------------------------
+
+// UserDefinedStruct BP_STRUCT_ActivtyInfo_Click.BP_STRUCT_ActivtyInfo_Click
+// 0x0010
+struct FBP_STRUCT_ActivtyInfo_Click
+{
+	int                                                SubActIndex_0_D7D80E5A43F1A94B30F0A38B46B872A0;           // 0x0000(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	int                                                SubActType_1_BDE3B10B40F2A8D8512BD2927A1883C0;            // 0x0004(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	int                                                SubActID_2_4DDE339C45BB47C52C25DEB253222565;              // 0x0008(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+	int                                                Arg_3_A9B6F30A477F5CE4764586BC17CD0C1E;                   // 0x000C(0x0004) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
+};
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivtyInfo_classes.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:50 2025
+
+namespace SDK
+{
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivtyInfo_functions.cpp

@@ -0,0 +1,15 @@
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:50 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Functions
+//---------------------------------------------------------------------------
+
+}
+

结构体/数据/SDK/PUBGM_BP_STRUCT_ActivtyInfo_parameters.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+//PUBGM(0.13.5)32位SDK
+//作者:清华
+//Telegram:@qinghuanb666
+//生成时间:Fri Apr 18 20:44:50 2025
+
+#include "../SDK.hpp"
+
+namespace SDK
+{
+//---------------------------------------------------------------------------
+//Parameters
+//---------------------------------------------------------------------------
+
+}
+