chr_shared.h

Go to the documentation of this file.

 
/*
Copyright (C) 2002-2025 UFO: Alien Invasion.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
*/
 
#pragma once
 
typedef enum {
    KILLED_ENEMIES,     
    KILLED_CIVILIANS,   
    KILLED_TEAM,        
 
    KILLED_NUM_TYPES
} killtypes_t;

typedef enum {
    ABILITY_POWER,
    ABILITY_SPEED,
    ABILITY_ACCURACY,
    ABILITY_MIND,
 
    SKILL_CLOSE,
    SKILL_HEAVY,
    SKILL_ASSAULT,
    SKILL_SNIPER,
    SKILL_EXPLOSIVE,
    /* Pilot skills */
    SKILL_PILOTING,
    SKILL_TARGETING,
    SKILL_EVADING,
    SKILL_NUM_TYPES
} abilityskills_t;
 
#define ABILITY_NUM_TYPES SKILL_CLOSE
 
typedef struct chrTemplate_s {
    char id[MAX_VAR];                   
    float rate;                         
    int skills[SKILL_NUM_TYPES + 1][2]; 
} chrTemplate_t;

typedef struct chrScoreMission_s {
    /* Movement counts. */
    int movedNormal;
    int movedCrouched;
 
    /* Kills & stuns */
    int kills[KILLED_NUM_TYPES];    
    int stuns[KILLED_NUM_TYPES];    
 
    /* Hits/Misses */
    int fired[SKILL_NUM_TYPES];                 
    int firedTUs[SKILL_NUM_TYPES];              
    bool firedHit[KILLED_NUM_TYPES];            
    int hits[SKILL_NUM_TYPES][KILLED_NUM_TYPES];    
    int firedSplash[SKILL_NUM_TYPES];               
    int firedSplashTUs[SKILL_NUM_TYPES];            
    bool firedSplashHit[KILLED_NUM_TYPES];          
    int hitsSplash[SKILL_NUM_TYPES][KILLED_NUM_TYPES];          
    int hitsSplashDamage[SKILL_NUM_TYPES][KILLED_NUM_TYPES];    
    int skillKills[SKILL_NUM_TYPES];    
 
    int heal;               
    int carriedWeight;  
 
    inline chrScoreMission_s () {
        init();
    }
    inline void init () {
        OBJZERO(*this);
    }
} chrScoreMission_t;

typedef struct chrScoreGlobal_s {
    int experience[SKILL_NUM_TYPES + 1];    
 
    int skills[SKILL_NUM_TYPES];            
    int initialSkills[SKILL_NUM_TYPES + 1]; 
 
    /* Kills & Stuns */
    int kills[KILLED_NUM_TYPES];    
    int stuns[KILLED_NUM_TYPES];    
 
    int assignedMissions;           
 
    int rank;                       
 
    inline chrScoreGlobal_s () :
        assignedMissions(0),
        rank(0)
    {
        OBJZERO(experience);
        OBJZERO(skills);
        OBJZERO(initialSkills);
        OBJZERO(kills);
        OBJZERO(stuns);
    }
} chrScoreGlobal_t;
 
class FiremodeSettings {
    actorHands_t _hand;     
    fireDefIndex_t _fmIdx;  
    const objDef_t* _weapon;
 
public:
 
    inline FiremodeSettings () : _hand(ACTOR_HAND_NOT_SET), _fmIdx(0), _weapon(nullptr) {}
    inline bool isSaneFiremode () const {
        return _hand > ACTOR_HAND_NOT_SET && _fmIdx >= 0 && _fmIdx < MAX_FIREDEFS_PER_WEAPON && _weapon != nullptr;
    }
 
    inline int getFmIdx () const {
        return _fmIdx;
    }
 
    inline const objDef_t* getWeapon () const {
        return _weapon;
    }
 
    inline actorHands_t getHand () const {
        return _hand;
    }
 
    inline void setHand (const actorHands_t hand) {
        _hand = hand;
    }
 
    inline void set (const actorHands_t hand, const fireDefIndex_t fmIdx, const objDef_t* weapon) {
        _hand = hand;
        _fmIdx = fmIdx;
        _weapon = weapon;
    }
};

typedef struct chrReservations_s {
    /* Reaction fire reservation (for current turn and next enemy turn) */
    int reaction;   
 
    /* Crouch reservation (for current turn) */
    int crouch; 
 
    /* Shot reservation (for current turn) */
    int shot;   
    FiremodeSettings shotSettings;  
 
    inline chrReservations_s () :
        reaction(0),
        crouch(0),
        shot(0),
        shotSettings(FiremodeSettings())
    {
    }
} chrReservations_t;
 
typedef enum {
    RES_REACTION,
    RES_CROUCH,
    RES_SHOT,
    RES_ALL,
    RES_ALL_ACTIVE,
    RES_TYPES 
} reservation_types_t;

typedef enum {
    SND_DEATH,  
    SND_HURT,   
 
    SND_MAX
} actorSound_t;
 
/* team definitions */
 
#define MAX_UGV                 8
#define MAX_TEAMDEFS            64
#define MAX_CHARACTER_TEMPLATES 24
#define MAX_TEMPLATES_PER_TEAM  16
 
typedef enum {
    NAME_NEUTRAL,
    NAME_FEMALE,
    NAME_MALE,
 
    NAME_LAST,
    NAME_FEMALE_LAST,
    NAME_MALE_LAST,
 
    NAME_NUM_TYPES
} nametypes_t;

typedef struct ugv_s {
    char* id;
    int idx;
    char weapon[MAX_VAR];
    char armour[MAX_VAR];
    int tu;
    char actors[MAX_VAR];
    int price;
} ugv_t;
 
enum modifier_types_t {
     MODIFIER_ACCURACY,     
     MODIFIER_SHOOTING,     
     MODIFIER_MOVEMENT,     
     MODIFIER_SIGHT,        
     MODIFIER_REACTION,     
     MODIFIER_TU,           
 
     MODIFIER_MAX
};
 
#define BODYPART_MAXTYPE 4
 
class BodyPartData {
public:
    char id[MAX_TEXPATH];
    char name[MAX_TEXPATH];
    int penalties[MODIFIER_MAX];
    vec4_t shape;
    int bleedingFactor;
    int woundThreshold;
};
 
class BodyData {
private:
    char _id[MAX_TEXPATH];
    BodyPartData _bodyParts[BODYPART_MAXTYPE];
    float _totalBodyArea;
    short _numBodyParts;
 
public:
    BodyData(void);
    const char* id(void) const;
    const char* id(const short bodyPart) const;
    const char* name(const short bodyPart) const;
    float penalty(const short bodyPart, const modifier_types_t type) const;
    float bleedingFactor(const short bodyPart) const;
    float woundThreshold(const short bodyPart) const;
    short getRandomBodyPart(void) const;
    short numBodyParts (void) const;
    void setId(const char* id);
    void addBodyPart(const BodyPartData& bodyPart);
    short getHitBodyPart(const byte direction, const float height) const;
    float getArea(const short bodyPart) const;
};
 
typedef struct teamNames_s {
    char id[MAX_VAR];                       
    linkedList_t* names[NAME_NUM_TYPES];    
    int numNames[NAME_NUM_TYPES];           
} teamNames_t;
 
typedef struct teamDef_s {
    int idx;                    
    char id[MAX_VAR];           
    char name[MAX_VAR];         
    char tech[MAX_VAR];         
    char footstepSound[MAX_VAR];
 
    linkedList_t* const* names; 
    const int* numNames;        
 
    struct model_t {
        char* path;
        char* body;
        char* head;
        int   bodySkin;
        int   headSkin;
    };
 
    linkedList_t* models[NAME_LAST];    
    int numModels[NAME_LAST];           
 
    linkedList_t* sounds[SND_MAX][NAME_LAST];   
    int numSounds[SND_MAX][NAME_LAST];  
 
    int team;       
 
    bool robot;
    bool armour;    
    bool weapons;   
    const objDef_t* onlyWeapon; 
 
    actorSizeEnum_t size;               
    char hitParticle[MAX_VAR];          
    char deathTextureName[MAX_VAR];     
 
    short resistance[MAX_DAMAGETYPES];  
 
    const chrTemplate_t* characterTemplates[MAX_TEMPLATES_PER_TEAM];
    int numTemplates;
 
    const BodyData* bodyTemplate;
 
    const char* getActorSound(int gender, actorSound_t soundType) const;
 
//  can't add this simple constructor because in scripts.cpp, teamDefValues 'offsetof' is used on teamdef_t
//  inline teamDef_s () {
//      OBJZERO(*this);
//  }
} teamDef_t;

typedef struct woundInfo_s {
    int woundLevel[BODYPART_MAXTYPE];
    int treatmentLevel[BODYPART_MAXTYPE];
 
    inline woundInfo_s () {
        OBJZERO(woundLevel);
        OBJZERO(treatmentLevel);
    }
} woundInfo_t;
 
#define MAX_CHARACTER_IMPLANTS 4
typedef struct implant_s {
    const implantDef_t* def;    
    int installedTime;          
    int removedTime;            
    int trigger;
 
    inline implant_s () :
        def(nullptr),
        installedTime(0),
        removedTime(0),
        trigger(0)
    {
    }
} implant_t;

typedef struct character_s {
    int ucn;                    
    char name[MAX_VAR];         
    char path[MAX_VAR];
    char body[MAX_VAR];
    char head[MAX_VAR];
    int bodySkin;               
    int headSkin;               
 
    int HP;                     
    int minHP;                  
    int maxHP;                  
    int STUN;
    int morale;
    woundInfo_t wounds;         
 
    int state;                  
 
    chrScoreGlobal_t score;     
    chrScoreMission_t* scoreMission;    
 
    actorSizeEnum_t fieldSize;
 
    Inventory inv;              
 
    const teamDef_t* teamDef;       
    int gender;                     
    chrReservations_t reservedTus;  
    FiremodeSettings RFmode;        
 
    implant_t implants[MAX_CHARACTER_IMPLANTS];
 
    character_s();                  
    void init ();
} character_t;
 
/* ================================ */
/*  CHARACTER GENERATING FUNCTIONS  */
/* ================================ */
 
const chrTemplate_t* CHRSH_GetTemplateByID(const teamDef_t* teamDef, const char* templateId);
void CHRSH_CharGenAbilitySkills(character_t* chr, bool multiplayer, const char* templateId = "") __attribute__((nonnull));
const char* CHRSH_CharGetBody(const character_t* const chr) __attribute__((nonnull));
const char* CHRSH_CharGetHead(const character_t* const chr) __attribute__((nonnull));
bool CHRSH_IsTeamDefAlien(const teamDef_t* const td) __attribute__((nonnull));
bool CHRSH_IsTeamDefRobot(const teamDef_t* const td) __attribute__((nonnull));
bool CHRSH_IsArmourUseableForTeam(const objDef_t* od, const teamDef_t* teamDef);
const implant_t* CHRSH_ApplyImplant(character_t& chr, const implantDef_t& implant);
void CHRSH_UpdateImplants(character_t& chr);