inv_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
 
struct csi_s;

typedef short humanAircraftType_t;
#define DROPSHIP_MAX 8
#define INTERCEPTOR_MAX 12
#define AIRCRAFTTYPE_MAX (DROPSHIP_MAX + INTERCEPTOR_MAX)
 
/* this is the absolute max for now */
#define MAX_OBJDEFS     144
#define MAX_IMPLANTS    16
#define MAX_MAPDEFS     256
#define MAX_WEAPONS_PER_OBJDEF 4
#define MAX_AMMOS_PER_OBJDEF 4
#define MAX_FIREDEFS_PER_WEAPON 8
#define WEAPON_BALANCE 0.5f
#define SKILL_BALANCE 1.0f
 
typedef int32_t containerIndex_t;
#define CID_RIGHT       0
#define CID_LEFT        1
#define CID_IMPLANT     2
#define CID_HEADGEAR    3
#define CID_BACKPACK    4
#define CID_BELT        5
#define CID_HOLSTER     6
#define CID_ARMOUR      7
#define CID_FLOOR       8
#define CID_EQUIP       9
#define CID_MAX         10
 
inline bool isValidContId(const containerIndex_t id)
{
    return (id >= 0 && id < CID_MAX);
}

typedef enum {
    IA_NONE,            
 
    IA_MOVE,            
    IA_ARMOUR,          
    IA_RELOAD,          
    IA_RELOAD_SWAP,     
 
    IA_NOTIME,          
    IA_NORELOAD         
} inventory_action_t;
 
typedef int32_t weaponFireDefIndex_t;
typedef int32_t fireDefIndex_t;
 
typedef enum {
    EFFECT_ACTIVE,
    EFFECT_INACTIVE,
    EFFECT_OVERDOSE,
    EFFECT_STRENGTHEN,
    EFFECT_MAX
} effectStages_t;
 
typedef struct itemEffect_s {
    bool isPermanent;   
    int duration;       
    int period;         
 
    /* all in percent */
    float accuracy;
    float TUs;
    float power;
    float mind;
    float morale;
} itemEffect_t;
 
typedef struct implantDef_s {
    const char* id;
    int idx;
    const struct objDef_s* item;    
    int installationTime;   
    int removeTime;         
} implantDef_t;

typedef struct fireDef_s {
    const char* name;           
    const char* projectile;     
    const char* impact;         
    const char* impactSound;    
    const char* hitBody;        
    const char* hitBodySound;   
    const char* fireSound;      
    const char* bounceSound;    
 
    float fireAttenuation;      
    float impactAttenuation;    
 
    /* These values are created in Com_ParseItem and Com_AddObjectLinks.
     * They are used for self-referencing the firedef. */
    const struct objDef_s* obj;     
    weaponFireDefIndex_t weapFdsIdx;    
    fireDefIndex_t fdIdx;       
    itemEffect_t* activeEffect;
    itemEffect_t* deactiveEffect;
    itemEffect_t* overdoseEffect;
 
    bool soundOnce;     
    bool gravity;       
    bool launched;      
    bool rolled;        
    bool reaction;      
    bool irgoggles;     
    byte dmgweight;     
    int throughWall;    
    float speed;        
    vec2_t shotOrg;     
    vec2_t spread;      
    int delay;          
    int bounce;         
    float bounceFac;    
    float crouch;       
    float range;        
    int shots;          
    int ammo;           
    float delayBetweenShots;    
    int time;           
    vec2_t damage;      
    vec2_t spldmg;      
    float splrad;       
    int weaponSkill;    
    int rounds;         
 
    void getShotOrigin (const vec3_t from, const vec3_t dir, bool crouching, vec3_t shotOrigin) const;
} fireDef_t;

#define SHAPE_SMALL_MAX_WIDTH 8
#define SHAPE_SMALL_MAX_HEIGHT 4

#define SHAPE_BIG_MAX_HEIGHT 16
#define SHAPE_BIG_MAX_WIDTH 32

typedef enum {
    /* weapons */
    AC_ITEM_BASE_MISSILE,   
    AC_ITEM_BASE_LASER,     
    AC_ITEM_WEAPON,         
 
    /* misc */
    AC_ITEM_SHIELD,         
    AC_ITEM_ELECTRONICS,    
 
    /* Crew */
    AC_ITEM_PILOT,
 
    /* ammos */
    AC_ITEM_AMMO,           
    AC_ITEM_AMMO_MISSILE,   
    AC_ITEM_AMMO_LASER,     
 
    MAX_ACITEMS
} aircraftItemType_t;

typedef enum {
    AIR_STATS_SPEED,    
    AIR_STATS_MAXSPEED, 
    AIR_STATS_SHIELD,   
    AIR_STATS_ECM,      
    AIR_STATS_DAMAGE,   
    AIR_STATS_ACCURACY, 
    AIR_STATS_FUELSIZE, 
    AIR_STATS_WRANGE,   
    AIR_STATS_ANTIMATTER,   
 
    AIR_STATS_MAX
} aircraftParams_t;

typedef struct craftitem_s {
    aircraftItemType_t type;    
    float stats[AIR_STATS_MAX]; 
    float weaponDamage;         
    float weaponSpeed;          
    float weaponDelay;          
    int installationTime;       
    bool bullets;               
    bool beam;                  
    vec4_t beamColor;
} craftItem;
 
#define MAX_DAMAGETYPES 64

typedef struct objDef_s {
    /* Common */
    int idx;                
    const char* name;       
    const char* id;         
    const char* model;      
    const char* image;      
    const char* type;       
    const char* armourPath;
    uint32_t shape;         
 
    float scale;            
    vec3_t center;          
    bool weapon;            
    bool holdTwoHanded;     
    bool fireTwoHanded;     
    bool headgear;          
    bool thrown;            
    bool implant;           
    itemEffect_t* strengthenEffect;
    bool isVirtual;         
    bool isPrimary;
    bool isSecondary;
    bool isHeavy;
    bool isMisc;
    bool isUGVitem;
    bool isDummy;
 
    /* Weapon specific. */
    int ammo;           
    int _reload;            
    const char* reloadSound;    
    float reloadAttenuation;    
    bool oneshot;       
    bool deplete;       
 
    int useable;        
 
    const struct objDef_s* ammos[MAX_AMMOS_PER_OBJDEF];     
    int numAmmos;       
 
    /* Firemodes (per weapon). */
    const struct objDef_s* weapons[MAX_WEAPONS_PER_OBJDEF]; 
    fireDef_t fd[MAX_WEAPONS_PER_OBJDEF][MAX_FIREDEFS_PER_WEAPON];  
    fireDefIndex_t numFiredefs[MAX_WEAPONS_PER_OBJDEF]; 
    int numWeapons;     
 
 
    /* Armour specific */
    short protection[MAX_DAMAGETYPES];  
    short ratings[MAX_DAMAGETYPES];     
 
    byte dmgtype;
    byte sx, sy;            
    char animationIndex;    
 
    /**** @todo move into campaign only structure ****/
    /* Aircraft specific */
    craftItem craftitem;
    int price;              
    int productionCost;     
    int size;               
    int weight;         
    bool notOnMarket;       
 
 
    uint32_t getShapeRotated () const;
    bool isCraftItem () const;
    bool isBaseDefenceItem () const;
    bool isLoadableInWeapon (const objDef_s* weapon) const;
    inline bool isAmmo () const {
        return Q_streq(this->type, "ammo");
    }
    inline bool isArmour () const {
        return Q_streq(this->type, "armour");
    }
    inline int getReloadTime () const {
        return _reload;
    }
    inline bool isReloadable () const {
        return getReloadTime() > 0;
    }
 
} objDef_t;

enum {
    INV_DOES_NOT_FIT        = 0,    
    INV_FITS                = 1,    
    INV_FITS_ONLY_ROTATED   = 2,    
    INV_FITS_BOTH           = 3     
};
 
#define MAX_INVDEFS 16

typedef struct invDef_s {
    char name[MAX_VAR]; 
    containerIndex_t id;                
    bool single;    
    bool armour;    
    bool implant;   
    bool headgear;  
    bool all;       
    bool unique;    
    bool temp;      
    bool scroll;    
    uint32_t shape[SHAPE_BIG_MAX_HEIGHT];   
    int in, out;    
 
    bool isArmourDef () const;
    bool isFloorDef () const;
    bool isRightDef () const;
    bool isLeftDef () const;
    bool isEquipDef () const;
} invDef_t;
 
#define MAX_CONTAINERS  MAX_INVDEFS

class Item {
    const objDef_t* _itemDef;   
    const objDef_t* _ammoDef;   
    Item* _next;                
    int _x, _y;                 
    int _amount;                
    int _ammoLeft;              
public:
    int rotated;    
 
 
    /*==================
     *      ctors
     *==================*/
    Item ();
    Item (const objDef_t* _itemDef, const objDef_t* ammo = nullptr, int ammoLeft = 0);
 
    /*==================
     *      setters
     *==================*/
    inline void setNext (Item* nx) {
        _next = nx;
    }
    inline void setX (const int val) {
        _x = val;
    }
    inline void setY (const int val) {
        _y = val;
    }
    inline void setAmmoDef (const objDef_t* od) {
        _ammoDef = od;
    }
    inline void setAmount (int value) {
        _amount = value;
    }
    inline void setAmmoLeft (int value) {
        _ammoLeft = value;
    }
    inline void setDef(const objDef_t* objDef) {
        _itemDef = objDef;
    }
 
    /*==================
     *      getters
     *==================*/
    inline Item* getNext () const {
        return _next;
    }
    inline int getX () const {
        return _x;
    }
    inline int getY () const {
        return _y;
    }
    inline const objDef_t* ammoDef (void) const {
        return _ammoDef;
    }
    inline int getAmount () const {
        return _amount;
    }
    inline int getAmmoLeft () const {
        return _ammoLeft;
    }
    inline const objDef_t* def (void) const {
        return _itemDef;
    }
 
    /*==================
     *      checkers
     *==================*/
    inline bool isHeldTwoHanded() const {
        return _itemDef->holdTwoHanded;
    }
    inline bool isReloadable() const {
        return _itemDef->getReloadTime() > 0;
    }

    inline bool mustReload() const {
        return isReloadable() && getAmmoLeft() <= 0;
    }
    inline bool isWeapon() const {
        return _itemDef->weapon;
    }
    inline bool isArmour() const {
        return _itemDef->isArmour();
    }
    bool isSameAs (const Item* const other) const;
 
    /*==================
     *  manipulators
     *==================*/
    inline void addAmount (int value) {
        _amount += value;
    }
 
 
    int getWeight() const;
    void getFirstShapePosition(int* const x, int* const y) const;
    const objDef_t* getReactionFireWeaponType() const;
    const fireDef_t* getFiredefs() const;
    int getNumFiredefs() const;
    const fireDef_t* getSlowestFireDef() const;
    const fireDef_t* getFastestFireDef() const;
};
 
class Container
{
    const invDef_t* _def;   /* container attributes (invDef_t) */
public:
    int id;
    Item* _invList; /* start of the list of items */
 
    Container();
    const invDef_t* def () const;
    Item* getNextItem (const Item* prev) const;
    int countItems () const;
};

class Inventory {
protected:
    Container _containers[MAX_CONTAINERS];

    const Container* _getNextCont (const Container* prev) const;
 
public:
    Inventory ();
    virtual ~Inventory() {}
    void init ();
 
    inline const Container& getContainer (const containerIndex_t idx) const {
        return _containers[idx];
    }

    inline Item* getContainer2 (const containerIndex_t idx) const {
        return getContainer(idx)._invList;
    }
 
    inline void setContainer (const containerIndex_t idx, Item* cont) {
        _containers[idx]._invList = cont;
    }
 
    inline void resetContainer (const containerIndex_t idx) {
        _containers[idx]._invList = nullptr;
    }
    inline void resetTempContainers () {
        const Container* cont = nullptr;
        while ((cont = getNextCont(cont, true))) {
            /* CID_FLOOR and CID_EQUIP are temp */
            if (cont->def()->temp)
                resetContainer(cont->id);
        }
    }

    inline bool containsItem (const containerIndex_t contId, const Item* const item) const {
        return findInContainer(contId, item) ? true : false;
    }
 
    Item* getArmour () const;
    Item* getHeadgear() const;
    Item* getRightHandContainer() const;
    Item* getLeftHandContainer () const;
    Item* getHolsterContainer() const;
    Item* getEquipContainer () const;
    Item* getImplantContainer () const;
    Item* getFloorContainer() const;
    void setFloorContainer(Item* cont);
 
    void findSpace (const invDef_t* container, const Item* item, int* const px, int* const py, const Item* ignoredItem) const;
    Item* findInContainer (const containerIndex_t contId, const Item*  const item) const;
    Item* getItemAtPos (const invDef_t* container, const int x, const int y) const;
    int getWeight () const;
    int canHoldItem (const invDef_t* container, const objDef_t* od, const int x, const int y, const Item* ignoredItem) const;
    bool canHoldItemWeight (containerIndex_t from, containerIndex_t to, const Item& item, int maxWeight) const;
    bool holdsReactionFireWeapon () const;
    const Container* getNextCont (const Container* prev, bool inclTemp = false) const;
    int countItems () const;
};
 
#define MAX_EQUIPDEFS   64
 
typedef struct equipDef_s {
    char id[MAX_VAR];           
    const char* name;           
    int numItems[MAX_OBJDEFS];  
    byte numItemsLoose[MAX_OBJDEFS];    
    int numAircraft[AIRCRAFTTYPE_MAX];
    int minInterest;            
    int maxInterest;            
 
    void addClip(const Item* item); 
} equipDef_t;
 
/* Maximum number of alien teams per alien group */
#define MAX_TEAMS_PER_MISSION MAX_TEAMDEFS
 
typedef struct damageType_s {
    char id[MAX_VAR];
    bool showInMenu;    
} damageType_t;

typedef enum {
    ACTOR_HAND_NOT_SET = 0,
    ACTOR_HAND_RIGHT = 1,
    ACTOR_HAND_LEFT = 2,
 
    ACTOR_HAND_ENSURE_32BIT = 0x7FFFFFFF
} actorHands_t;
 
#define foreachhand(hand) for (int hand##__loop = 0; hand##__loop < 2; ++hand##__loop) \
    if (hand = (hand##__loop == 0 ? ACTOR_HAND_RIGHT : ACTOR_HAND_LEFT), false) {} else
 
 
/* ================================ */
/*  INVENTORY MANAGEMENT FUNCTIONS  */
/* ================================ */
 
void INVSH_InitCSI(const struct csi_s* import) __attribute__((nonnull));
 
const objDef_t* INVSH_GetItemByID(const char* id);
const objDef_t* INVSH_GetItemByIDX(int index);
const objDef_t* INVSH_GetItemByIDSilent(const char* id);
 
const implantDef_t* INVSH_GetImplantForObjDef(const objDef_t* od);
const implantDef_t* INVSH_GetImplantByID(const char* id);
const implantDef_t* INVSH_GetImplantByIDSilent(const char* id);
 
const invDef_t* INVSH_GetInventoryDefinitionByID(const char* id);
 
#define THIS_FIREMODE(fm, HAND, fdIdx)  ((fm)->getHand() == (HAND) && (fm)->getFmIdx() == (fdIdx))
 
/* =============================== */
/*  FIREMODE MANAGEMENT FUNCTIONS  */
/* =============================== */
 
const fireDef_t* FIRESH_GetFiredef(const objDef_t* obj, const weaponFireDefIndex_t weapFdsIdx, const fireDefIndex_t fdIdx);
#define FIRESH_IsMedikit(firedef) ((firedef)->damage[0] < 0)
void INVSH_MergeShapes(uint32_t* shape, const uint32_t itemShape, const int x, const int y);
bool INVSH_CheckShape(const uint32_t* shape, const int x, const int y);
int INVSH_ShapeSize(const uint32_t shape);