naev/c/pilot_8h_source.html

/*

 * 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 "intlist.h"

#include "lvar.h"

#include "ntime.h"

#include "outfit.h"

#include "physics.h"

#include "ship.h"

#include "space.h"

#include "spfx.h"


#define PLAYER_ID 1


/* Hyperspace parameters. */

#define HYPERSPACE_ENGINE_DELAY 3.

#define HYPERSPACE_FLY_DELAY 5.

#define HYPERSPACE_DUST_BLUR                                                   \

   3.

#define HYPERSPACE_DUST_LENGTH                                                 \

   250

#define HYPERSPACE_FADEOUT 1.

#define HYPERSPACE_FADEIN 1.

#define HYPERSPACE_ACCEL                                                       \

   2000.

#define HYPERSPACE_VEL                                                         \

   ( 2. * HYPERSPACE_ACCEL *                                                   \

     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.

/* Misc. */

#define PILOT_SIZE_APPROX 0.8

#define PILOT_WEAPON_SETS 12

#define PILOT_REVERSE_THRUST                                                   \

   0.4

#define PILOT_PLAYER_NONTARGETABLE_TAKEOFF_DELAY                               \

   5.

#define PILOT_PLAYER_NONTARGETABLE_JUMPIN_DELAY                                \

   5.


/* Pilot-related hooks. */

typedef enum PilotHookType_ {

   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,

} PilotHookType;


/* 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;


#define PILOTOUTFIT_ACTIVE                                                     \

   ( 1 << 0 )

#define PILOTOUTFIT_TOGGLEABLE                                                 \

   ( 1 << 1 )

#define PILOTOUTFIT_ISON ( 1 << 2 )

#define PILOTOUTFIT_VOLLEY                                                     \

   ( 1 << 3 )

#define PILOTOUTFIT_INRANGE                                                    \

   ( 1 << 4 )

#define PILOTOUTFIT_MANUAL                                                     \

   ( 1 << 5 )

#define PILOTOUTFIT_ISON_TOGGLE                                                \

   ( 1 << 7 )

#define PILOTOUTFIT_ISON_HOLD ( 1 << 8 )

#define PILOTOUTFIT_DYNAMIC_FLAGS                                              \

   ( PILOTOUTFIT_VOLLEY | PILOTOUTFIT_INRANGE | PILOTOUTFIT_MANUAL |           \

     PILOTOUTFIT_ISON_TOGGLE | PILOTOUTFIT_ISON_HOLD )


typedef struct PilotOutfitSlot_ {

   int id;


   /* Outfit slot properties. */

   const Outfit   *outfit;

   int             flags;

   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 weapset;

   unsigned int inrange;


   /* Type-specific data. */

   union {

      unsigned int beamid;

      PilotOutfitAmmo ammo;

   } u;


   /* In the case of Lua stuff. */

   int

      lua_mem;

   ShipStatList *lua_stats;

} PilotOutfitSlot;


typedef struct PilotWeaponSetOutfit_ {

   double range2;

   int    slotid;

} PilotWeaponSetOutfit;


typedef enum WeaponSetType_ {

   WEAPSET_TYPE_DEFAULT = 0,

   WEAPSET_TYPE_HOLD    = 1,

   WEAPSET_TYPE_TOGGLE  = 2,

} WeaponSetType;


typedef struct PilotWeaponSet_ {

   WeaponSetType         type;

   int                   active;

   PilotWeaponSetOutfit *slots;

   /* Only applicable to weapon type. */

   int    inrange;

   int    manual;

   int    volley;

   double range_min;

   double range;

   double speed;

} 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 {

   const Ship  *ship;

   EscortType_t type;

   unsigned int id;

   /* TODO: something better than this */

   int persist;

} Escort_t;


typedef struct Pilot_ {

   unsigned int id;

   char        *name;

   double       r;


   /* Fleet/faction management. */

   int faction;

   int faction_spawn;

   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 accel;

   double accel_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;


   /* Defensive Electronic Warfare. */

   double

      ew_detection;

   double ew_signature;

   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. */

   ShipStatList *ship_stats;

   ShipStatList *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 autoweap;

   int advweap;

   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;


   /* Ship Lua. */

   int    lua_ship_mem;

   double lua_ship_timer;


   /* 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;

   double tilt;

   int    messages;

   lvar  *shipvar;

} Pilot;


/* These depend on Pilot being defined first. */

#include "pilot_cargo.h"  // IWYU pragma: export

#include "pilot_ew.h"     // IWYU pragma: export

#include "pilot_heat.h"   // IWYU pragma: export

#include "pilot_hook.h"   // IWYU pragma: export

#include "pilot_outfit.h" // IWYU pragma: export

#include "pilot_weapon.h" // IWYU pragma: export


/* 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_getNearestPosPilot( const Pilot *p, Pilot **tp, double x, double y,

                                 int disabled );

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_validTargetRange( const Pilot *p, const Pilot *target, int *inrange );

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, double dir, double dt );

int    pilot_brakeCheckReverseThrusters( const Pilot *p );

double pilot_minbrakedist( const Pilot *p, double dt, double *flytime );

int    pilot_brake( Pilot *p, double dt );

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 );


/* Outfits */

int  pilot_numOutfit( const Pilot *p, const Outfit *o );

void pilot_dpseps( const Pilot *p, double *pdps, double *peps );


/* Money. */

credits_t pilot_worth( const Pilot *p, int count_unique );

int       pilot_hasCredits( const Pilot *p, credits_t amount );

credits_t pilot_modCredits( Pilot *p, credits_t amount );


/* Creation. */

Pilot       *pilot_create( const Ship *ship, const char *name, int faction,

                           const char *ai, 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_setAccel( Pilot *p, double accel );

void pilot_setTurn( Pilot *p, double turn );


/* Update. */

void pilot_update( Pilot *pilot, double dt );

void pilots_updatePurge( void );

void pilots_update( double dt );

void pilot_renderFramebuffer( Pilot *p, GLuint fbo, double fw, double fh,

                              const Lighting *L );

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 stuff. */

int  pilot_validEnemy( const Pilot *p, const Pilot *target );

int  pilot_areAllies( const Pilot *p, const Pilot *target );

int  pilot_areEnemies( const Pilot *p, const Pilot *target );

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. */

mat4    pilot_local_transform( const Pilot *p );

void    pilot_msg( const Pilot *p, const 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 );

int     pilot_refuelStart( Pilot *p );

void    pilot_hyperspaceAbort( Pilot *p );

void    pilot_clearTimers( Pilot *pilot );

int     pilot_hasDeployed( const Pilot *p );

int     pilot_dock( Pilot *p, Pilot *target );

ntime_t pilot_hyperspaceDelay( const Pilot *p );

void    pilot_untargetAsteroid( int anchor, int asteroid );

PilotOutfitSlot *pilot_getDockSlot( Pilot *p );

const IntList   *pilot_collideQuery( int x1, int y1, int x2, int y2 );

void pilot_collideQueryIL( IntList *il, int x1, int y1, int x2, int y2 );

void pilot_quadtreeParams( int max_elem, int depth );

cur_pilot
Pilot * cur_pilot
Definition ai.c:340

pilot_getFactionColourChar
char pilot_getFactionColourChar(const Pilot *p)
Gets the faction colour char, works like faction_reputationColourChar but for a pilot.
Definition pilot.c:1121

pilot_free
void pilot_free(Pilot *p)
Frees and cleans up a pilot.
Definition pilot.c:3902

pilot_stackRemove
void pilot_stackRemove(Pilot *p)
Tries to remove a pilot from the stack.
Definition pilot.c:3992

pilot_getNearestEnemy_size
unsigned int pilot_getNearestEnemy_size(const Pilot *p, double target_mass_LB, double target_mass_UB)
Gets the nearest enemy to the pilot closest to the pilot whose mass is between LB and UB.
Definition pilot.c:361

pilot_choosePoint
void pilot_choosePoint(vec2 *vp, Spob **spob, JumpPoint **jump, int lf, int ignore_rules, int guerilla)
Finds a spawn point for a pilot.
Definition pilot.c:3784

pilot_isHostile
int pilot_isHostile(const Pilot *p)
Checks to see if pilot is hostile to the player.
Definition pilot.c:699

pilot_updateDisable
void pilot_updateDisable(Pilot *p, unsigned int shooter)
Handles pilot disabling. Set or unset the disable status depending on health and stress values.
Definition pilot.c:1605

pilot_cooldown
void pilot_cooldown(Pilot *p, int dochecks)
Begins active cooldown, reducing hull and outfit temperatures.
Definition pilot.c:918

pilot_brakeCheckReverseThrusters
int pilot_brakeCheckReverseThrusters(const Pilot *p)
See if the pilot wants to use their reverse thrusters to brake.
Definition pilot.c:838

pilot_renderFramebuffer
void pilot_renderFramebuffer(Pilot *p, GLuint fbo, double fw, double fh, const Lighting *L)
Renders a pilot to a framebuffer.
Definition pilot.c:1849

pilot_rmHostile
void pilot_rmHostile(Pilot *p)
Unmarks a pilot as hostile to player.
Definition pilot.c:1277

pilot_addStack
unsigned int pilot_addStack(Pilot *p)
Adds a pilot to the stack.
Definition pilot.c:3690

pilots_updatePurge
void pilots_updatePurge(void)
Purges pilots set for deletion.
Definition pilot.c:4176

pilot_quadtreeParams
void pilot_quadtreeParams(int max_elem, int depth)
Sets the quad tree parameters. Can have significant impact on performance.
Definition pilot.c:4592

pilot_relhp
double pilot_relhp(const Pilot *cur_pilot, const Pilot *p)
Gets the relative hp(combined shields and armour) between the current pilot and the specified target.
Definition pilot.c:4468

pilot_validEnemy
int pilot_validEnemy(const Pilot *p, const Pilot *target)
Checks to see if a pilot is a valid enemy for another pilot.
Definition pilot.c:291

pilot_relsize
double pilot_relsize(const Pilot *cur_pilot, const Pilot *p)
Gets the relative size(shipmass) between the current pilot and the specified target.
Definition pilot.c:4364

pilot_areEnemies
int pilot_areEnemies(const Pilot *p, const Pilot *target)
Like areEnemies but for pilots.
Definition pilot.c:763

pilots_clear
void pilots_clear(void)
Clears all the pilots except the player and clear-exempt pilots.
Definition pilot.c:4137

pilot_getNearestPilot
unsigned int pilot_getNearestPilot(const Pilot *p)
Get the nearest pilot to a pilot.
Definition pilot.c:437

pilots_clean
void pilots_clean(int persist)
Cleans up the pilot stack - leaves the player.
Definition pilot.c:4052

pilot_getTarget
Pilot * pilot_getTarget(Pilot *p)
Gets the target of a pilot using a fancy caching system.
Definition pilot.c:655

pilot_createEmpty
Pilot * pilot_createEmpty(const Ship *ship, const char *name, int faction, PilotFlags flags)
Creates a pilot without adding it to the stack.
Definition pilot.c:3627

pilot_face
double pilot_face(Pilot *p, double dir, double dt)
Tries to turn the pilot to face dir.
Definition pilot.c:827

pilot_local_transform
mat4 pilot_local_transform(const Pilot *p)
Gets the local transformation matrix of a pilot.
Definition pilot.c:4507

pilot_getNearestPos
double pilot_getNearestPos(const Pilot *p, unsigned int *tp, double x, double y, int disabled)
Get the nearest pilot to a pilot from a certain position.
Definition pilot.c:564

pilot_clearTimers
void pilot_clearTimers(Pilot *pilot)
Clears the pilot's timers.
Definition pilot.c:4337

pilot_reldps
double pilot_reldps(const Pilot *cur_pilot, const Pilot *p)
Gets the relative damage output(total DPS) between the current pilot and the specified target.
Definition pilot.c:4445

pilot_msg
void pilot_msg(const Pilot *p, const Pilot *receiver, const char *type, unsigned int idx)
Sends a message.
Definition pilot.c:4531

pilot_dead
void pilot_dead(Pilot *p, unsigned int killer)
Pilot is dead, now will slowly explode.
Definition pilot.c:1687

pilot_setPlayer
Pilot * pilot_setPlayer(Pilot *after)
Replaces the player's pilot with an alternate ship with the same ID.
Definition pilot.c:3735

pilot_renderOverlay
void pilot_renderOverlay(Pilot *p)
Renders the pilot overlay.
Definition pilot.c:2235

pilot_setAccel
void pilot_setAccel(Pilot *p, double accel)
Sets the pilot's accel.
Definition pilot.c:680

pilot_cooldownEnd
void pilot_cooldownEnd(Pilot *p, const char *reason)
Terminates active cooldown.
Definition pilot.c:986

pilot_modCredits
credits_t pilot_modCredits(Pilot *p, credits_t amount)
Modifies the amount of credits the pilot has.
Definition pilot.c:3300

pilot_getNearestEnemy
unsigned int pilot_getNearestEnemy(const Pilot *p)
Gets the nearest enemy to the pilot.
Definition pilot.c:331

pilot_setFriendly
void pilot_setFriendly(Pilot *p)
Marks pilot as friendly to player.
Definition pilot.c:1295

pilot_hyperspaceAbort
void pilot_hyperspaceAbort(Pilot *p)
Stops the pilot from hyperspacing.
Definition pilot.c:3140

pilot_setTurn
void pilot_setTurn(Pilot *p, double turn)
Sets the pilot's turn.
Definition pilot.c:688

pilot_validTarget
int pilot_validTarget(const Pilot *p, const Pilot *target)
Checks to see if a pilot is a valid target for another pilot.
Definition pilot.c:235

pilot_explode
void pilot_explode(double x, double y, double radius, const Damage *dmg, const Pilot *parent)
Makes the pilot explosion.
Definition pilot.c:1767

pilot_reset
void pilot_reset(Pilot *pilot)
Resets a pilot.
Definition pilot.c:3491

pilot_isFriendly
int pilot_isFriendly(const Pilot *p)
Checks to see if pilot is friendly to the player.
Definition pilot.c:728

pilot_refuelStart
int pilot_refuelStart(Pilot *p)
Attempts to start refueling the pilot's target.
Definition pilot.c:3170

pilots_renderOverlay
void pilots_renderOverlay(void)
Renders all the pilots overlays.
Definition pilot.c:4314

pilot_isNeutral
int pilot_isNeutral(const Pilot *p)
Checks to see if pilot is neutral to the player.
Definition pilot.c:715

pilot_getDockSlot
PilotOutfitSlot * pilot_getDockSlot(Pilot *p)
Gets the dock slot of the pilot.
Definition pilot.c:793

pilots_init
void pilots_init(void)
Initializes pilot stuff.
Definition pilot.c:4010

pilot_hasIllegal
int pilot_hasIllegal(const Pilot *p, int faction)
Checks to see if the pilot has illegal stuf to a faction.
Definition pilot.c:4567

pilot_setCommMsg
void pilot_setCommMsg(Pilot *p, const char *s)
Sets the overhead communication message of the pilot.
Definition pilot.c:1137

pilot_get
Pilot * pilot_get(unsigned int id)
Pulls a pilot out of the pilot_stack based on ID.
Definition pilot.c:640

pilot_hyperspaceDelay
ntime_t pilot_hyperspaceDelay(const Pilot *p)
Calculates the hyperspace delay for a pilot.
Definition pilot.c:3243

pilot_broadcast
void pilot_broadcast(Pilot *p, const char *msg, int ignore_int)
Has the pilot broadcast a message.
Definition pilot.c:1152

pilot_minbrakedist
double pilot_minbrakedist(const Pilot *p, double dt, double *flytime)
Gets the minimum braking distance for the pilot.
Definition pilot.c:862

pilot_setHostile
void pilot_setHostile(Pilot *p)
Marks pilot as hostile to player.
Definition pilot.c:1105

pilot_getNearestPosPilot
double pilot_getNearestPosPilot(const Pilot *p, Pilot **tp, double x, double y, int disabled)
Get the nearest pilot to a pilot from a certain position.
Definition pilot.c:518

pilot_dpseps
void pilot_dpseps(const Pilot *p, double *pdps, double *peps)
Calculates the dps and eps of a pilot.
Definition pilot.c:4377

pilot_getColour
const glColour * pilot_getColour(const Pilot *p)
Gets a pilot's colour.
Definition pilot.c:1328

pilot_distress
void pilot_distress(Pilot *p, Pilot *attacker, const char *msg)
Has the pilot broadcast a distress signal.
Definition pilot.c:1180

pilot_render
void pilot_render(Pilot *p)
Renders the pilot.
Definition pilot.c:1958

pilot_getAll
Pilot *const * pilot_getAll(void)
Gets the pilot stack.
Definition pilot.c:93

pilot_canTarget
int pilot_canTarget(const Pilot *p)
Same as pilot_validTarget but without the range check.
Definition pilot.c:270

pilot_worth
credits_t pilot_worth(const Pilot *p, int count_unique)
Gets the price or worth of a pilot in credits.
Definition pilot.c:4482

pilot_getNearestEnemy_heuristic
unsigned int pilot_getNearestEnemy_heuristic(const Pilot *p, double mass_factor, double health_factor, double damage_factor, double range_factor)
Gets the nearest enemy to the pilot closest to the pilot whose mass is between LB and UB.
Definition pilot.c:400

pilot_aimAngle
double pilot_aimAngle(Pilot *p, const vec2 *pos, const vec2 *vel)
Returns the angle for a pilot to aim at another pilot.
Definition pilot.c:1025

pilots_newSystem
void pilots_newSystem(void)
Updates pilot state which depends on the system (sensor range, nebula trails...)
Definition pilot.c:4116

pilot_getNextID
unsigned int pilot_getNextID(unsigned int id, int mode)
Gets the next pilot based on id.
Definition pilot.c:135

pilot_rmFriendly
void pilot_rmFriendly(Pilot *p)
Unmarks a pilot as friendly to player.
Definition pilot.c:1306

pilots_render
void pilots_render(void)
Renders all the pilots.
Definition pilot.c:4293

pilot_areAllies
int pilot_areAllies(const Pilot *p, const Pilot *target)
Like areAllies but for pilots.
Definition pilot.c:741

pilot_validTargetRange
int pilot_validTargetRange(const Pilot *p, const Pilot *target, int *inrange)
Checks to see if a pilot is a valid target for another pilot while storing the result of pilot_inRang...
Definition pilot.c:250

pilot_getNearestAng
double pilot_getNearestAng(const Pilot *p, unsigned int *tp, double ang, int disabled)
Get the pilot closest to an angle extending from another pilot.
Definition pilot.c:585

pilot_untargetAsteroid
void pilot_untargetAsteroid(int anchor, int asteroid)
Loops over pilot stack to remove an asteroid as target.
Definition pilot.c:3255

pilot_getJumps
int pilot_getJumps(const Pilot *p)
Gets the amount of jumps the pilot has left.
Definition pilot.c:1317

pilot_delete
void pilot_delete(Pilot *p)
Deletes a pilot.
Definition pilot.c:2965

pilots_update
void pilots_update(double dt)
Updates all the pilots.
Definition pilot.c:4216

pilots_cleanAll
void pilots_cleanAll(void)
Even cleans up the player.
Definition pilot.c:4148

pilot_clearTrails
void pilot_clearTrails(Pilot *p)
Resets the trails for a pilot.
Definition pilot.c:3722

pilot_getBoss
unsigned int pilot_getBoss(const Pilot *p)
Get the strongest ally in a given range.
Definition pilot.c:450

pilots_free
void pilots_free(void)
Frees the pilot stack.
Definition pilot.c:4019

pilot_hit
double pilot_hit(Pilot *p, const Solid *w, const Pilot *pshooter, const Damage *dmg, const Outfit *outfit, int lua_mem, int reset)
Damages the pilot.
Definition pilot.c:1383

pilot_update
void pilot_update(Pilot *pilot, double dt)
Updates the pilot.
Definition pilot.c:2328

pilot_create
Pilot * 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)
Creates a new pilot.
Definition pilot.c:3557

pilot_getPrevID
unsigned int pilot_getPrevID(unsigned int id, int mode)
Gets the previous pilot based on ID.
Definition pilot.c:183

pilot_numOutfit
int pilot_numOutfit(const Pilot *p, const Outfit *o)
Checks to see how many of an outfit a pilot has.
Definition pilot.c:3269

pilot_sample_trails
void pilot_sample_trails(Pilot *p, int none)
Updates the given pilot's trail emissions.
Definition pilot.c:2846

pilot_hasCredits
int pilot_hasCredits(const Pilot *p, credits_t amount)
Checks to see if the pilot has at least a certain amount of credits.
Definition pilot.c:3286

pilot_brake
int pilot_brake(Pilot *p, double dt)
Causes the pilot to turn around and brake.
Definition pilot.c:886

pilot_setTarget
void pilot_setTarget(Pilot *p, unsigned int id)
Sets the target of the pilot.
Definition pilot.c:1352

pilot_clone
unsigned int pilot_clone(const Pilot *ref)
Clones an existing pilot.
Definition pilot.c:3646

AI_Profile
Basic AI profile.
Definition ai.h:39

Commodity
Represents a commodity.
Definition commodity.h:57

Damage
Core damage that an outfit does.
Definition outfit.h:168

Effect
Pilot ship effect.
Definition effect.h:49

Escort_t
Stores an escort.
Definition pilot.h:252

Escort_t::id
unsigned int id
Definition pilot.h:255

Escort_t::persist
int persist
Definition pilot.h:257

Escort_t::type
EscortType_t type
Definition pilot.h:254

Escort_t::ship
const Ship * ship
Definition pilot.h:253

IntList
Definition intlist.h:20

Lighting
Definition gltf.h:217

Outfit
A ship outfit, depends radically on the type.
Definition outfit.h:372

PilotCommodity
Stores a pilot commodity.
Definition pilot.h:223

PilotCommodity::commodity
const Commodity * commodity
Definition pilot.h:224

PilotCommodity::id
unsigned int id
Definition pilot.h:226

PilotCommodity::quantity
int quantity
Definition pilot.h:225

PilotHook
A wrapper for pilot hooks.
Definition pilot.h:232

PilotHook::id
unsigned int id
Definition pilot.h:234

PilotHook::type
int type
Definition pilot.h:233

PilotOutfitAmmo
Stores outfit ammo.
Definition pilot.h:114

PilotOutfitAmmo::deployed
int deployed
Definition pilot.h:116

PilotOutfitAmmo::quantity
int quantity
Definition pilot.h:115

PilotOutfitAmmo::lockon_timer
double lockon_timer
Definition pilot.h:117

PilotOutfitAmmo::in_arc
int in_arc
Definition pilot.h:118

PilotOutfitSlot
Stores an outfit the pilot has.
Definition pilot.h:145

PilotOutfitSlot::beamid
unsigned int beamid
Definition pilot.h:172

PilotOutfitSlot::weapset
int weapset
Definition pilot.h:166

PilotOutfitSlot::ammo
PilotOutfitAmmo ammo
Definition pilot.h:174

PilotOutfitSlot::heat_C
double heat_C
Definition pilot.h:155

PilotOutfitSlot::flags
int flags
Definition pilot.h:150

PilotOutfitSlot::stimer
double stimer
Definition pilot.h:161

PilotOutfitSlot::id
int id
Definition pilot.h:146

PilotOutfitSlot::rtimer
double rtimer
Definition pilot.h:163

PilotOutfitSlot::heat_start
double heat_start
Definition pilot.h:157

PilotOutfitSlot::heat_T
double heat_T
Definition pilot.h:154

PilotOutfitSlot::progress
double progress
Definition pilot.h:165

PilotOutfitSlot::heat_area
double heat_area
Definition pilot.h:156

PilotOutfitSlot::state
PilotOutfitState state
Definition pilot.h:160

PilotOutfitSlot::lua_mem
int lua_mem
Definition pilot.h:179

PilotOutfitSlot::lua_stats
ShipStatList * lua_stats
Definition pilot.h:180

PilotOutfitSlot::timer
double timer
Definition pilot.h:162

PilotOutfitSlot::inrange
unsigned int inrange
Definition pilot.h:167

PilotOutfitSlot::sslot
ShipOutfitSlot * sslot
Definition pilot.h:151

PilotOutfitSlot::outfit
const Outfit * outfit
Definition pilot.h:149

PilotWeaponSetOutfit
A pilot Weapon Set Outfit.
Definition pilot.h:187

PilotWeaponSetOutfit::slotid
int slotid
Definition pilot.h:189

PilotWeaponSetOutfit::range2
double range2
Definition pilot.h:188

PilotWeaponSet
A weapon set represents a set of weapons that have an action.
Definition pilot.h:207

PilotWeaponSet::inrange
int inrange
Definition pilot.h:212

PilotWeaponSet::range
double range
Definition pilot.h:216

PilotWeaponSet::range_min
double range_min
Definition pilot.h:215

PilotWeaponSet::slots
PilotWeaponSetOutfit * slots
Definition pilot.h:210

PilotWeaponSet::active
int active
Definition pilot.h:209

PilotWeaponSet::volley
int volley
Definition pilot.h:214

PilotWeaponSet::manual
int manual
Definition pilot.h:213

PilotWeaponSet::speed
double speed
Definition pilot.h:217

PilotWeaponSet::type
WeaponSetType type
Definition pilot.h:208

Pilot
The representation of an in-game pilot.
Definition pilot.h:263

Pilot::tilt
double tilt
Definition pilot.h:443

Pilot::advweap
int advweap
Definition pilot.h:378

Pilot::engine_glow
double engine_glow
Definition pilot.h:442

Pilot::ew_stealth_timer
double ew_stealth_timer
Definition pilot.h:329

Pilot::nturrets
int nturrets
Definition pilot.h:364

Pilot::dtimer
double dtimer
Definition pilot.h:432

Pilot::dtimer_accum
double dtimer_accum
Definition pilot.h:433

Pilot::ship_stats
ShipStatList * ship_stats
Definition pilot.h:343

Pilot::itimer
double itimer
Definition pilot.h:428

Pilot::stats
ShipStats stats
Definition pilot.h:348

Pilot::accel
double accel
Definition pilot.h:291

Pilot::shield
double shield
Definition pilot.h:303

Pilot::otimer
double otimer
Definition pilot.h:434

Pilot::speed_limit
double speed_limit
Definition pilot.h:296

Pilot::ai
AI_Profile * ai
Definition pilot.h:408

Pilot::presence
int presence
Definition pilot.h:271

Pilot::id
unsigned int id
Definition pilot.h:264

Pilot::shipvar
lvar * shipvar
Definition pilot.h:445

Pilot::comm_msgWidth
double comm_msgWidth
Definition pilot.h:422

Pilot::weapon_sets
PilotWeaponSet weapon_sets[PILOT_WEAPON_SETS]
Definition pilot.h:376

Pilot::commodities
PilotCommodity * commodities
Definition pilot.h:383

Pilot::aimLines
int aimLines
Definition pilot.h:379

Pilot::turn_base
double turn_base
Definition pilot.h:298

Pilot::cpu_max
int cpu_max
Definition pilot.h:285

Pilot::crew
double crew
Definition pilot.h:286

Pilot::ew_stealth
double ew_stealth
Definition pilot.h:323

Pilot::outfit_structure
PilotOutfitSlot * outfit_structure
Definition pilot.h:356

Pilot::parent
unsigned int parent
Definition pilot.h:390

Pilot::credits
credits_t credits
Definition pilot.h:382

Pilot::nav_hyperspace
int nav_hyperspace
Definition pilot.h:403

Pilot::projectiles
int projectiles
Definition pilot.h:438

Pilot::scantimer
double scantimer
Definition pilot.h:435

Pilot::refuel_amount
double refuel_amount
Definition pilot.h:369

Pilot::energy_regen
double energy_regen
Definition pilot.h:316

Pilot::outfits
PilotOutfitSlot ** outfits
Definition pilot.h:354

Pilot::outfit_utility
PilotOutfitSlot * outfit_utility
Definition pilot.h:357

Pilot::outfit_intrinsic
PilotOutfitSlot * outfit_intrinsic
Definition pilot.h:360

Pilot::outfitlupdate
int outfitlupdate
Definition pilot.h:368

Pilot::messages
int messages
Definition pilot.h:444

Pilot::lua_ship_timer
double lua_ship_timer
Definition pilot.h:418

Pilot::armour_max
double armour_max
Definition pilot.h:304

Pilot::speed
double speed
Definition pilot.h:293

Pilot::tsy
int tsy
Definition pilot.h:280

Pilot::tsx
int tsx
Definition pilot.h:279

Pilot::speed_base
double speed_base
Definition pilot.h:294

Pilot::ew_asteroid
double ew_asteroid
Definition pilot.h:326

Pilot::timer
double timer[MAX_AI_TIMERS]
Definition pilot.h:411

Pilot::heat_start
double heat_start
Definition pilot.h:340

Pilot::htimer
double htimer
Definition pilot.h:429

Pilot::ew_mass
double ew_mass
Definition pilot.h:325

Pilot::ship
const Ship * ship
Definition pilot.h:274

Pilot::sbonus
double sbonus
Definition pilot.h:431

Pilot::lockons
int lockons
Definition pilot.h:437

Pilot::fuel_max
double fuel_max
Definition pilot.h:309

Pilot::intrinsic_stats
ShipStatList * intrinsic_stats
Definition pilot.h:345

Pilot::ncannons
int ncannons
Definition pilot.h:363

Pilot::energy
double energy
Definition pilot.h:314

Pilot::ew_detection
double ew_detection
Definition pilot.h:320

Pilot::nav_anchor
int nav_anchor
Definition pilot.h:404

Pilot::stress
double stress
Definition pilot.h:302

Pilot::hail_pos
int hail_pos
Definition pilot.h:436

Pilot::mass_cargo
double mass_cargo
Definition pilot.h:277

Pilot::ptimer
double ptimer
Definition pilot.h:427

Pilot::faction
int faction
Definition pilot.h:269

Pilot::hooks
PilotHook * hooks
Definition pilot.h:387

Pilot::faction_spawn
int faction_spawn
Definition pilot.h:270

Pilot::autoweap
int autoweap
Definition pilot.h:377

Pilot::comm_msgTimer
double comm_msgTimer
Definition pilot.h:421

Pilot::stimer
double stimer
Definition pilot.h:430

Pilot::energy_max
double energy_max
Definition pilot.h:315

Pilot::landing_delay
double landing_delay
Definition pilot.h:425

Pilot::shoot_indicator
unsigned int shoot_indicator
Definition pilot.h:413

Pilot::solid
Solid solid
Definition pilot.h:275

Pilot::fuel
double fuel
Definition pilot.h:310

Pilot::afterburner
PilotOutfitSlot * afterburner
Definition pilot.h:372

Pilot::cdelay
double cdelay
Definition pilot.h:338

Pilot::accel_base
double accel_base
Definition pilot.h:292

Pilot::pdata
double pdata
Definition pilot.h:426

Pilot::name
char * name
Definition pilot.h:265

Pilot::ptarget
void * ptarget
Definition pilot.h:401

Pilot::tcontrol
double tcontrol
Definition pilot.h:410

Pilot::r
double r
Definition pilot.h:266

Pilot::flags
PilotFlags flags
Definition pilot.h:424

Pilot::nbeams
int nbeams
Definition pilot.h:365

Pilot::mass_outfit
double mass_outfit
Definition pilot.h:278

Pilot::escorts
Escort_t * escorts
Definition pilot.h:391

Pilot::dockpilot
unsigned int dockpilot
Definition pilot.h:392

Pilot::cpu
int cpu
Definition pilot.h:284

Pilot::trail
Trail_spfx ** trail
Definition pilot.h:281

Pilot::fuel_consumption
double fuel_consumption
Definition pilot.h:311

Pilot::lua_ship_mem
int lua_ship_mem
Definition pilot.h:417

Pilot::ctimer
double ctimer
Definition pilot.h:339

Pilot::heat_cond
double heat_cond
Definition pilot.h:336

Pilot::base_mass
double base_mass
Definition pilot.h:276

Pilot::heat_T
double heat_T
Definition pilot.h:332

Pilot::heat_emis
double heat_emis
Definition pilot.h:335

Pilot::task
Task * task
Definition pilot.h:412

Pilot::heat_C
double heat_C
Definition pilot.h:333

Pilot::nfighterbays
int nfighterbays
Definition pilot.h:366

Pilot::shield_regen
double shield_regen
Definition pilot.h:307

Pilot::cargo_free
int cargo_free
Definition pilot.h:384

Pilot::ew_jumppoint
double ew_jumppoint
Definition pilot.h:327

Pilot::target
unsigned int target
Definition pilot.h:400

Pilot::nafterburners
int nafterburners
Definition pilot.h:367

Pilot::nav_spob
int nav_spob
Definition pilot.h:402

Pilot::dockslot
int dockslot
Definition pilot.h:396

Pilot::lua_mem
int lua_mem
Definition pilot.h:409

Pilot::player_damage
double player_damage
Definition pilot.h:440

Pilot::effects
Effect * effects
Definition pilot.h:351

Pilot::cap_cargo
double cap_cargo
Definition pilot.h:288

Pilot::turn
double turn
Definition pilot.h:297

Pilot::comm_msg
char * comm_msg
Definition pilot.h:423

Pilot::outfit_weapon
PilotOutfitSlot * outfit_weapon
Definition pilot.h:358

Pilot::armour
double armour
Definition pilot.h:301

Pilot::shield_max
double shield_max
Definition pilot.h:305

Pilot::dmg_absorb
double dmg_absorb
Definition pilot.h:308

Pilot::mounted
int * mounted
Definition pilot.h:439

Pilot::nav_asteroid
int nav_asteroid
Definition pilot.h:405

Pilot::heat_area
double heat_area
Definition pilot.h:337

Pilot::ew_signature
double ew_signature
Definition pilot.h:321

Pilot::armour_regen
double armour_regen
Definition pilot.h:306

ShipOutfitSlot
Ship outfit slot.
Definition ship.h:71

ShipStatList
Represents relative ship statistics as a linked list.
Definition shipstats.h:198

ShipStats
Represents ship statistics, properties ship can use.
Definition shipstats.h:229

Ship
Represents a space ship.
Definition ship.h:97

Solid
Represents a solid in the game.
Definition physics.h:44

Spob
Represents a Space Object (SPOB), including and not limited to planets, stations, wormholes,...
Definition space.h:102

Task
Basic AI task.
Definition ai.h:23

Trail_spfx
A trail generated by a ship or an ammo.
Definition spfx.h:93

lvar
Contains a mission variable.
Definition lvar.h:24

mat4
Definition mat4.h:12

vec2
Represents a 2d vector.
Definition vec2.h:45