HudTypes.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "network/MatchStatus.hpp"
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <glm/glm.hpp>
#include <span>
#include <string>
 
class InputBindings;
enum class BindingDevice : std::uint8_t;
 
// ── Colors ──────────────────────────────────────────────────────────────────

struct HudColor
{
    float r = 1.f, g = 1.f, b = 1.f, a = 1.f;
 
    constexpr HudColor() = default;
    constexpr HudColor(float r_, float g_, float b_, float a_ = 1.f) : r(r_), g(g_), b(b_), a(a_) {}
 
    static constexpr HudColor white() { return {1, 1, 1, 1}; }
    static constexpr HudColor black() { return {0, 0, 0, 1}; }
    static constexpr HudColor red() { return {1, 0, 0, 1}; }
    static constexpr HudColor green() { return {0, 1, 0, 1}; }
    static constexpr HudColor yellow() { return {1, 1, 0, 1}; }
    static constexpr HudColor cyan() { return {0, 1, 1, 1}; }
    static constexpr HudColor transparent() { return {0, 0, 0, 0}; }
};
 
// ── Enums ───────────────────────────────────────────────────────────────────
 
enum class HudAnchor
{
    TopLeft,
    TopCenter,
    TopRight,
    CenterLeft,
    Center,
    CenterRight,
    BottomLeft,
    BottomCenter,
    BottomRight,
};
 
enum class HudAlign
{
    Left,
    Center,
    Right,
};

enum class HudIcon : uint8_t
{
    None = 0,
    AbilityBarBack,
    AbilityBarFront,
    AbilityIconFrame,
    BulletCountBox,
    GrenadeBox,
    HealthFrameBack,
    HealthFrameFront,
    LetterButton,
    LevelBarBack,
    LevelBarFront,
    NoIcon,
    Radar,
    Scoreboard,
    EnemyDiamond,
    Fall,
    DashAbilityIcon,
    Grapple,
    GrappleAbilityIcon,
    Gravity,
    GravityAbilityIcon,
    LevitateAbilityIcon,
    Grenade,
    FragGrenadeIcon,
    MolotovGrenadeIcon,
    StickyGrenadeIcon,
    Headshot,
    Hp,
    PlayerArrow,
    Shield,
    Skull,
    Tactical,
    WallhackAbilityIcon,
    RecallAbilityIcon,
    TopDecal,
    BottomDecal,
    WeaponFrame,
    ARIcon,
    RocketLauncherIcon,
    RailGunIcon,
    TrackingGunIcon,
};

enum class HudPopupKind : std::uint8_t
{
    Info,         
    Success,      
    Warning,      
    PlayerJoined, 
    PlayerLeft    
};
 
// ── Vertex ──────────────────────────────────────────────────────────────────

struct HudVertex
{
    float position[2];  
    float uv[2];        
    float color[4];     
    float texMode;      
    float shapeData[3]; 
};
 
// ── Crosshair ───────────────────────────────────────────────────────────────

struct CrosshairStyle
{
    float gap = 3.f;                                              
    float length = 6.f;                                           
    float thickness = 2.f;                                        
    HudColor color{0.168627f, 0.694118f, 0.741176f, 0.85f};       
    bool dot = true;                                              
    float reloadRadius = 20.f;                                    
    float reloadThickness = 2.f;                                  
    HudColor reloadColor{0.168627f, 0.694118f, 0.741176f, 0.85f}; 
};
 
// ── Game State Contract ─────────────────────────────────────────────────────

struct HudKillFeedEntry
{
    std::string killerName;
    std::string victimName;
    int weaponId = 0;
    bool isHeadshot = false;
};

struct HudDamageEvent
{
    float angleDeg = 0.f; 
    float amount = 0.f;   
};

struct HudHitConfirm
{
    bool isHeadshot = false;
    bool isKill = false;
    bool shieldBreak = false; 
};

struct HudDamageNumber
{
    float worldX = 0.f, worldY = 0.f, worldZ = 0.f; 
    int damage = 0;                                 
    bool headshot = false;
    bool shielded = false;                          
};

struct HudDamageAccum
{
    int total = 0;                                        
    HudColor color{0.168627f, 0.694118f, 0.741176f, 1.f}; 
};

struct HudTeamMemberStatus
{
    std::string name;
    HudColor color = HudColor::white();
    int health = 100;
    bool isAlive = true;
    bool isLocal = false;
    int kills = 0;
    int deaths = 0;
    int ping = 0;
};

struct HudMinimapDot
{
    float worldX = 0.f, worldZ = 0.f;
};

struct HudWorldEnemy
{
    float worldX = 0.f, worldY = 0.f, worldZ = 0.f; 
    std::string name;                               
    int health = 100, maxHealth = 100;
    int armor = 0, maxArmor = 100;
    bool isAlive = true;
    bool occluded = false; 
};

struct HudKillerBox
{
    bool valid = false;          
    glm::vec3 center{0.f};       
    glm::vec3 halfExtents{0.f};  
    std::string name;            
};

struct HudEquipmentState
{
    std::string primaryAbilityName = "LOCKED";
    std::string secondaryAbilityName = "LOCKED";
    std::string grenadeName = "FRAG";
    float primaryAbilityCharge = 1.f;   
    float secondaryAbilityCharge = 1.f; 
    bool primaryAbilityAvailable = false;
    bool secondaryAbilityAvailable = false;
    bool secondaryAbilityMarked = false;
    float grappleCharge = 1.f;  
    float grenadeCharge = 1.f;  
    float tacticalCharge = 1.f; 
    int grenadeCount = 2;       
    int tacticalCount = 1;      
};
 
inline constexpr std::size_t kHudGrenadeSlots = 3;
 
struct HudGrenadeRadialItem
{
    std::string name;
    int count = 0;
    bool available = true;
};
 
struct HudGrenadeRadialState
{
    bool open = false;
    int selectedIndex = -1;
    std::array<HudGrenadeRadialItem, kHudGrenadeSlots> items;
};

struct HudEmoteWheelState
{
    bool open = false;       
    int selectedIndex = -1;  
};
 
struct HudAbilityChoice
{
    std::string name;
    std::string description;
};
 
struct HudAbilitySelectionState
{
    bool available = false;
    bool modifierHeld = false;
    int level = 0;
    std::string slotLabel;
    std::array<HudAbilityChoice, 2> choices;
};

struct HudPickupNotification
{
    std::string label; 
    int qty = 1;       
};

struct HudPopupMessage
{
    HudPopupKind kind = HudPopupKind::Info; 
    std::string text;                       
};

struct HudKdaCounter
{
    int kills = 0;
    int deaths = 0;
    int assists = 0;
};
 
struct HudChatMessage
{
    std::string senderName;
    std::string message;
    float ageSeconds = 0.f;
    bool fromLocal = false;
};
 
struct HudChatState
{
    bool open = false;
    std::string draft;
    std::span<const HudChatMessage> messages;
};
 
struct HudVoiceSpeaker
{
    std::string senderName;
};

struct HudMatchInfo
{
    float elapsedSeconds = 0.f; 
    int fragTarget = 30;        
    bool valid = false;         
};

struct HudShotgunPellet
{
    enum class Result : uint8_t
    {
        Miss = 0,
        Body = 1,
        Head = 2,
    };
    Result result = Result::Miss;
};

struct HudShotgunBlast
{
    bool valid = false;           
    float secondsSinceFire = 0.f; 
    std::array<HudShotgunPellet, 11> pellets{};
};

struct HudGameState
{
    const InputBindings* bindings = nullptr; 
    BindingDevice activeInputDevice{};       
 
    int health = 100, maxHealth = 100;
    int armor = 0, maxArmor = 100;
    int overShield = 0, maxOverShield = 200;
    float abilityLevelProgress = 0.f; 
    int abilityLevel = 0;
    int ammoClip = 30, ammoReserve = 90;
    int weaponId = 0;
    int primaryWeaponId = 0;   
    int secondarySlotWeaponId = 2; 
    int activeWeaponSlot = 0;      
    bool railgunScoped = false;    
    float railgunChargeTime = 0.f; 
    float roundTimeRemaining = 0.f;
    bool isAlive = true;
    MatchPhase currentPhase = MatchPhase::IN_PROGRESS; 
    bool matchWon = false;                             
    bool forceScoreboardOpen = false;                  
    bool isReloading = false;
    float reloadProgress = 0.0f;                       
 
    // Events (valid for this frame only).
    std::span<const HudKillFeedEntry> killFeedEvents;
    std::span<const HudDamageEvent> damageEvents;
    std::span<const HudHitConfirm> hitConfirms;
    std::span<const HudDamageNumber> damageNumbers; 
    HudDamageAccum damageAccum;                     
    HudShotgunBlast latestShotgunBlast;             
 
    // View/projection for world→screen projection (damage numbers).
    glm::mat4 viewProj{1.f};
 
    // Team status.
    std::span<const HudTeamMemberStatus> allies;
    std::span<const HudTeamMemberStatus> enemies;
    int allyScore = 0, enemyScore = 0;
 
    // Minimap.
    float localPlayerX = 0.f, localPlayerZ = 0.f;
    float localPlayerYaw = 0.f;       
    std::span<const HudMinimapDot> enemyDots;
    float minimapWorldRange = 4000.f; 
 
    // Vignette events (set by Game each frame based on health/armor deltas).
    bool tookDamage = false;     
    float damageIntensity = 0.f; 
    bool armorBroke = false;     
    // isAlive already covers death vignette.
 
    // Weapon pickup prompt — populated by Game when the local player is in
    // range of (and looking at) an available weapon spawner. The HUD reads
    // these to render a "Press <binding> to pick up <Weapon>" hint.
    bool pickupAvailable = false; 
    int pickupWeaponId = 0;       
 
    // Voidfall HUD additions.
    std::span<const HudWorldEnemy> worldEnemies;                
    HudEquipmentState equipment;                                
    HudGrenadeRadialState grenadeRadial;                        
    HudEmoteWheelState emoteWheel;                              
    HudKillerBox killerBox;                                    
    HudAbilitySelectionState abilitySelection;                  
    std::span<const HudPickupNotification> pickupNotifications; 
    std::span<const HudPopupMessage> popupMessages;             
    HudKdaCounter kda;                                          
    HudChatState chat;                                          
    std::span<const HudVoiceSpeaker> voiceSpeakers;             
    HudMatchInfo matchInfo;   
    int gravityDirection = 0; 
 
    // Inactive-slot weapon snapshot (drives the small weapon slot sub-row at
    // the bottom of the weapon panel — i.e. the
    // *other* weapon, whichever the player isn't currently holding).
    int secondaryWeaponId = -1; 
    int secondaryClip = 0;      
    int secondaryReserve = 0;   
    int secondaryKeybind = 2;   
 
    // Magazine capacities — sourced from WeaponConfig.magazineSize each frame
    // so the HUD never hardcodes per-weapon constants.
    int magCapacity = 0;          
    int secondaryMagCapacity = 0; 
 
    // Screen dimensions (set by Game each frame).
    float screenW = 1280.f, screenH = 720.f;
};