uint32_t g_dynamic_key = 0;
extern uint32_t g_dynamic_key;
static uint8_t g_state_enc[4] = {0x00, 0x00, 0x00, 0x00};
#define STATE_MASK 0x7A 
inline bool get_state(int idx) {
    return (g_state_enc[idx] ^ STATE_MASK) & 1;
}
inline void set_state(int idx, bool val) {
    g_state_enc[idx] = (g_state_enc[idx] & ~1) | (val ^ STATE_MASK);
}
enum {
    IDX_INJECTED = 0,
    IDX_INJECTED2 = 1,
    IDX_HARDWARE_MAPPED_COMMON = 2,
    IDX_HARDWARE_MAPPED_SHOTGUN = 3,
    IDX_D_REGISTER_USED = 4  // 🔥 新增：标记D寄存器是否已使用
};

inline uintptr_t enc_offset_common() {
    return 0x87049AC ^ g_dynamic_key;
}
inline uintptr_t enc_offset_shotgun() {
    return 0xCC95250 ^ g_dynamic_key;
}
static uint32_t common_restore_enc[3] = {
    1840659439 ^ g_dynamic_key,
    1828795373 ^ g_dynamic_key,
    1828858859 ^ g_dynamic_key
};
static uint32_t shotgun_restore_enc[3] = {
    -1119459328 ^ g_dynamic_key,
    -1119458303 ^ g_dynamic_key,
    -1119457278 ^ g_dynamic_key
};
static volatile int confuse_counter = 0;
static void confuse_loop() {
    for (int i = 0; i < 10; ++i) confuse_counter += i;
}
#define DEBUG_PRINT(fmt, ...) do { if (g_dynamic_key & 1) printf(fmt, ##__VA_ARGS__); } while(0)
static uintptr_t 硬件安全缓冲区[16] = {0};  
static int 硬件调度索引 = 0;  

// 函数声明
void 写入硬件映射_霰弹枪(uintptr_t 地址值);  
void 写入硬件映射_通用武器(uintptr_t 地址值); 
void 写入硬件映射_功能武器(uintptr_t 地址值);
uintptr_t 读取硬件映射_霰弹枪();           
uintptr_t 读取硬件映射_通用武器();         
uintptr_t 读取硬件映射_功能武器();
// 函数实现
void 写入硬件映射_霰弹枪(uintptr_t 地址值) {
    asm volatile("mov x20, %0" : : "r"(地址值) : "x20");
    硬件调度索引 = (硬件调度索引 + 1) & 7;
    switch(硬件调度索引) {
        case 0: asm volatile("mov x9, %0" : : "r"(地址值) : "x9"); break;
        case 1: asm volatile("mov x10, %0" : : "r"(地址值) : "x10"); break;
        case 2: asm volatile("mov x11, %0" : : "r"(地址值) : "x11"); break;
        case 3: asm volatile("mov x12, %0" : : "r"(地址值) : "x12"); break;
        case 4: asm volatile("mov x13, %0" : : "r"(地址值) : "x13"); break;
        case 5: asm volatile("mov x14, %0" : : "r"(地址值) : "x14"); break;
        case 6: asm volatile("mov x15, %0" : : "r"(地址值) : "x15"); break;
        case 7: asm volatile("mov x16, %0" : : "r"(地址值) : "x16"); break;
    }
    
    硬件安全缓冲区[硬件调度索引] = 地址值 ^ 0xA5A5A5A5;
}

void 写入硬件映射_通用武器(uintptr_t 地址值) {
    // 🔥 使用 D19 作为主地址寄存器（V19 的低64位）
    asm volatile("fmov d19, %0" : : "r"(地址值) : "d19");
    
    // 🔥 使用 D21-D28 作为动态调度寄存器
    static int 次调度索引 = 0;
    次调度索引 = (次调度索引 + 3) & 7;
    
    // 为不同寄存器生成不同的变换值
    uintptr_t 变换值1 = 地址值 ^ 0x12345678;
    uintptr_t 变换值2 = __builtin_bswap64(地址值);
    uintptr_t 变换值3 = ~地址值;
    uintptr_t 变换值4 = 地址值 + 0x1000;
    uintptr_t 变换值5 = 地址值 - 0x1000;
    uintptr_t 变换值6 = 地址值 ^ 0xF0F0F0F0;
    uintptr_t 变换值7 = __builtin_bswap64(~地址值);
    uintptr_t 变换值8 = 地址值 * 0x9E3779B9;
    
    switch(次调度索引) {
        case 0: asm volatile("fmov d21, %0" : : "r"(变换值1) : "d21"); break;
        case 1: asm volatile("fmov d22, %0" : : "r"(变换值2) : "d22"); break;
        case 2: asm volatile("fmov d23, %0" : : "r"(变换值3) : "d23"); break;
        case 3: asm volatile("fmov d24, %0" : : "r"(变换值4) : "d24"); break;
        case 4: asm volatile("fmov d25, %0" : : "r"(变换值5) : "d25"); break;
        case 5: asm volatile("fmov d26, %0" : : "r"(变换值6) : "d26"); break;
        case 6: asm volatile("fmov d27, %0" : : "r"(变换值7) : "d27"); break;
        case 7: asm volatile("fmov d28, %0" : : "r"(变换值8) : "d28"); break;
    }
    
    硬件安全缓冲区[次调度索引 + 8] = __builtin_bswap64(地址值 ^ 0x5A5A5A5A);
}

uintptr_t 读取硬件映射_霰弹枪() {
    uintptr_t val;
    asm volatile("mov %0, x20" : "=r"(val));
    
    // 缓冲区验证
    uintptr_t 缓冲区值 = 硬件安全缓冲区[硬件调度索引] ^ 0xA5A5A5A5;
    if (val != 缓冲区值) {
        return 缓冲区值; // 降级到缓冲区值
    }
    
    return val;
}

uintptr_t 读取硬件映射_通用武器() {
    uintptr_t 主地址;
    
    // 🔥 从 D19 读取主地址
    asm volatile("fmov %0, d19" : "=r"(主地址));
    
    // 验证：从备份D寄存器读取
    static int 上次写入索引 = 0;
    uintptr_t 备份值 = 0;
    
    switch(上次写入索引) {
        case 0: asm volatile("fmov %0, d21" : "=r"(备份值)); break;
        case 1: asm volatile("fmov %0, d22" : "=r"(备份值)); break;
        case 2: asm volatile("fmov %0, d23" : "=r"(备份值)); break;
        case 3: asm volatile("fmov %0, d24" : "=r"(备份值)); break;
        case 4: asm volatile("fmov %0, d25" : "=r"(备份值)); break;
        case 5: asm volatile("fmov %0, d26" : "=r"(备份值)); break;
        case 6: asm volatile("fmov %0, d27" : "=r"(备份值)); break;
        case 7: asm volatile("fmov %0, d28" : "=r"(备份值)); break;
    }
    
    // 反向变换验证
    uintptr_t 验证地址 = 0;
    switch(上次写入索引) {
        case 0: 验证地址 = 备份值 ^ 0x12345678; break;
        case 1: 验证地址 = __builtin_bswap64(备份值); break;
        case 2: 验证地址 = ~备份值; break;
        case 3: 验证地址 = 备份值 - 0x1000; break;
        case 4: 验证地址 = 备份值 + 0x1000; break;
        case 5: 验证地址 = 备份值 ^ 0xF0F0F0F0; break;
        case 6: 验证地址 = __builtin_bswap64(~备份值); break;
        case 7: 验证地址 = 备份值 / 0x9E3779B9; break;
    }
    
    if (主地址 == 验证地址) {
        上次写入索引 = (上次写入索引 + 1) & 7;
        return 主地址;
    } else {
        // 验证失败，从缓冲区恢复
        uintptr_t 缓冲区地址 = 硬件安全缓冲区[(上次写入索引 + 8) & 15];
        缓冲区地址 = __builtin_bswap64(缓冲区地址) ^ 0x5A5A5A5A;
        asm volatile("fmov d19, %0" : : "r"(缓冲区地址) : "d19");
        return 缓冲区地址;
    }
}




class 硬件映射控制器 {  // 原名：寄存器追踪
private:
    uintptr_t 主执行核心地址;      // 原名：reg_a
    uintptr_t 备用执行核心地址;     // 原名：reg_b
    uintptr_t 硬件状态校验字;      // 原名：reg_c
    uintptr_t 身份标识单元;        // 原名：reg_d
    bool 硬件映射就绪;             // 原名：寄存器就绪
    uintptr_t 基准映射地址;        // 原名：默认地址
    
public:
    硬件映射控制器() : 主执行核心地址(0), 备用执行核心地址(0), 硬件状态校验字(0), 
                      身份标识单元(0), 硬件映射就绪(false), 基准映射地址(0) {}
    
    // 设置基准地址
    void 设置基准地址(uintptr_t 地址) {
        基准映射地址 = 地址;
    }
    
    // 初始化硬件映射
    void 初始化硬件映射(uintptr_t 基础地址) {  // 原名：初始化寄存器
        基准映射地址 = 基础地址;
        主执行核心地址 = 基础地址;      // 主执行核心存放映射地址
        备用执行核心地址 = 基础地址;    // 备用执行核心
        硬件状态校验字 = 0x12345678;    // 硬件魔术字验证值
        身份标识单元 = (uintptr_t)this; // 自验证值
        硬件映射就绪 = true;
    }
    
    // 获取当前主执行核心地址
    uintptr_t 获取主核心地址() {  // 原名：获取追踪地址
        if (!硬件映射就绪 || !验证硬件完整性()) {
            return 基准映射地址; // 降级到基准地址
        }
        return 主执行核心地址;
    }
    
    // 获取备用执行核心地址
    uintptr_t 获取备用核心地址() {  // 原名：获取备用地址
        if (!硬件映射就绪) return 基准映射地址;
        return 备用执行核心地址;
    }
    
    // 更新主执行核心地址
    void 更新主核心地址(uintptr_t 新地址) {  // 原名：更新追踪地址
        if (!硬件映射就绪) return;
        备用执行核心地址 = 主执行核心地址;  // 当前地址备份到备用核心
        主执行核心地址 = 新地址;          // 更新主执行核心
        硬件状态校验字 = (主执行核心地址 ^ 备用执行核心地址) + 0xABCD1234;
    }
    
    // 验证硬件完整性
    bool 验证硬件完整性() {  // 原名：验证寄存器完整性
        if (!硬件映射就绪) return false;
        if (身份标识单元 != (uintptr_t)this) return false;
        if (硬件状态校验字 != ((主执行核心地址 ^ 备用执行核心地址) + 0xABCD1234)) return false;
        return true;
    }
    
    // 重新初始化硬件映射
    void 重新初始化映射(uintptr_t 新基础地址) {  // 原名：重新初始化
        初始化硬件映射(新基础地址);
    }
    
    // 获取硬件状态
    void 打印硬件状态() {  // 原名：打印寄存器状态
        printf("[硬件映射状态] 主核心=0x%lx, 备核心=0x%lx, 状态字=0x%lx, 身份标识=0x%lx, 基准地址=0x%lx, 就绪=%d\n", 
               主执行核心地址, 备用执行核心地址, 硬件状态校验字, 身份标识单元, 基准映射地址, 硬件映射就绪);
    }
};

// 全局硬件映射控制器实例
硬件映射控制器 硬件映射管理器;          // 原名：追踪寄存器管理器
硬件映射控制器 硬件映射管理器_霰弹枪;   // 原名：追踪寄存器管理器1







uintptr_t 硬件追踪函数;       // 原名：弹道追踪函数
uintptr_t 硬件追踪函数_霰弹枪; // 原名：弹道追踪函数1







硬件追踪函数 = 地址.libue4 + 0x87049AC;        
硬件追踪函数_霰弹枪 = 地址.libue4 + 0xCC95250;

    硬件映射管理器.设置基准地址(硬件追踪函数);
    硬件映射管理器_霰弹枪.设置基准地址(硬件追踪函数_霰弹枪);
    硬件映射管理器.初始化硬件映射(硬件追踪函数);
    硬件映射管理器_霰弹枪.初始化硬件映射(硬件追踪函数_霰弹枪);

    static uint32_t g_dynamic_key = 0;
    g_dynamic_key = (uint32_t)(time(NULL) ^ pid1 ^ 0x87049AC);
    
    for (int i = 0; i < 16; i++) {
        硬件安全缓冲区[i] = g_dynamic_key ^ (i * 0xCC95250);
    }
    
    硬件调度索引 = (int)(g_dynamic_key % 16);
    
    // 🔥 霰弹枪：使用原有的通用寄存器
    uintptr_t 验证霰弹枪地址 = 读取硬件映射_霰弹枪();
    
    // 🔥 自动步枪：使用新的D寄存器
    写入硬件映射_通用武器(硬件追踪函数);
    写入硬件映射_霰弹枪(硬件追踪函数_霰弹枪);
    
    
  /*  printf("[霰弹枪硬件初始化] 动态密钥:0x%X 霰弹枪地址:0x%lX 调度索引:%d\n", 
           g_dynamic_key, 验证霰弹枪地址, 硬件调度索引);
    printf("[自动枪械硬件初始化] ARM64 管理  动态密钥:0x%X\n");
*/

    
    
}








    {
        confuse_loop();

        // ================ 1. 弹道恢复机制（增强版） ================
        static bool 上次追踪状态 = 自瞄.开启追踪;
        if (上次追踪状态 == true && 自瞄.开启追踪 == false) {
            // 追踪从开启变为关闭，强制恢复所有弹道
            printf("[弹道恢复] 检测到追踪关闭，开始恢复原始弹道...\n");
            
            // 调用全局恢复函数
            强制恢复所有弹道();
        }
        上次追踪状态 = 自瞄.开启追踪;
        // ====================================================

        // ================ 2. 正确的武器分类逻辑 ================
        float 当前追踪概率 = 0.0f;
        bool 是喷子 = (散弹枪(自身数据.手持) == 1.0f);
        
        // 武器分类：只有喷子走特殊逻辑，其他所有武器都走普通武器逻辑
        if (是喷子) {
            // 霰弹枪使用喷子专属概率
            当前追踪概率 = 自瞄.喷子追踪概率;
        } else {
            // 所有非霰弹枪武器：单发狙、射手步枪、手枪、弓箭、自动武器等
            if (自身数据.开镜 == 1 || 自身数据.开镜 == 257) {
                当前追踪概率 = 自瞄.追踪开镜概率;
            } else {
                当前追踪概率 = 自瞄.追踪腰射概率;
            }
        }
        // ====================================================

        int 随机数 = dist(engine);
        // 正确的概率计算
        bool 触发概率追踪 = (随机数 <= static_cast<int>(当前追踪概率));

        // ================ 3. 开火检测优化 ================
        static const long long 追踪维持时间毫秒 = 300;
        static long long 上次有效开火时间戳 = 0;
        static bool 上次开火状态 = false;
        bool 应维持追踪状态 = false;  // 声明变量

        auto 当前时刻 = std::chrono::steady_clock::now();
        long long 当前时间戳 = std::chrono::duration_cast<std::chrono::milliseconds>(
            当前时刻.time_since_epoch()).count();

        bool 当前开火状态 = (自身数据.开火 == 1);
        bool 检测到开火信号 = (!上次开火状态 && 当前开火状态);

        if (检测到开火信号) {
            上次有效开火时间戳 = 当前时间戳;
        }

        if (当前开火状态) {
            应维持追踪状态 = true;
        } else if (上次有效开火时间戳 > 0) {
            long long 时间差 = 当前时间戳 - 上次有效开火时间戳;
            long long 实际维持时间 = 是喷子 ? 100 : 300;
            
            if (时间差 < 实际维持时间) {
                应维持追踪状态 = true;
            } else {
                上次有效开火时间戳 = 0;  // 超过时间重置
            }
        }

        上次开火状态 = 当前开火状态;
        // ====================================================

// 在 绘制::更新地址数据() 函数中修改

// ================ 4. 普通武器追踪（使用D寄存器） ================
if (自瞄.开启追踪 && lockBase && !是喷子 && 触发概率追踪 && 人物距离 <= 追踪距离限制 && 倒地不追 && 人机不追 && 应维持追踪状态) {
    if (!get_state(IDX_INJECTED)) {
        if (!get_state(IDX_HARDWARE_MAPPED_COMMON)) {
            uintptr_t target = 地址.libue4 + enc_offset_common();
            // 🔥 改为使用D寄存器版本
            写入硬件映射_通用武器(target);
            set_state(IDX_HARDWARE_MAPPED_COMMON, true);
            set_state(IDX_D_REGISTER_USED, true);  // 标记D寄存器已使用
        }
        InjectFunction(地址.libue4 + enc_offset_common(), (uintptr_t)hook3);
        set_state(IDX_INJECTED, true);
    }
} else {
    // 条件不满足时，清理普通武器追踪
    if (get_state(IDX_INJECTED) && (!自瞄.开启追踪 || !应维持追踪状态 || !触发概率追踪)) {
        uintptr_t addr = 地址.libue4 + enc_offset_common();
        for (int i = 0; i < 3; ++i) {
            读写.WriteDword(addr + i * 4, common_restore_enc[i] ^ g_dynamic_key);
        }
        set_state(IDX_INJECTED, false);
        set_state(IDX_HARDWARE_MAPPED_COMMON, false);
        set_state(IDX_D_REGISTER_USED, false);  // 清除D寄存器标记
    }
}
// ====================================================

// ================ 5. 霰弹枪追踪（保持原样，使用通用寄存器） ================
if (自瞄.开启追踪 && lockBase && 是喷子 && 人物距离 <= 追踪距离限制 && 倒地不追 && 人机不追) {
    // 霰弹枪：100%触发，立即追踪
    if (!get_state(IDX_INJECTED2)) {
        if (!get_state(IDX_HARDWARE_MAPPED_SHOTGUN)) {
            uintptr_t target = 地址.libue4 + enc_offset_shotgun();
            // 🔥 霰弹枪继续使用原有的通用寄存器版本
            写入硬件映射_霰弹枪(target);
            set_state(IDX_HARDWARE_MAPPED_SHOTGUN, true);
        }
        InjectFunction(地址.libue4 + enc_offset_shotgun(), (uintptr_t)hook3);
        set_state(IDX_INJECTED2, true);
    }
} else {
    // 条件不满足时，清理霰弹枪追踪
    if (get_state(IDX_INJECTED2) && (!自瞄.开启追踪 || !lockBase || !是喷子)) {
        uintptr_t addr = 地址.libue4 + enc_offset_shotgun();
        for (int i = 0; i < 3; ++i) {
            读写.WriteDword(addr + i * 4, shotgun_restore_enc[i] ^ g_dynamic_key);
        }
        set_state(IDX_INJECTED2, false);
        set_state(IDX_HARDWARE_MAPPED_SHOTGUN, false);
    }
}