// [原理示例] 3D 世界坐标到 2D 屏幕投影算法 (WorldToScreen)
struct Vector3 { float x, y, z; };
struct Vector2 { float x, y; };

struct Matrix4x4 {
    float m[4][4];
};

bool WorldToScreen(const Vector3& world_pos, const Matrix4x4& vMatrix, int screen_width, int screen_height, Vector2& out_screen) {
    // 1. 矩阵乘法计算裁剪坐标 (Clip Coordinates)
    float clip_w = world_pos.x * vMatrix.m[0][3] + world_pos.y * vMatrix.m[1][3] + world_pos.z * vMatrix.m[2][3] + vMatrix.m[3][3];
    
    // 如果 W <= 0.1f，说明目标位于摄像机背后，无需在屏幕上绘制
    if (clip_w <= 0.1f) return false;

    float clip_x = world_pos.x * vMatrix.m[0][0] + world_pos.y * vMatrix.m[1][0] + world_pos.z * vMatrix.m[2][0] + vMatrix.m[3][0];
    float clip_y = world_pos.x * vMatrix.m[0][1] + world_pos.y * vMatrix.m[1][1] + world_pos.z * vMatrix.m[2][1] + vMatrix.m[3][1];

    // 2. 透视除法，转换为标准化设备坐标 (NDC: -1.0 到 1.0)
    float ndc_x = clip_x / clip_w;
    float ndc_y = clip_y / clip_w;

    // 3. 映射为手机屏幕的像素绝对坐标
    out_screen.x = (screen_width / 2.0f) * (ndc_x + 1.0f);
    out_screen.y = (screen_height / 2.0f) * (1.0f - ndc_y); // Y轴反转

    return true;
}

// [原理示例] 英雄实体数据结构抽象伪代码
struct HeroEntity {
    uintptr_t vtable;         // 虚函数表指针
    Vector3   current_pos;    // 实时物理三维坐标 (X, Y, Z)
    float     current_hp;     // 当前生命值
    float     max_hp;         // 最大生命值
    int32_t   camp_id;        // 阵营编号 (例如: 1为己方, 2为敌方)
    
    // 【关键状态位】在特定偏移处 (如 0x718)
    bool      is_visible_enemy; // 是否向敌方阵营暴露 (0=未暴露, 1=已被敌方获取视野)
    bool      in_stealth;       // 是否处于隐身状态 (如兰陵王、阿轲隐身)
};

// 判定自身是否安全
void CheckBushSafety(HeroEntity* my_hero) {
    if (my_hero->is_visible_enemy) {
        // 触发预警：血条变红，并在屏幕中间弹出警告：“已被敌方洞察！”
        DrawWarningBanner("【危险】自身视野已暴露！");
    }
}

// [原理示例] 二维平面技能拦截前置量计算算法
Vector2 CalculatePredictiveAim(Vector2 my_pos, Vector2 enemy_pos, Vector2 enemy_velocity, float skill_speed) {
    Vector2 relative_pos = { enemy_pos.x - my_pos.x, enemy_pos.y - my_pos.y };

    // 建立相对运动二次方程: |relative_pos + enemy_velocity * t|^2 = (skill_speed * t)^2
    float a = (enemy_velocity.x * enemy_velocity.x + enemy_velocity.y * enemy_velocity.y) - (skill_speed * skill_speed);
    float b = 2.0f * (relative_pos.x * enemy_velocity.x + relative_pos.y * enemy_velocity.y);
    float c = (relative_pos.x * relative_pos.x + relative_pos.y * relative_pos.y);

    float discriminant = b * b - 4.0f * a * c;
    if (discriminant < 0.0f) {
        // 目标速度过快，在射程内无法拦截，直接瞄准当前位置
        return enemy_pos;
    }

    // 求解最小正时间 t
    float t1 = (-b - sqrt(discriminant)) / (2.0f * a);
    float t2 = (-b + sqrt(discriminant)) / (2.0f * a);
    float t = (t1 > 0.0f) ? t1 : t2;

    // 预判的打击坐标
    Vector2 predicted_target;
    predicted_target.x = enemy_pos.x + enemy_velocity.x * t;
    predicted_target.y = enemy_pos.y + enemy_velocity.y * t;
    return predicted_target;
}

// [反作弊原理示例] 服务端对多次秒换装的方差与物理特征判别算法
#include <vector>
#include <numeric>
#include <cmath>

struct SwapRecord {
    float total_duration_ms; // 单次换装总耗时
    float touch_pressure_variance; // 触控按压力的抖动幅度
    float touch_size_average;      // 手指接触面积
};

bool AnalyzeSwapBotBehavior(const std::vector<SwapRecord>& history) {
    if (history.size() < 5) {
        // 单场游戏只换了一次装，证据不足，坚决不误判！(这也是为什么你实测换一次不会被封的原因)
        return false;
    }

    // 1. 计算耗时的平均值 (Mean) 与方差 (Variance)
    float sum = 0.0f;
    for (const auto& r : history) sum += r.total_duration_ms;
    float mean = sum / history.size();

    float variance_sum = 0.0f;
    for (const auto& r : history) {
        variance_sum += (r.total_duration_ms - mean) * (r.total_duration_ms - mean);
    }
    float variance = variance_sum / history.size();

    // 2. 判别准则 A: 极速且超高稳定性 (人类无论怎么练，在紧张团战中方差必然很大)
    // 如果平均耗时 < 320ms，而且方差极小 (< 50)，哪怕用了高斯拟人伪装，数学统计也会暴露出是算法生成的假随机
    if (mean < 320.0f && variance < 45.0f) {
        return true; // 判定为换装脚本
    }

    // 3. 判别准则 B: 物理压力特征审计
    for (const auto& r : history) {
        // 真实人手按屏幕，触摸面积和压力必须有动态变化
        // 如果虚拟节点注入的事件没有真实的压力扰动 (触控压力方差几乎为 0)
        if (r.touch_pressure_variance <= 0.001f) {
            return true; // 判定为底层虚拟注入
        }
    }

    return false;
}

// [反作弊原理示例] 动态实体指针混淆机制
class AntiCheatActorManager {
private:
    uintptr_t obfuscation_key; // 动态随机异或密钥
    HeroEntity* real_entity_ptr;

public:
    void RefreshPointersAtGameEvents() {
        // 每到 2:20 或团战爆发时，将原有实体深拷贝至随机内存地址，并销毁旧内存
        HeroEntity* new_location = (HeroEntity*)malloc(sizeof(HeroEntity));
        memcpy(new_location, real_entity_ptr, sizeof(HeroEntity));

        // 抹除旧内存，写入垃圾虚假数据让外挂读取错误数值
        memset(real_entity_ptr, 0, sizeof(HeroEntity));

        // 生成新密钥
        obfuscation_key = generate_random_seed();
        real_entity_ptr = new_location;
    }

    // 官方代码取实体时必须经过解密
    HeroEntity* GetActor() {
        return (HeroEntity*)((uintptr_t)real_entity_ptr ^ obfuscation_key);
    }
};