Hitbox.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstdint>
#include <glm/glm.hpp>
#include <string>
#include <unordered_map>
#include <vector>


enum class BodyRegion : uint8_t
{
    Head,
    Neck,
    UpperTorso,
    LowerTorso,
    LeftUpperArm,
    LeftLowerArm,
    RightUpperArm,
    RightLowerArm,
    LeftUpperLeg,
    LeftLowerLeg,
    RightUpperLeg,
    RightLowerLeg,
    Count
};

inline const char* bodyRegionName(BodyRegion region)
{
    switch (region) {
    case BodyRegion::Head:
        return "Head";
    case BodyRegion::Neck:
        return "Neck";
    case BodyRegion::UpperTorso:
        return "Upper Torso";
    case BodyRegion::LowerTorso:
        return "Lower Torso";
    case BodyRegion::LeftUpperArm:
        return "L Upper Arm";
    case BodyRegion::LeftLowerArm:
        return "L Lower Arm";
    case BodyRegion::RightUpperArm:
        return "R Upper Arm";
    case BodyRegion::RightLowerArm:
        return "R Lower Arm";
    case BodyRegion::LeftUpperLeg:
        return "L Upper Leg";
    case BodyRegion::LeftLowerLeg:
        return "L Lower Leg";
    case BodyRegion::RightUpperLeg:
        return "R Upper Leg";
    case BodyRegion::RightLowerLeg:
        return "R Lower Leg";
    case BodyRegion::Count:
        return "(none)";
    }
    return "(unknown)";
}


struct HitboxDef
{
    std::string boneName;                       
    int boneIndex = -1;                         
    BodyRegion region = BodyRegion::UpperTorso; 
    glm::vec3 localOffset{0.0f};                
    float radius = 4.0f;                        
    float halfHeight = 4.0f;                    
    glm::vec3 localAxis{0.0f, 1.0f, 0.0f};      
};


struct WorldCapsule
{
    glm::vec3 pointA{0.0f};                     
    glm::vec3 pointB{0.0f};                     
    float radius = 0.0f;                        
    BodyRegion region = BodyRegion::UpperTorso; 
};


struct HitboxInstance
{
    std::vector<WorldCapsule> capsules; 
};

struct JointMatrices
{
    std::vector<glm::mat4> matrices; 
};


struct DamageProfile
{
    // clang-format off
    std::array<float, static_cast<size_t>(BodyRegion::Count)> multipliers = {{
        2.00f,  // Head
        1.80f,  // Neck
        1.00f,  // UpperTorso
        1.00f,  // LowerTorso
        1.00f,  // LeftUpperArm
        1.00f,  // LeftLowerArm
        1.00f,  // RightUpperArm
        1.00f,  // RightLowerArm
        1.00f,  // LeftUpperLeg
        0.8f,  // LeftLowerLeg
        0.8f,  // RightUpperLeg
        0.8f,  // RightLowerLeg
    }};
    // clang-format on
};

inline const DamageProfile& defaultDamageProfile()
{
    static const DamageProfile profile;
    return profile;
}


struct HitboxRig
{
    std::vector<HitboxDef> definitions;

    static HitboxRig buildMixamoDefault()
    {
        HitboxRig rig;
        auto& defs = rig.definitions;
        defs.reserve(12);
 
        // clang-format off
        // NOTE: In Mixamo rigs imported via assimp/ozz the bone-local +Y axis
        // points from child toward parent (i.e. "up" for legs, "inward" for arms).
        // Therefore offsets that push the capsule ALONG the bone (toward the child
        // joint) use negative Y.  The localAxis {0,-1,0} makes halfHeight extend
        // in the -Y direction (along the bone) so the capsule covers from the bone
        // origin toward the next joint. All magnitudes are WORLD units (player = 72 tall).
        //                boneName                        region                       offset                radius  halfH  axis
        defs.push_back({"mixamorig:Head",          -1, BodyRegion::Head,          {0,    3.4f, 1.1f},    5.8f,  1.0f, {0,-1,0}});
        defs.push_back({"mixamorig:Neck",          -1, BodyRegion::Neck,          {0,    1.3f, 0.6f},    2.5f,  0.8f, {0,-1,0}});
        defs.push_back({"mixamorig:Spine2",        -1, BodyRegion::UpperTorso,    {0,   -2.8f, 0},       7.45f, 2.5f, {0,-1,0}});
        defs.push_back({"mixamorig:Spine1",        -1, BodyRegion::LowerTorso,    {0,   -9.05f,-0.8f},   8.0f,  0.9f, {0,-1,0}});
        defs.push_back({"mixamorig:LeftArm",       -1, BodyRegion::LeftUpperArm,  {0,    4.2f, 0},       2.8f,  5.1f, {0,-1,0}});
        defs.push_back({"mixamorig:LeftForeArm",   -1, BodyRegion::LeftLowerArm,  {0,    9.7f, 0},       2.5f,  7.7f, {0,-1,0}});
        defs.push_back({"mixamorig:RightArm",      -1, BodyRegion::RightUpperArm, {0,    4.2f, 0},       2.8f,  5.1f, {0,-1,0}});
        defs.push_back({"mixamorig:RightForeArm",  -1, BodyRegion::RightLowerArm, {0,    9.7f, 0},       2.5f,  7.7f, {0,-1,0}});
        defs.push_back({"mixamorig:LeftUpLeg",     -1, BodyRegion::LeftUpperLeg,  {-1.1f,10.4f, 0},      4.4f,  6.5f, {0,-1,0}});
        defs.push_back({"mixamorig:LeftLeg",       -1, BodyRegion::LeftLowerLeg,  {0,   10.4f, 0},       4.4f,  8.5f, {0,-1,0}});
        defs.push_back({"mixamorig:RightUpLeg",    -1, BodyRegion::RightUpperLeg, {1.1f, 10.4f, 0},      4.4f,  6.5f, {0,-1,0}});
        defs.push_back({"mixamorig:RightLeg",      -1, BodyRegion::RightLowerLeg, {0,   10.4f, 0},       4.4f,  8.5f, {0,-1,0}});
        // clang-format on
 
        return rig;
    }

    void resolveIndices(const std::unordered_map<std::string, int>& jointMap)
    {
        for (auto& def : definitions) {
            auto it = jointMap.find(def.boneName);
            if (it != jointMap.end()) {
                def.boneIndex = it->second;
            } else {
                def.boneIndex = -1;
            }
        }
    }
};


struct HitDebugSnapshot
{
    uint32_t tick = 0;                              
    glm::vec3 shooterEye{0.0f};                     
    glm::vec3 shooterDir{0.0f};                     
    glm::vec3 targetPos{0.0f};                      
    float targetYaw = 0.0f;                         
    std::vector<WorldCapsule> clientCapsules;       
    std::vector<WorldCapsule> serverCapsules;       
    BodyRegion clientHitRegion = BodyRegion::Count; 
    bool serverConfirmed = false;                   
    bool serverRejected = false;                    
};