inv_shared.h

Go to the documentation of this file.

/*
Copyright (C) 2002-2010 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.

*/

#ifndef GAME_INV_SHARED_H
#define GAME_INV_SHARED_H

struct csi_s;

typedef enum {
    DROPSHIP_FIREBIRD,
    DROPSHIP_HERAKLES,
    DROPSHIP_RAPTOR,

    INTERCEPTOR_STILETTO,
    INTERCEPTOR_SARACEN,
    INTERCEPTOR_DRAGON,
    INTERCEPTOR_STARCHASER,
    INTERCEPTOR_STINGRAY,

    AIRCRAFTTYPE_MAX
} humanAircraftType_t;

/* this is the absolute max for now */
#define MAX_OBJDEFS     128     /* Remember to adapt the "NONE" define (and similar) if this gets changed. */
#define MAX_MAPDEFS     128
#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
#define INJURY_BALANCE 0.2f
#define INJURY_THRESHOLD 0.5f /* HP / maxHP > INJURY_THRESHOLD no penalty is incurred */

typedef int32_t containerIndex_t;

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 struct fireDef_s {
    char name[MAX_VAR];         
    char projectile[MAX_VAR];   
    char impact[MAX_VAR];       
    char hitBody[MAX_VAR];      
    char fireSound[MAX_VAR];    
    char impactSound[MAX_VAR];  
    char hitBodySound[MAX_VAR]; 
    float fireAttenuation;      
    float impactAttenuation;        
    char bounceSound[MAX_VAR];  
    /* These values are created in Com_ParseItem and Com_AddObjectLinks.
     * They are used for self-referencing the firedef. */
    struct objDef_s *obj;       
    weaponFireDefIndex_t weapFdsIdx;    
    fireDefIndex_t fdIdx;       
    qboolean soundOnce;     
    qboolean gravity;       
    qboolean launched;      
    qboolean rolled;        
    qboolean reaction;      
    int throughWall;        
    byte dmgweight;         
    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 irgoggles;          
} 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;       
    qboolean bullets;           
    qboolean beam;              
    vec4_t beamColor;
} craftitem_t;

#define MAX_DAMAGETYPES 64

typedef struct objDef_s {
    /* Common */
    int idx;    
    char name[MAX_VAR];     
    char id[MAX_VAR];       
    char model[MAX_VAR];        
    char image[MAX_VAR];        
    char type[MAX_VAR];     
    char armourPath[MAX_VAR];
    uint32_t shape;         
    float scale;            
    vec3_t center;          
    qboolean weapon;        
    qboolean holdTwoHanded;     
    qboolean fireTwoHanded;     
    qboolean extension;     
    qboolean headgear;      
    qboolean thrown;        
    qboolean isVirtual; 
    qboolean isPrimary;
    qboolean isSecondary;
    qboolean isHeavy;
    qboolean isMisc;
    qboolean isUGVitem;
    qboolean isDummy;

    /* Weapon specific. */
    int ammo;           
    int reload;         
    qboolean oneshot;   
    qboolean deplete;   
    int useable;        
    struct objDef_s *ammos[MAX_AMMOS_PER_OBJDEF];       
    int numAmmos;           
    /* Firemodes (per weapon). */
    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_t craftitem;
    int price;          
    int size;           
    qboolean notOnMarket;       
} 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;                
    qboolean single;    
    qboolean armour;    
    qboolean extension; 
    qboolean headgear;  
    qboolean all;       
    qboolean temp;      
    uint32_t shape[SHAPE_BIG_MAX_HEIGHT];   
    int in, out;    
    qboolean scroll;    
} invDef_t;

#define MAX_CONTAINERS  MAX_INVDEFS

typedef struct item_s {
    int a;          
    objDef_t *m;    
    objDef_t *t;    
    int amount;     
    int rotated;    
} item_t;

typedef struct invList_s {
    item_t item;    
    int x, y;       
    struct invList_s *next;     
} invList_t;

typedef struct inventory_s {
    invList_t *c[MAX_CONTAINERS];
} inventory_t;

#define MAX_EQUIPDEFS   64

typedef struct equipDef_s {
    char name[MAX_VAR];     
    int numItems[MAX_OBJDEFS];  
    byte numItemsLoose[MAX_OBJDEFS];    
    int numAircraft[AIRCRAFTTYPE_MAX];
    int minInterest;        
    int maxInterest;        
} equipDef_t;

/* Maximum number of alien teams per alien group */
#define MAX_TEAMS_PER_MISSION 4
#define MAX_TERRAINS 8
#define MAX_CULTURES 8
#define MAX_POPULATIONS 8

typedef struct damageType_s {
    char id[MAX_VAR];
    qboolean 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 ACTOR_GET_INV(actor, hand) (((hand) == ACTOR_HAND_RIGHT) ? RIGHT(actor) : (((hand) == ACTOR_HAND_LEFT) ? LEFT(actor) : NULL))

#define ACTOR_SWAP_HAND(hand) ((hand) == ACTOR_HAND_RIGHT ? ACTOR_HAND_LEFT : ACTOR_HAND_RIGHT)

qboolean INV_IsFloorDef(const invDef_t* invDef);
qboolean INV_IsRightDef(const invDef_t* invDef);
qboolean INV_IsLeftDef(const invDef_t* invDef);
qboolean INV_IsEquipDef(const invDef_t* invDef);
qboolean INV_IsArmourDef(const invDef_t* invDef);

/* ================================ */
/*  INVENTORY MANAGEMENT FUNCTIONS  */
/* ================================ */

invList_t* INVSH_HasArmour(const inventory_t *inv);
void INVSH_InitCSI(struct csi_s * import) __attribute__((nonnull));
int INVSH_CheckToInventory(const inventory_t* const i, const objDef_t *ob, const invDef_t * container, const int x, const int y, const invList_t *ignoredItem);
qboolean INVSH_CompareItem(item_t *item1, item_t *item2);
void INVSH_GetFirstShapePosition(const invList_t *ic, int* const x, int* const y);
qboolean INVSH_ExistsInInventory(const inventory_t* const inv, const invDef_t * container, item_t item);
invList_t *INVSH_SearchInInventory(const inventory_t* const i, const invDef_t * container, const int x, const int y) __attribute__((nonnull(1)));
void INVSH_FindSpace(const inventory_t* const inv, const item_t *item, const invDef_t * container, int * const px, int * const py, const invList_t *ignoredItem) __attribute__((nonnull(1)));
qboolean INV_IsCraftItem(const objDef_t *obj);
qboolean INV_IsBaseDefenceItem(const objDef_t *item);

objDef_t *INVSH_GetItemByID(const char *id);
objDef_t *INVSH_GetItemByIDX(int index);
objDef_t *INVSH_GetItemByIDSilent(const char *id);
qboolean INVSH_LoadableInWeapon(const objDef_t *od, const objDef_t *weapon);

invDef_t *INVSH_GetInventoryDefinitionByID(const char *id);

#define THIS_FIREMODE(fm, HAND, fdIdx)  ((fm)->hand == (HAND) && (fm)->fmIdx == (fdIdx))
#define SANE_FIREMODE(fm)   (((fm)->hand > ACTOR_HAND_NOT_SET && (fm)->fmIdx >= 0 && (fm)->fmIdx < MAX_FIREDEFS_PER_WEAPON))

#define INV_IsArmour(od)    (!strcmp((od)->type, "armour"))
#define INV_IsAmmo(od)      (!strcmp((od)->type, "ammo"))

/* =============================== */
/*  FIREMODE MANAGEMENT FUNCTIONS  */
/* =============================== */

const fireDef_t* FIRESH_GetFiredef(const objDef_t *obj, const weaponFireDefIndex_t weapFdsIdx, const fireDefIndex_t fdIdx);
const fireDef_t *FIRESH_FiredefForWeapon(const item_t *item);
#define FIRESH_IsMedikit(firedef) ((firedef)->damage[0] < 0)
void INVSH_MergeShapes(uint32_t *shape, const uint32_t itemShape, const int x, const int y);
qboolean INVSH_CheckShape(const uint32_t *shape, const int x, const int y);
int INVSH_ShapeSize(const uint32_t shape);
uint32_t INVSH_ShapeRotate(const uint32_t shape);

const objDef_t* INVSH_HasReactionFireEnabledWeapon(const invList_t *invList);

#define INV_INVENTORY_BYTES 11

#endif /* GAME_INV_SHARED_H */