cp_aircraft.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 CLIENT_CL_AIRCRAFT_H
#define CLIENT_CL_AIRCRAFT_H

#define MAX_CARGO       32
#define MAX_AIRCRAFT    64
#define LINE_MAXSEG 64
#define LINE_MAXPTS (LINE_MAXSEG + 2)
#define LINE_DPHI   (M_PI / LINE_MAXSEG)

#define AIRCRAFT_INVALID -1

#define AIRCRAFT_INBASE_INVALID -1

#define AIRCRAFT_REFUEL_FACTOR 16

#define AIR_IsUFO(aircraft) ((aircraft)->ufotype != UFO_MAX)

typedef struct mapline_s {
    int numPoints;      
    float distance;     
    vec2_t point[LINE_MAXPTS]; 
} mapline_t;

typedef enum {
    AIRCRAFT_TRANSPORTER,
    AIRCRAFT_INTERCEPTOR,
    AIRCRAFT_UFO
} aircraftType_t;

#define MAX_HUMAN_AIRCRAFT_TYPE AIRCRAFT_INTERCEPTOR

typedef enum {
    AIRCRAFT_SMALL = 1,
    AIRCRAFT_LARGE = 2
} aircraftSize_t;

typedef enum {
    AIRCRAFT_HANGAR_NONE = 0,
    AIRCRAFT_HANGAR_SMALL = 1,
    AIRCRAFT_HANGAR_BIG = 2,

    AIRCRAFT_HANGAR_ERROR
} aircraftHangarType_t;

typedef enum {
    ITEM_LIGHT,
    ITEM_MEDIUM,
    ITEM_HEAVY
} itemWeight_t;

#define MAX_AIRCRAFTITEMS 64

typedef enum {
    AIR_NOSE_LEFT,
    AIR_NOSE_CENTER,
    AIR_NOSE_RIGHT,
    AIR_WING_LEFT,
    AIR_WING_RIGHT,
    AIR_REAR_LEFT,
    AIR_REAR_CENTER,
    AIR_REAR_RIGHT,

    AIR_POSITIONS_MAX
} itemPos_t;

typedef enum {
    AIR_CANNOT_REFUEL,

    MAX_AIR_NOTIFICATIONS
} aircraft_notifications_t;

typedef struct aliensTmp_s {
    const teamDef_t* teamDef;       
    int amountAlive;        
    int amountDead;     
} aliensTmp_t;

#define MAX_AIRCRAFTSLOT 4

typedef struct aircraftSlot_s {
    int idx;                    
    struct base_s *base;        
    struct installation_s *installation;    
    struct aircraft_s *aircraft;    
    aircraftItemType_t type;    
    const objDef_t *item;       
    const objDef_t *ammo;       
    itemWeight_t size;          
    int ammoLeft;               
    int delayNextShot;          
    int installationTime;       
    const objDef_t *nextItem;   
    const objDef_t *nextAmmo;   
    itemPos_t pos;              
} aircraftSlot_t;


typedef struct itemsTmp_s {
    const objDef_t *item;       
    int amount;                 
} itemsTmp_t;

typedef enum aircraftStatus_s {
    AIR_NONE,
    AIR_REFUEL,         
    AIR_HOME,           
    AIR_IDLE,           
    AIR_TRANSIT,        
    AIR_MISSION,        
    AIR_UFO,            
    AIR_DROP,           
    AIR_INTERCEPT,      
    AIR_TRANSFER,       
    AIR_CRASHED,        
    AIR_RETURNING       
} aircraftStatus_t;

typedef struct aircraft_s {
    int idx;            
    struct aircraft_s *tpl; 
    char *id;           
    char name[MAX_VAR];         
    char *defaultName;  
    char *image;        
    char *model;        
    aircraftType_t type;
    ufoType_t ufotype;  
    aircraftStatus_t status;            
    int price;          
    int fuel;           
    int damage;         
    int size;           
    vec3_t pos;         
    vec3_t direction;   
    vec3_t projectedPos;    
    vec3_t oldDrawPos;  
    qboolean hasMoved;       
    int numInterpolationPoints; 
    int point;          
    int time;           
    int hangar;         
    int maxTeamSize;    
    linkedList_t *acTeam;           
    struct employee_s *pilot;           
    aircraftSlot_t weapons[MAX_AIRCRAFTSLOT];   
    int maxWeapons;                 
    aircraftSlot_t shield;          
    aircraftSlot_t electronics[MAX_AIRCRAFTSLOT];       
    int maxElectronics;             
    mapline_t route;
    struct base_s *homebase;            
    itemsTmp_t itemcargo[MAX_CARGO];    
    int itemTypes;                      
    char *building;     
    struct mission_s* mission;  
    char *missionID;            
    struct aircraft_s *aircraftTarget;      
    struct radar_s radar;               
    int stats[AIR_STATS_MAX];   
    technology_t* tech;     
    qboolean notifySent[MAX_AIR_NOTIFICATIONS]; /* stores if a notification was already sent */

    qboolean detected;      
    qboolean landed;        
    qboolean notOnGeoscape; 
    int ufoInterestOnGeoscape;  
    int detectionIdx;       
    date_t lastSpotted;     
    aliensTmp_t alienCargo[MAX_CARGO];  
    int alienCargoTypes;                        
} aircraft_t;

/* script functions */

#ifdef DEBUG
void AIR_ListAircraft_f(void);
void AIR_ListAircraftSamples_f(void);
void AIR_ListCraftIndexes_f(void);
#endif

aircraft_t *AIR_Add(struct base_s *base, const aircraft_t *aircraftTemplate);
qboolean AIR_Delete(struct base_s *base, const aircraft_t *aircraft);

aircraft_t* AIR_GetNextFromBase(const struct base_s *base, aircraft_t *lastAircraft);
aircraft_t* AIR_GetByIDX(int idx);

qboolean AIR_BaseHasAircraft(const struct base_s *base);
int AIR_GetAircraftIDXInBase(const aircraft_t* aircraft);
aircraft_t *AIR_GetAircraftFromBaseByIDXSafe(struct base_s *base, int index);
const char *AIR_AircraftStatusToName(const aircraft_t *aircraft);
qboolean AIR_IsAircraftInBase(const aircraft_t *aircraft);
qboolean AIR_IsAircraftOnGeoscape(const aircraft_t *aircraft);

void AIR_DeleteAircraft(aircraft_t *aircraft);
void AIR_DestroyAircraft(aircraft_t *aircraft);
qboolean AIR_MoveAircraftIntoNewHomebase(aircraft_t *aircraft, struct base_s *base);

void AIR_ResetAircraftTeam(aircraft_t *aircraft);
qboolean AIR_AddToAircraftTeam(aircraft_t *aircraft, struct employee_s* employee);
qboolean AIR_RemoveFromAircraftTeam(aircraft_t *aircraft, const struct employee_s* employee);
qboolean AIR_IsInAircraftTeam(const aircraft_t *aircraft, const struct employee_s* employee);
int AIR_GetTeamSize(const aircraft_t *aircraft);

void CL_CampaignRunAircraft(int dt, qboolean updateRadarOverlay);
aircraft_t *AIR_GetAircraftSilent(const char *name);
aircraft_t *AIR_GetAircraft(const char *name);
aircraft_t* AIR_AircraftGetFromIDX(int idx);
qboolean AIR_AircraftMakeMove(int dt, aircraft_t* aircraft);
void AIR_ParseAircraft(const char *name, const char **text, qboolean assignAircraftItems);
qboolean AIR_AircraftHasEnoughFuel(const aircraft_t *aircraft, const vec2_t destination);
qboolean AIR_AircraftHasEnoughFuelOneWay(const aircraft_t *aircraft, const vec2_t destination);
void AIR_AircraftReturnToBase(aircraft_t *aircraft);
qboolean AIR_SendAircraftToMission(aircraft_t* aircraft, struct mission_s* mission);
void AIR_GetDestinationWhilePursuing(const aircraft_t const *shooter, const aircraft_t const *target, vec2_t *dest);
qboolean AIR_SendAircraftPursuingUFO(aircraft_t* aircraft, aircraft_t* ufo);
void AIR_AircraftsNotifyUFORemoved(const aircraft_t *const ufo, qboolean destroyed);
void AIR_AircraftsUFODisappear(const aircraft_t *const ufo);
void AIR_UpdateHangarCapForAll(struct base_s *base);
qboolean AIR_ScriptSanityCheck(void);
int AIR_CalculateHangarStorage(const aircraft_t *aircraft, const struct base_s *base, int used) __attribute__((nonnull (1, 2)));
int CL_AircraftMenuStatsValues(const int value, const int stat);
int AIR_CountTypeInBase(const struct base_s *base, aircraftType_t aircraftType);
const char *AIR_GetAircraftString(aircraftType_t aircraftType);

int AIR_GetAircraftWeaponRanges(const aircraftSlot_t *slot, int maxSlot, float *weaponRanges);
int AIR_GetCapacityByAircraftWeight(const aircraft_t *aircraft);

const char *AIR_CheckMoveIntoNewHomebase(const aircraft_t *aircraft, const struct base_s* base, const int capacity);

void AII_CollectItem(aircraft_t *aircraft, const objDef_t *item, int amount);
void AII_CollectingItems(aircraft_t *aircraft, int won);

void AIR_AutoAddPilotToAircraft(struct base_s* base, struct employee_s* pilot);
void AIR_RemovePilotFromAssignedAircraft(struct base_s* base, const struct employee_s* pilot);
void AIR_RemoveEmployees(aircraft_t* aircraft);
qboolean AIR_RemoveEmployee(struct employee_s *employee, aircraft_t* aircraft);
const aircraft_t *AIR_IsEmployeeInAircraft(const struct employee_s *employee, const aircraft_t* aircraft);
void AIR_MoveEmployeeInventoryIntoStorage(const aircraft_t *aircraft, equipDef_t *equip);

void AIM_AddEmployeeFromMenu(aircraft_t *aircraft, const int num);
void AIR_AssignInitial(aircraft_t *aircraft);

qboolean AIR_CanIntercept(const aircraft_t *aircraft);

int AIR_GetOperationRange(const aircraft_t *aircraft);
int AIR_GetRemainingRange(const aircraft_t *aircraft);

#endif