cp_aircraft.h

Go to the documentation of this file.

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

#include "cp_capacity.h"
#include "cp_radar.h"

#define MAX_AIRCRAFT    64
#define LINE_MAXSEG 64
#define LINE_MAXPTS (LINE_MAXSEG + 2)

#define AIRCRAFT_REFUEL_FACTOR 16

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

typedef enum {
    ITEM_LIGHT,
    ITEM_MEDIUM,
    ITEM_HEAVY
} itemWeight_t;

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;

#define MAX_AIRCRAFTSLOT 8

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 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;                    
    ufoType_t ufotype;              
    aircraftStatus_t status;            
    int price;                  
    int productionCost;             
    int fuel;                   
    int damage;                 
    vec3_t pos;                 
    vec3_t direction;               
    vec3_t projectedPos;                
    mapline_t route;
    int point;                  
    int time;                   
    int maxTeamSize;                
    linkedList_t* acTeam;               
    class Employee* pilot;              
    aircraftSlot_t weapons[MAX_AIRCRAFTSLOT];   
    int maxWeapons;                 
    aircraftSlot_t shield;              
    aircraftSlot_t electronics[MAX_AIRCRAFTSLOT];   
    int maxElectronics;             
    struct base_s* homebase;            
    const char* building;               
    struct mission_s* mission;          
    char* missionID;                
    struct aircraft_s* aircraftTarget;      
    bool leader;                    
    struct radar_s radar;               
    int stats[AIR_STATS_MAX]    ;       
    struct technology_s* tech;          
    bool notifySent[MAX_AIR_NOTIFICATIONS];     /* stores if a notification was already sent */

    bool detected;                  
    bool landed;                    
    bool notOnGeoscape;             
    int ufoInterestOnGeoscape;          
    linkedList_t* missionTypes;         
    int detectionIdx;               
    date_t lastSpotted;             
    class AlienCargo* alienCargo;           
    class ItemCargo* itemCargo;         
    inline ufoType_t getUfoType() const {
        return ufotype;
    }
    inline void setUfoType(ufoType_t ufoT) {
        ufotype = ufoT;
    }
} aircraft_t;


#define AIR_Foreach(var) LIST_Foreach(ccs.aircraft, aircraft_t, var)

#define AIR_IsAircraftOfBase(aircraft, base) ((aircraft)->homebase == (base) && (aircraft)->status != AIR_CRASHED)

#define AIR_ForeachFromBase(var, base) \
    AIR_Foreach(var) \
        if (!AIR_IsAircraftOfBase(var, (base))) continue; else

#define AIR_IsUFO(aircraft) ((aircraft)->getUfoType() != UFO_NONE)


aircraft_t* AIR_NewAircraft(struct base_s* base, const aircraft_t* aircraftTemplate);
aircraft_t* AIR_Add(struct base_s* base, const aircraft_t* aircraftTemplate);
bool AIR_Delete(struct base_s* base, aircraft_t* aircraft);
void AIR_DeleteAircraft(aircraft_t* aircraft);
void AIR_DestroyAircraft(aircraft_t* aircraft, bool killPilot = true);

const aircraft_t* AIR_GetAircraftSilent(const char* name);
const aircraft_t* AIR_GetAircraft(const char* name);

aircraft_t* AIR_GetFirstFromBase(const struct base_s* base);
bool AIR_BaseHasAircraft(const struct base_s* base);
int AIR_BaseCountAircraft(const struct base_s* base);
aircraft_t* AIR_GetAircraftFromBaseByIDXSafe(const struct base_s* base, int index);

aircraft_t* AIR_AircraftGetFromIDX(int idx);

const char* AIR_AircraftStatusToName(const aircraft_t* aircraft);
bool AIR_IsAircraftInBase(const aircraft_t* aircraft);
bool AIR_IsAircraftOnGeoscape(const aircraft_t* aircraft);

void AIR_ResetAircraftTeam(aircraft_t* aircraft);
bool AIR_AddToAircraftTeam(aircraft_t* aircraft, class Employee* employee);
bool AIR_IsInAircraftTeam(const aircraft_t* aircraft, const class Employee* employee);
int AIR_GetTeamSize(const aircraft_t* aircraft);

void AIR_CampaignRun(const struct campaign_s* campaign, int dt, bool updateRadarOverlay);
bool AIR_AircraftMakeMove(int dt, aircraft_t* aircraft);

void AIR_ParseAircraft(const char* name, const char** text, bool assignAircraftItems);

bool AIR_AircraftHasEnoughFuel(const aircraft_t* aircraft, const vec2_t destination);
bool AIR_AircraftHasEnoughFuelOneWay(const aircraft_t* aircraft, const vec2_t destination);

void AIR_AircraftReturnToBase(aircraft_t* aircraft);
bool AIR_SendAircraftToMission(aircraft_t* aircraft, struct mission_s* mission);

void AIR_AircraftsNotifyMissionRemoved(const struct mission_s* mission);
void AIR_AircraftsNotifyUFORemoved(const aircraft_t* const ufo, bool destroyed);

void AIR_GetDestinationWhilePursuing(const aircraft_t* shooter, const aircraft_t* target, vec2_t dest);
bool AIR_SendAircraftPursuingUFO(aircraft_t* aircraft, aircraft_t* ufo);
void AIR_AircraftsUFODisappear(const aircraft_t* const ufo);
bool AIR_ScriptSanityCheck(void);
int AIR_AircraftMenuStatsValues(const int value, const int stat);
int AIR_CountInBaseByTemplate(const struct base_s* base, const aircraft_t* aircraftTemplate);

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

const char* AIR_CheckMoveIntoNewHomebase(const aircraft_t* aircraft, const struct base_s* base);
void AIR_MoveAircraftIntoNewHomebase(aircraft_t* aircraft, struct base_s* base);

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

bool AIR_SetPilot(aircraft_t* aircraft, class Employee* pilot);
Employee* AIR_GetPilot(const aircraft_t* aircraft);

bool AIR_PilotSurvivedCrash(const aircraft_t* aircraft);

bool AIR_AddEmployee(Employee* employee, aircraft_t* aircraft);
void AIR_RemoveEmployees(aircraft_t& aircraft);
bool AIR_RemoveEmployee(Employee* employee, aircraft_t* aircraft);

const aircraft_t* AIR_IsEmployeeInAircraft(const class Employee* employee, const aircraft_t* aircraft);

void AIR_AutoAddPilotToAircraft(const struct base_s* base, class Employee* pilot);
void AIR_RemovePilotFromAssignedAircraft(const struct base_s* base, const class Employee* pilot);

void AIR_MoveEmployeeInventoryIntoStorage(const aircraft_t& aircraft, equipDef_t& equip);

void AIR_AssignInitial(aircraft_t* aircraft);

bool AIR_CanIntercept(const aircraft_t* aircraft);

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

void AIR_InitStartup(void);
void AIR_Shutdown(void);