pilot.h

/*
 * See Licensing and Copyright notice in naev.h
 */
#pragma once
 
#include "pilot_flags.h"
 
#include "ai.h"
#include "commodity.h"
#include "effect.h"
#include "faction.h"
#include "ntime.h"
#include "outfit.h"
#include "physics.h"
#include "ship.h"
#include "sound.h"
#include "space.h"
#include "spfx.h"
#include "lvar.h"
 
#define PLAYER_ID       1 
/* Hyperspace parameters. */
#define HYPERSPACE_ENGINE_DELAY  3. 
#define HYPERSPACE_FLY_DELAY     5. 
#define HYPERSPACE_STARS_BLUR    3. 
#define HYPERSPACE_STARS_LENGTH  250 
#define HYPERSPACE_FADEOUT       1. 
#define HYPERSPACE_FADEIN        1. 
#define HYPERSPACE_THRUST        2000.
#define HYPERSPACE_VEL           (2.*HYPERSPACE_THRUST*HYPERSPACE_FLY_DELAY) 
#define HYPERSPACE_ENTER_MIN     (HYPERSPACE_VEL*0.3) 
#define HYPERSPACE_ENTER_MAX     (HYPERSPACE_VEL*0.4) 
#define HYPERSPACE_EXIT_MIN      1500. 
/* Land/takeoff. */
#define PILOT_LANDING_DELAY      1. 
#define PILOT_TAKEOFF_DELAY      1. 
/* Refueling. */
#define PILOT_REFUEL_TIME        3. 
#define PILOT_REFUEL_QUANTITY    100 
/* Misc. */
#define PILOT_SIZE_APPROX        0.8   
#define PILOT_WEAPON_SETS        10    
#define PILOT_WEAPSET_MAX_LEVELS 2     
#define PILOT_REVERSE_THRUST     0.4   
#define PILOT_PLAYER_NONTARGETABLE_TAKEOFF_DELAY 5. 
#define PILOT_PLAYER_NONTARGETABLE_JUMPIN_DELAY 5. 
/* Pilot-related hooks. */
enum {
   PILOT_HOOK_NONE,      
   PILOT_HOOK_CREATION,  
   PILOT_HOOK_DEATH,     
   PILOT_HOOK_BOARDING,  
   PILOT_HOOK_BOARD,     
   PILOT_HOOK_BOARD_ALL,  
   PILOT_HOOK_DISABLE,   
   PILOT_HOOK_UNDISABLE, 
   PILOT_HOOK_JUMP,      
   PILOT_HOOK_HAIL,      
   PILOT_HOOK_LAND,      
   PILOT_HOOK_ATTACKED,  
   PILOT_HOOK_DISCOVERED,  
   PILOT_HOOK_SCAN,      
   PILOT_HOOK_SCANNED,   
   PILOT_HOOK_IDLE,      
   PILOT_HOOK_EXPLODED,  
   PILOT_HOOK_LOCKON,    
   PILOT_HOOK_STEALTH,   
};
 
/* Damage */
#define PILOT_HOSTILE_THRESHOLD  0.09 
#define PILOT_HOSTILE_DECAY      0.005 
/* Makes life easier */
#define pilot_isPlayer(p)   pilot_isFlag(p,PILOT_PLAYER) 
#define pilot_isDisabled(p) pilot_isFlag(p,PILOT_DISABLED) 
#define pilot_isStopped(p)  (VMOD(p->solid->vel) <= MIN_VEL_ERR)
/* We would really have to recursively go up all the parents to check, but we're being cheap. */
#define pilot_isWithPlayer(p) ((p)->faction == FACTION_PLAYER || ((p)->parent == PLAYER_ID))
 
typedef enum PilotOutfitState_ {
   PILOT_OUTFIT_OFF,    
   PILOT_OUTFIT_WARMUP, 
   PILOT_OUTFIT_ON,     
   PILOT_OUTFIT_COOLDOWN 
} PilotOutfitState;
 
typedef struct PilotOutfitAmmo_ {
   int quantity;        
   int deployed;        
   double lockon_timer; 
   int in_arc;          
} PilotOutfitAmmo;
 
typedef struct PilotOutfitSlot_ {
   int id;           
   /* Outfit slot properties. */
   const Outfit* outfit;  
   int active;            
   ShipOutfitSlot *sslot; 
   /* Heat. */
   double heat_T;    
   double heat_C;    
   double heat_area; 
   double heat_start;
   /* Current state. */
   PilotOutfitState state; 
   double stimer;    
   double timer;     
   double rtimer;    
   double progress;  
   int level;        
   int weapset;      
   unsigned int inrange; 
   /* Type-specific data. */
   union {
      unsigned int beamid; 
      PilotOutfitAmmo ammo;
   } u;
 
   /* In the case of Lua stuff. */
   int lua_mem; 
   ShipStats lua_stats; 
} PilotOutfitSlot;
 
typedef struct PilotWeaponSetOutfit_ {
   int level;              
   double range2;          
   int slotid;             
} PilotWeaponSetOutfit;
 
typedef struct PilotWeaponSet_ {
   int type;      
   int active;    
   PilotWeaponSetOutfit *slots; 
   /* Only applicable to weapon type. */
   int inrange;   
   int manual;    
   double range[PILOT_WEAPSET_MAX_LEVELS]; 
   double speed[PILOT_WEAPSET_MAX_LEVELS]; 
} PilotWeaponSet;
 
typedef struct PilotCommodity_ {
   const Commodity *commodity;
   int quantity;           
   unsigned int id;        
} PilotCommodity;
 
typedef struct PilotHook_ {
   int type;         
   unsigned int id;  
} PilotHook;
 
typedef enum EscortType_e {
   ESCORT_TYPE_NULL,       
   ESCORT_TYPE_BAY,        
   ESCORT_TYPE_MERCENARY,  
   ESCORT_TYPE_FLEET,      
} EscortType_t;
 
typedef struct Escort_s {
   char *ship;          
   EscortType_t type;   
   unsigned int id;     
   /* TODO: something better than this */
   int persist;         
} Escort_t;
 
typedef struct Pilot_ {
   unsigned int id;  
   char* name;       
   /* Fleet/faction management. */
   int faction;      
   int presence;     
   /* Object characteristics */
   const Ship* ship; 
   Solid* solid;     
   double base_mass; 
   double mass_cargo;
   double mass_outfit;
   int tsx;          
   int tsy;          
   Trail_spfx** trail;
   /* Properties. */
   int cpu;       
   int cpu_max;   
   double crew;   
   double cap_cargo;
   /* Movement */
   double thrust;    
   double thrust_base;
   double speed;     
   double speed_base;
   double speed_limit;
   double turn;      
   double turn_base; 
   /* Current health */
   double armour;    
   double stress;    
   double shield;    
   double armour_max;
   double shield_max;
   double armour_regen;
   double shield_regen;
   double dmg_absorb;
   double fuel_max;  
   double fuel;      
   double fuel_consumption; 
   /* Energy is handled a bit differently. */
   double energy;    
   double energy_max; 
   double energy_regen; 
   double energy_tau; 
   double energy_loss; 
   /* Defensive Electronic Warfare. */
   double ew_detection; 
   double ew_evasion;   
   double ew_stealth;   
   /* Defensive Electronic Warfare. */
   double ew_mass;      
   double ew_asteroid;  
   double ew_jumppoint; 
   /* misc. */
   double ew_stealth_timer; 
   /* Heat. */
   double heat_T;    
   double heat_C;    
   double heat_emis; 
   double heat_cond; 
   double heat_area; 
   double cdelay;    
   double ctimer;    
   double heat_start; 
   /* Ship statistics. */
   ShipStats intrinsic_stats; 
   ShipStats stats;  
   /* Ship effects. */
   Effect *effects; 
   /* Outfit management */
   PilotOutfitSlot **outfits;        
   PilotOutfitSlot *outfit_structure;
   PilotOutfitSlot *outfit_utility;  
   PilotOutfitSlot *outfit_weapon;   
   PilotOutfitSlot *outfit_intrinsic;
   /* Primarily for AI usage. */
   int ncannons;      
   int nturrets;      
   int nbeams;        
   int nfighterbays;  
   int nafterburners; 
   int outfitlupdate; 
   double refuel_amount; 
   /* For easier usage. */
   PilotOutfitSlot *afterburner; 
   /* Weapon sets. */
   PilotWeaponSet weapon_sets[PILOT_WEAPON_SETS]; 
   int active_set;   
   int autoweap;     
   int aimLines;     
   /* Cargo */
   credits_t credits; 
   PilotCommodity* commodities; 
   int cargo_free;   
   /* Hook attached to the pilot */
   PilotHook *hooks; 
   /* Escort stuff. */
   unsigned int parent; 
   Escort_t *escorts;   
   unsigned int dockpilot;
   int dockslot; 
   /* Targeting. */
   unsigned int target; 
   void *ptarget;       
   int nav_spob;      
   int nav_hyperspace;  
   int nav_anchor;      
   int nav_asteroid;    
   /* AI */
   AI_Profile* ai;   
   int lua_mem;      
   double tcontrol;  
   double timer[MAX_AI_TIMERS]; 
   Task* task;       
   unsigned int shoot_indicator; 
   /* Misc */
   double comm_msgTimer; 
   double comm_msgWidth; 
   char *comm_msg;   
   PilotFlags flags; 
   double landing_delay;
   double pdata;     
   double ptimer;    
   double itimer;    
   double htimer;    
   double stimer;    
   double sbonus;    
   double dtimer;    
   double dtimer_accum; 
   double otimer;    
   double scantimer; 
   int hail_pos;     
   int lockons;      
   int projectiles;  
   int *mounted;     
   double player_damage;
   double engine_glow;
   int messages;     
   lvar *shipvar;    
} Pilot;
 
/* These depend on Pilot being defined first. */
#include "pilot_cargo.h"
#include "pilot_heat.h"
#include "pilot_hook.h"
#include "pilot_outfit.h"
#include "pilot_weapon.h"
#include "pilot_ew.h"
 
/*
 * Getting pilot stuff.
 */
Pilot*const* pilot_getAll (void);
Pilot* pilot_get( unsigned int id );
Pilot* pilot_getTarget( Pilot *p );
unsigned int pilot_getNextID( unsigned int id, int mode );
unsigned int pilot_getPrevID( unsigned int id, int mode );
unsigned int pilot_getNearestEnemy( const Pilot* p );
unsigned int pilot_getNearestEnemy_size( const Pilot* p, double target_mass_LB, double target_mass_UB );
unsigned int pilot_getNearestEnemy_heuristic(const Pilot* p, double mass_factor, double health_factor, double damage_factor, double range_factor);
unsigned int pilot_getNearestHostile (void); /* only for the player */
unsigned int pilot_getNearestPilot( const Pilot* p );
unsigned int pilot_getBoss( const Pilot* p );
double pilot_getNearestPos( const Pilot *p, unsigned int *tp, double x, double y, int disabled );
double pilot_getNearestAng( const Pilot *p, unsigned int *tp, double ang, int disabled );
int pilot_getJumps( const Pilot* p );
const glColour* pilot_getColour( const Pilot* p );
int pilot_validTarget( const Pilot* p, const Pilot* target );
int pilot_canTarget( const Pilot* p );
 
/* non-lua wrappers */
double pilot_relsize( const Pilot* cur_pilot, const Pilot* p );
double pilot_reldps( const Pilot* cur_pilot, const Pilot* p );
double pilot_relhp( const Pilot* cur_pilot, const Pilot* p );
 
/*
 * Combat.
 */
void pilot_setTarget( Pilot* p, unsigned int id );
double pilot_hit( Pilot* p, const Solid* w, const Pilot *pshooter,
      const Damage *dmg, const Outfit *outfit, int lua_mem, int reset );
void pilot_updateDisable( Pilot* p, unsigned int shooter );
void pilot_explode( double x, double y, double radius, const Damage *dmg, const Pilot *parent );
double pilot_face( Pilot* p, const double dir );
int pilot_brake( Pilot* p );
double pilot_brakeDist( Pilot *p, vec2 *pos );
int pilot_interceptPos( Pilot *p, double x, double y );
void pilot_cooldown( Pilot *p, int dochecks );
void pilot_cooldownEnd( Pilot *p, const char *reason );
double pilot_aimAngle( Pilot *p, const vec2* pos, const vec2* vel );
 
/*
 * Faction stuff.
 */
int pilot_validEnemy( const Pilot* p, const Pilot* target );
int pilot_validEnemyDist( const Pilot* p, const Pilot* target, double *dist );
int pilot_areAllies( const Pilot *p, const Pilot *target );
int pilot_areEnemies( const Pilot *p, const Pilot *target );
 
/* Outfits */
int pilot_numOutfit( const Pilot *p, const Outfit *o );
void pilot_dpseps( const Pilot *p, double *pdps, double *peps );
 
/* Misc. */
int pilot_hasCredits( Pilot *p, credits_t amount );
credits_t pilot_modCredits( Pilot *p, credits_t amount );
int pilot_refuelStart( Pilot *p );
void pilot_hyperspaceAbort( Pilot* p );
void pilot_clearTimers( Pilot *pilot );
int pilot_hasDeployed( Pilot *p );
int pilot_dock( Pilot *p, Pilot *target );
ntime_t pilot_hyperspaceDelay( Pilot *p );
void pilot_untargetAsteroid( int anchor, int asteroid );
PilotOutfitSlot* pilot_getDockSlot( Pilot* p );
 
/*
 * Creation.
 */
unsigned int pilot_create( const Ship* ship, const char* name, int faction, const char *ai,
      const double dir, const vec2* pos, const vec2* vel,
      const PilotFlags flags, unsigned int dockpilot, int dockslot );
Pilot* pilot_createEmpty( const Ship* ship, const char* name,
      int faction, PilotFlags flags );
unsigned int pilot_clone( const Pilot *p );
unsigned int pilot_addStack( Pilot *p );
void pilot_reset( Pilot* pilot );
Pilot* pilot_setPlayer( Pilot* after );
void pilot_choosePoint( vec2 *vp, Spob **spob, JumpPoint **jump, int lf, int ignore_rules, int guerilla );
void pilot_delete( Pilot *p );
void pilot_dead( Pilot* p, unsigned int killer );
 
/*
 * Init and cleanup.
 */
void pilot_stackRemove( Pilot *p );
void pilots_init (void);
void pilots_free (void);
void pilots_clean( int persist );
void pilots_newSystem (void);
void pilots_clear (void);
void pilots_cleanAll (void);
void pilot_free( Pilot* p );
 
/*
 * Movement.
 */
void pilot_setThrust( Pilot *p, double thrust );
void pilot_setTurn( Pilot *p, double turn );
 
/*
 * update
 */
void pilot_update( Pilot* pilot, double dt );
void pilots_update( double dt );
void pilot_renderFramebuffer( Pilot *p, GLuint fbo, double fw, double fh );
void pilots_render (void);
void pilots_renderOverlay (void);
void pilot_render( Pilot* pilot );
void pilot_renderOverlay( Pilot* p );
 
/*
 * communication
 */
void pilot_broadcast( Pilot *p, const char *msg, int ignore_int );
void pilot_distress( Pilot *p, Pilot *attacker, const char *msg );
void pilot_setCommMsg( Pilot *p, const char *s );
 
/*
 * faction
 */
void pilot_setHostile( Pilot *p );
void pilot_rmHostile( Pilot *p );
void pilot_setFriendly( Pilot *p );
void pilot_rmFriendly( Pilot *p );
int pilot_isHostile( const Pilot *p );
int pilot_isNeutral( const Pilot *p );
int pilot_isFriendly( const Pilot *p );
char pilot_getFactionColourChar( const Pilot *p );
 
/*
 * Misc details.
 */
credits_t pilot_worth( const Pilot *p );
void pilot_msg( Pilot *p, Pilot *receiver, const char *type, unsigned int index );
void pilot_clearTrails( Pilot *p );
void pilot_sample_trails( Pilot* p, int none );
int pilot_hasIllegal( const Pilot *p, int faction );