pilot_weapon.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include "naev.h"
#include "array.h"
#include "escort.h"
#include "log.h"
#include "nxml.h"
#include "nlua_pilot.h"
#include "nlua_pilotoutfit.h"
#include "pilot.h"
#include "player.h"
#include "spfx.h"
#include "weapon.h"
 
/*
 * Prototypes.
 */
static void pilot_weapSetUpdateOutfits( Pilot* p, PilotWeaponSet *ws );
static int pilot_weapSetFire( Pilot *p, PilotWeaponSet *ws, int level );
static int pilot_shootWeaponSetOutfit( Pilot* p, PilotWeaponSet *ws, const Outfit *o, int level, double time, int aim );
static int pilot_shootWeapon( Pilot *p, PilotOutfitSlot *w, double time, int aim );
static void pilot_weapSetUpdateRange( const Pilot *p, PilotWeaponSet *ws );
unsigned int pilot_weaponSetShootStop( Pilot* p, PilotWeaponSet *ws, int level );
 
PilotWeaponSet* pilot_weapSet( Pilot* p, int id )
{
   return &p->weapon_sets[ id ];
}
 
static int pilot_weapSetFire( Pilot *p, PilotWeaponSet *ws, int level )
{
   int ret, s;
   Pilot *pt;
   AsteroidAnchor *field;
   Asteroid *ast;
   double time;
   int isstealth;
 
   isstealth = pilot_isFlag( p, PILOT_STEALTH );
 
   ret = 0;
   for (int i=0; i<array_size(ws->slots); i++) {
      PilotOutfitSlot *pos = p->outfits[ ws->slots[i].slotid ];
      const Outfit *o = pos->outfit;
 
      /* Ignore NULL outfits. */
      if (o == NULL)
         continue;
 
      /* Only "active" outfits. */
      if ((level != -1) && (ws->slots[i].level != level))
         continue;
 
      /* Only run once for each weapon type in the group. */
      s = 0;
      for (int j=0; j<i; j++) {
         /* Only active outfits. */
         if ((level != -1) && (ws->slots[j].level != level))
            continue;
         /* Found a match. */
         if (p->outfits[ ws->slots[j].slotid ]->outfit == o) {
            s = 1;
            break;
         }
      }
      if (s!=0)
         continue;
 
      /* Only "locked on" outfits. */
      if (outfit_isSeeker(o) && (pos->u.ammo.lockon_timer > 0.))
         continue;
 
      /* If inrange is set we only fire at targets in range. */
      time = INFINITY;  /* With no target we just set time to infinity. */
 
      /* Calculate time to target if it is there. */
      pt = pilot_getTarget( p );
      if (pt != NULL)
         time = pilot_weapFlyTime( o, p, &pt->solid->pos, &pt->solid->vel);
      /* Looking for a closer targeted asteroid */
      else if (p->nav_asteroid != -1) {
         field = &cur_system->asteroids[p->nav_anchor];
         ast = &field->asteroids[p->nav_asteroid];
         time = pilot_weapFlyTime( o, p, &ast->pos, &ast->vel);
      }
 
      /* Only "inrange" outfits. */
      if (ws->inrange && outfit_duration(o) < time)
         continue;
 
      /* Shoot the weapon of the weaponset. */
      ret += pilot_shootWeaponSetOutfit( p, ws, o, level, time, !ws->manual );
   }
 
   /* Destealth when attacking. */
   if (isstealth && (ret>0))
      pilot_destealth( p );
 
   /* Trigger onshoot after stealth gets broken. */
   if (ret > 0)
      pilot_outfitLOnshoot( p );
 
   return ret;
}
 
void pilot_weapSetAIClear( Pilot* p )
{
   for (int i=0; i<PILOT_WEAPON_SETS; i++) {
      PilotWeaponSet *ws = &p->weapon_sets[i];
      ws->active = 0;
   }
}
 
void pilot_weapSetPress( Pilot* p, int id, int type )
{
   int l, on, n;
   int isstealth = pilot_isFlag( p, PILOT_STEALTH );
   PilotWeaponSet *ws = pilot_weapSet(p,id);
   /* Case no outfits. */
   if (ws->slots == NULL)
      return;
 
   /* Handle fire groups. */
   switch (ws->type) {
      case WEAPSET_TYPE_CHANGE:
         /* On press just change active weapon set to whatever is available. */
         if ((type > 0) && (array_size(ws->slots)>0)) {
            if (id != p->active_set)
               pilot_weapSetUpdateOutfits( p, ws );
            p->active_set = id;
         }
         break;
 
      case WEAPSET_TYPE_WEAPON:
         /* Activation philosophy here is to turn on while pressed and off
          * when it's not held anymore. */
         if (type > 0)
            ws->active = 1;
         else if (type < 0) {
            ws->active = 0;
            if (pilot_weaponSetShootStop( p, ws, -1 )) /* De-activate weapon set. */
               pilot_calcStats( p ); /* Just in case there is a activated outfit here. */
         }
         break;
 
      case WEAPSET_TYPE_ACTIVE:
         /* The behaviour here is more complex. What we do is consider a group
          * to be entirely off if not all outfits are either on or cooling down.
          * In the case it's deemed to be off, all outfits that are off get turned
          * on, otherwise all outfits that are on are turrned to cooling down. */
         /* Only care about presses. */
         if (type < 0)
            break;
 
         /* Must not be disabled or cooling down. */
         if ((pilot_isDisabled(p)) || (pilot_isFlag(p, PILOT_COOLDOWN)))
            return;
 
         /* Decide what to do. */
         on = 1;
         l  = array_size(ws->slots);
         for (int i=0; i<l; i++) {
            PilotOutfitSlot *pos = p->outfits[ ws->slots[i].slotid ];
            if (pos->state == PILOT_OUTFIT_OFF) {
               on = 0;
               break;
            }
         }
 
         /* Turn them off. */
         n = 0;
         if (on) {
            for (int i=0; i<l; i++) {
               PilotOutfitSlot *pos = p->outfits[ ws->slots[i].slotid ];
               if (pos->state != PILOT_OUTFIT_ON)
                  continue;
 
               n += pilot_outfitOff( p, pos );
            }
         }
         /* Turn them on. */
         else {
            pilotoutfit_modified = 0;
            for (int i=0; i<l; i++) {
               PilotOutfitSlot *pos = p->outfits[ ws->slots[i].slotid ];
               if (pos->state != PILOT_OUTFIT_OFF)
                  continue;
 
               n += pilot_outfitOn( p, pos );
            }
            /* Recalculate if anything changed. */
            if (pilotoutfit_modified)
               pilot_calcStats( p );
         }
         /* Must recalculate stats. */
         if (n > 0) {
            /* pilot_destealth should run calcStats already. */
            if (isstealth)
               pilot_destealth( p );
            else
               pilot_calcStats( p );
         }
 
         break;
   }
}
 
void pilot_weapSetUpdate( Pilot* p )
{
   if (pilot_isFlag( p, PILOT_HYP_BEGIN))
      return;
 
   for (int i=0; i<PILOT_WEAPON_SETS; i++) {
      PilotWeaponSet *ws = &p->weapon_sets[i];
      if (ws->slots == NULL)
         continue;
 
      /* Weapons must get "fired" every turn. */
      if (ws->type == WEAPSET_TYPE_WEAPON) {
         if (ws->active)
            pilot_weapSetFire( p, ws, -1 );
      }
   }
}
 
static void pilot_weapSetUpdateOutfits( Pilot* p, PilotWeaponSet *ws )
{
   for (int i=0; i<array_size(p->outfits); i++)
      p->outfits[i]->level = -1;
 
   for (int i=0; i<array_size(ws->slots); i++)
      p->outfits[ ws->slots[i].slotid ]->level = ws->slots[i].level;
}
 
int pilot_weapSetTypeCheck( Pilot* p, int id )
{
   PilotWeaponSet *ws = pilot_weapSet(p,id);
   return ws->type;
}
 
void pilot_weapSetType( Pilot* p, int id, int type )
{
   PilotWeaponSet *ws = pilot_weapSet(p,id);
   ws->type = type;
 
   /* Set levels just in case. */
   if ((ws->type == WEAPSET_TYPE_WEAPON) ||
         (ws->type == WEAPSET_TYPE_ACTIVE))
      for (int i=0; i<array_size(ws->slots); i++)
         ws->slots[i].level = 0;
}
 
int pilot_weapSetInrangeCheck( Pilot* p, int id )
{
   PilotWeaponSet *ws = pilot_weapSet(p,id);
   return ws->inrange;
}
 
void pilot_weapSetInrange( Pilot* p, int id, int inrange )
{
   PilotWeaponSet *ws = pilot_weapSet(p,id);
   ws->inrange = inrange;
}
 
int pilot_weapSetManualCheck( Pilot *p, int id )
{
   PilotWeaponSet *ws = pilot_weapSet(p,id);
   return ws->manual;
}
 
void pilot_weapSetManual( Pilot* p, int id, int manual )
{
   PilotWeaponSet *ws = pilot_weapSet(p,id);
   ws->manual = manual;
}
 
const char *pilot_weapSetName( Pilot* p, int id )
{
   PilotWeaponSet *ws = pilot_weapSet(p,id);
   if (array_size(ws->slots)==0)
      return _("Unused");
   switch (ws->type) {
      case WEAPSET_TYPE_CHANGE: return _("Weapons - Switched");  break;
      case WEAPSET_TYPE_WEAPON: return _("Weapons - Instant");   break;
      case WEAPSET_TYPE_ACTIVE: return _("Abilities - Toggled"); break;
   }
   return NULL;
}
 
void pilot_weapSetRmSlot( Pilot *p, int id, OutfitSlotType type )
{
   int n, l;
   PilotWeaponSet *ws;
 
   /* We must clean up the slots. */
   n  = 0; /* Number to remove. */
   ws = pilot_weapSet(p,id);
   if (ws->slots == NULL)
      return;
   l  = array_size(ws->slots);
   for (int i=0; i<l; i++) {
      PilotOutfitSlot *pos = p->outfits[ ws->slots[i].slotid ];
 
      if (pos->sslot->slot.type != type)
         continue;
 
      /* Move down. */
      memmove( &ws->slots[i], &ws->slots[i+1], sizeof(PilotWeaponSetOutfit) * (l-i-1) );
      n++;
   }
 
   /* Remove surplus. */
   array_erase( &ws->slots, &ws->slots[l-n], &ws->slots[l] );
}
 
void pilot_weapSetAdd( Pilot* p, int id, PilotOutfitSlot *o, int level )
{
   PilotWeaponSetOutfit *slot;
   const Outfit *oo;
   double r;
   PilotWeaponSet *ws = pilot_weapSet(p,id);
 
   /* Make sure outfit is valid. */
   oo = o->outfit;
   if (oo == NULL)
      return;
 
   /* Make sure outfit type is weapon (or usable). */
   if (!pilot_slotIsToggleable(o))
      return;
 
   /* Create if needed. */
   if (ws->slots == NULL)
      ws->slots = array_create( PilotWeaponSetOutfit );
 
   /* Check if already there. */
   for (int i=0; i<array_size(ws->slots); i++) {
      if (ws->slots[i].slotid == o->id) {
         ws->slots[i].level = level;
 
         /* Update if needed. */
         if (id == p->active_set)
            pilot_weapSetUpdateOutfits( p, ws );
         return;
      }
   }
 
   /* Add it. */
   slot        = &array_grow( &ws->slots );
   slot->level = level;
   slot->slotid= o->id;
   r           = outfit_range(oo);
   if (r > 0)
      slot->range2 = pow2(r);
 
   /* Updated cached weapset. */
   o->weapset = -1;
   for (int j=0; j<PILOT_WEAPON_SETS; j++) {
      if (pilot_weapSetCheck(p, j, o) != -1) {
         o->weapset = j;
         break;
      }
   }
 
   /* Update range. */
   pilot_weapSetUpdateRange( p, ws );
 
   /* Update if needed. */
   if (id == p->active_set)
      pilot_weapSetUpdateOutfits( p, ws );
}
 
void pilot_weapSetRm( Pilot* p, int id, PilotOutfitSlot *o )
{
   PilotWeaponSet *ws = pilot_weapSet(p,id);
   for (int i=0; i<array_size(ws->slots); i++) {
      if (ws->slots[i].slotid != o->id)
         continue;
 
      array_erase( &ws->slots, &ws->slots[i], &ws->slots[i+1] );
 
      /* Update range. */
      pilot_weapSetUpdateRange( p, ws );
 
      /* Update if needed. */
      if (id == p->active_set)
         pilot_weapSetUpdateOutfits( p, ws );
 
      /* Updated cached weapset. */
      o->weapset = -1;
      for (int j=0; j<PILOT_WEAPON_SETS; j++) {
         if (pilot_weapSetCheck(p, j, o) != -1) {
            o->weapset = j;
            break;
         }
      }
 
      return;
   }
}
 
int pilot_weapSetCheck( Pilot* p, int id, PilotOutfitSlot *o )
{
   PilotWeaponSet *ws = pilot_weapSet(p,id);
   for (int i=0; i<array_size(ws->slots); i++)
      if (ws->slots[i].slotid == o->id)
         return ws->slots[i].level;
 
   /* Not found. */
   return -1;
}
 
void pilot_weapSetUpdateStats( Pilot *p )
{
   for (int i=0; i<PILOT_WEAPON_SETS; i++)
      pilot_weapSetUpdateRange( p, &p->weapon_sets[i] );
}
 
static void pilot_weapSetUpdateRange( const Pilot *p, PilotWeaponSet *ws )
{
   int lev;
   double range, speed;
   double range_accum[PILOT_WEAPSET_MAX_LEVELS];
   int range_num[PILOT_WEAPSET_MAX_LEVELS];
   double speed_accum[PILOT_WEAPSET_MAX_LEVELS];
   int speed_num[PILOT_WEAPSET_MAX_LEVELS];
 
   /* Calculate ranges. */
   for (int i=0; i<PILOT_WEAPSET_MAX_LEVELS; i++) {
      range_accum[i] = 0.;
      range_num[i]   = 0;
      speed_accum[i] = 0.;
      speed_num[i]   = 0;
   }
   for (int i=0; i<array_size(ws->slots); i++) {
      PilotOutfitSlot *pos = p->outfits[ ws->slots[i].slotid ];
      if (pos->outfit == NULL)
         continue;
 
      /* Get level. */
      lev = ws->slots[i].level;
      if (lev >= PILOT_WEAPSET_MAX_LEVELS)
         continue;
 
      /* Empty Launchers aren't valid */
      if (outfit_isLauncher(pos->outfit) && (pos->u.ammo.quantity <= 0))
         continue;
 
      /* Get range. */
      range = outfit_range(pos->outfit);
      if (outfit_isLauncher(pos->outfit))
         range *= p->stats.launch_range;
      if (range >= 0.) {
         /* Calculate. */
         range_accum[ lev ] += range;
         range_num[ lev ]++;
      }
 
      /* Get speed. */
      speed = outfit_speed(pos->outfit);
      if (speed >= 0.) {
         /* Calculate. */
         speed_accum[ lev ] += speed;
         speed_num[ lev ]++;
      }
   }
 
   /* Postprocess. */
   for (int i=0; i<PILOT_WEAPSET_MAX_LEVELS; i++) {
      /* Postprocess range. */
      if (range_num[i] == 0)
         ws->range[i] = 0;
      else
         ws->range[i] = range_accum[i] / (double) range_num[i];
 
      /* Postprocess speed. */
      if (speed_num[i] == 0)
         ws->speed[i] = 0;
      else
         ws->speed[i] = speed_accum[i] / (double) speed_num[i];
   }
}
 
double pilot_weapSetRange( Pilot* p, int id, int level )
{
   double range;
   PilotWeaponSet *ws = pilot_weapSet(p,id);
   if (level < 0) {
      range = 0.;
      for (int i=0; i<PILOT_WEAPSET_MAX_LEVELS; i++)
         range += ws->range[i];
   }
   else
      range = ws->range[ level ];
 
   return range;
}
 
double pilot_weapSetSpeed( Pilot* p, int id, int level )
{
   double speed;
   PilotWeaponSet *ws = pilot_weapSet(p,id);
   if (level < 0) {
      speed = 0.;
      for (int i=0; i<PILOT_WEAPSET_MAX_LEVELS; i++)
         speed += ws->speed[i];
   }
   else
      speed = ws->speed[ level ];
 
   return speed;
}
 
double pilot_weapSetAmmo( Pilot* p, int id, int level )
{
   PilotWeaponSet *ws;
   int amount, nammo;
   double ammo;
 
   ammo = 0.;
   nammo = 0;
   ws = pilot_weapSet(p,id);
   for (int i=0; i<array_size(ws->slots); i++) {
      PilotOutfitSlot *s = p->outfits[ ws->slots[i].slotid ];
      if ((level >= 0) && (ws->slots[i].level != level))
         continue;
      amount = pilot_maxAmmoO( p, s->outfit );
      if (amount > 0) {
         ammo += (double)s->u.ammo.quantity / (double)amount;
         nammo++;
      }
   }
   return (nammo==0) ? 0. : ammo / (double)nammo;
}
 
void pilot_weapSetCleanup( Pilot* p, int id )
{
   PilotWeaponSet *ws = pilot_weapSet(p,id);
 
   array_free( ws->slots );
   ws->slots = NULL;
 
   /* Update range. */
   pilot_weapSetUpdateRange( p, ws );
}
 
void pilot_weapSetFree( Pilot* p )
{
   for (int i=0; i<PILOT_WEAPON_SETS; i++)
      pilot_weapSetCleanup( p, i );
}
 
PilotWeaponSetOutfit* pilot_weapSetList( Pilot* p, int id )
{
   return pilot_weapSet( p, id )->slots;
}
 
int pilot_shoot( Pilot* p, int level )
{
   PilotWeaponSet *ws = pilot_weapSet( p, p->active_set );
 
   /* Fire weapons. */
   if (ws->type == WEAPSET_TYPE_CHANGE) { /* Must be a change set or a weaponset. */
      int ret = pilot_weapSetFire( p, ws, level );
 
      /* Firing weapons aborts active cooldown. */
      if (pilot_isFlag(p, PILOT_COOLDOWN) && ret)
         pilot_cooldownEnd(p, NULL);
 
      return ret;
   }
 
   return 0;
}
 
void pilot_shootStop( Pilot* p, int level )
{
   PilotWeaponSet *ws = pilot_weapSet( p, p->active_set );
 
   /* Stop and see if must recalculate. */
   if (pilot_weaponSetShootStop( p, ws, level ))
      pilot_calcStats( p );
}
 
unsigned int pilot_weaponSetShootStop( Pilot* p, PilotWeaponSet *ws, int level )
{
   /* Stop all beams. */
   int recalc = 0;
   for (int i=0; i<array_size(ws->slots); i++) {
      PilotOutfitSlot *pos = p->outfits[ ws->slots[i].slotid ];
 
      /* Must have associated outfit. */
      if (pos->outfit == NULL)
         continue;
 
      /* Must match level. */
      if ((level != -1) && (ws->slots[i].level != level))
         continue;
 
      /* Only handle beams. */
      if (!outfit_isBeam(pos->outfit)) {
         /* Turn off the state. */
         if (outfit_isMod( pos->outfit )) {
            pos->state = PILOT_OUTFIT_OFF;
            recalc = 1;
         }
         continue;
      }
 
      /* Stop beam. */
      if (pos->u.beamid > 0) {
         /* Enforce minimum duration if set. */
         if (pos->outfit->u.bem.min_duration > 0.) {
 
            pos->stimer = pos->outfit->u.bem.min_duration -
                  (pos->outfit->u.bem.duration - pos->timer);
 
            if (pos->stimer > 0.)
               continue;
         }
 
         beam_end( p->id, pos->u.beamid );
         pilot_stopBeam(p, pos);
      }
   }
 
   return recalc;
}
 
void pilot_stopBeam( Pilot *p, PilotOutfitSlot *w )
{
   double rate_mod, energy_mod, used;
 
   /* There's nothing to do if the beam isn't active. */
   if (w->u.beamid == 0)
      return;
 
   /* Safeguard against a nasty race condition. */
   if (w->outfit == NULL) {
      w->u.beamid = 0;
      return;
   }
 
   /* Lua test to stop beam. */
   if ((w->outfit->lua_ontoggle != LUA_NOREF) &&
         !pilot_outfitLOntoggle( p, w, 0 ))
      return;
 
   /* Calculate rate modifier. */
   pilot_getRateMod( &rate_mod, &energy_mod, p, w->outfit );
 
   /* Beam duration used. Compensate for the fact it's duration might have
    * been shortened by heat. */
   used = w->outfit->u.bem.duration - w->timer*(1.-pilot_heatAccuracyMod(w->heat_T));
 
   w->timer = rate_mod * (used / w->outfit->u.bem.duration) * outfit_delay( w->outfit );
   w->u.beamid = 0;
}
 
double pilot_weapFlyTime( const Outfit *o, const Pilot *parent, const vec2 *pos, const vec2 *vel )
{
   vec2 approach_vector, relative_location, orthoradial_vector;
   double speed, radial_speed, orthoradial_speed, dist, t;
 
   dist = vec2_dist( &parent->solid->pos, pos );
 
   /* Beam weapons */
   if (outfit_isBeam(o)) {
      if (dist > o->u.bem.range)
         return INFINITY;
      return 0.;
   }
 
   /* A bay doesn't have range issues */
   if (outfit_isFighterBay(o))
      return 0.;
 
   /* Missiles use absolute velocity while bolts and unguided rockets use relative vel */
   if (outfit_isLauncher(o) && o->u.lau.ai != AMMO_AI_UNGUIDED)
      vec2_cset( &approach_vector, - vel->x, - vel->y );
   else
      vec2_cset( &approach_vector, VX(parent->solid->vel) - vel->x,
            VY(parent->solid->vel) - vel->y );
 
   speed = outfit_speed(o);
 
   /* Get the vector : shooter -> target */
   vec2_cset( &relative_location, pos->x - VX(parent->solid->pos),
         pos->y - VY(parent->solid->pos) );
 
   /* Get the orthogonal vector */
   vec2_cset(&orthoradial_vector, VY(parent->solid->pos) - pos->y,
         pos->x -  VX(parent->solid->pos) );
 
   radial_speed = vec2_dot( &approach_vector, &relative_location );
   radial_speed = radial_speed / VMOD(relative_location);
 
   orthoradial_speed = vec2_dot(&approach_vector, &orthoradial_vector);
   orthoradial_speed = orthoradial_speed / VMOD(relative_location);
 
   if ( ((speed*speed - VMOD(approach_vector)*VMOD(approach_vector)) != 0) && (speed*speed - orthoradial_speed*orthoradial_speed) > 0)
      t = dist * (sqrt( speed*speed - orthoradial_speed*orthoradial_speed ) - radial_speed) /
            (speed*speed - VMOD(approach_vector)*VMOD(approach_vector));
   else
      return INFINITY;
 
   /* if t < 0, try the other solution */
   if (t < 0)
      t = - dist * (sqrt( speed*speed - orthoradial_speed*orthoradial_speed ) + radial_speed) /
            (speed*speed - VMOD(approach_vector)*VMOD(approach_vector));
 
   /* if t still < 0, no solution */
   if (t < 0)
      return INFINITY;
 
   return t;
}
 
static int pilot_shootWeaponSetOutfit( Pilot* p, PilotWeaponSet *ws, const Outfit *o, int level, double time, int aim )
{
   int ret;
   int is_launcher, is_bay;
   double rate_mod, energy_mod;
   int maxp, minh;
   double q, maxt;
 
   /* Store number of shots. */
   ret = 0;
 
   if (outfit_isBeam(o)) {
      for (int i=0; i<array_size(ws->slots); i++) {
         PilotOutfitSlot *pos = p->outfits[ ws->slots[i].slotid ];
         if (pos->outfit == o && (level == -1 || level == ws->slots[i].level)) {
            ret += pilot_shootWeapon( p, pos, 0, aim );
            pos->inrange = ws->inrange; /* State if the weapon has to be turn off when out of range. */
         }
      }
      return ret;
   }
 
   /* Stores if it is a launcher. */
   is_launcher = outfit_isLauncher(o);
 
   is_bay = outfit_isFighterBay(o);
 
   /* Calculate rate modifier. */
   pilot_getRateMod( &rate_mod, &energy_mod, p, o );
 
   /* Find optimal outfit, coolest that can fire. */
   minh  = -1;
   maxt  = 0.;
   maxp  = -1;
   q     = 0.;
   for (int i=0; i<array_size(ws->slots); i++) {
      PilotOutfitSlot *pos = p->outfits[ ws->slots[i].slotid ];
 
      /* Only matching outfits. */
      if (pos->outfit != o)
         continue;
 
      /* Only match levels. */
      if ((level != -1) && (ws->slots[i].level != level))
         continue;
 
      /* Launcher only counts with ammo. */
      if ((is_launcher || is_bay) && (pos->u.ammo.quantity <= 0))
         continue;
 
      /* Get coolest that can fire. */
      if (pos->timer <= 0.) {
         if (is_launcher) {
            if ((minh < 0) || (p->outfits[ ws->slots[minh].slotid ]->u.ammo.quantity < pos->u.ammo.quantity))
               minh = i;
         }
         else {
            if ((minh < 0) || (p->outfits[ ws->slots[minh].slotid ]->heat_T > pos->heat_T))
               minh = i;
         }
      }
 
      /* Save some stuff. */
      if ((maxp < 0) || (pos->timer > maxt)) {
         maxp = i;
         maxt = pos->timer;
      }
      q += 1.;
   }
 
   /* No weapon can fire. */
   if (minh < 0)
      return 0;
 
   /* Only fire if the last weapon to fire fired more than (q-1)/q ago. */
   if (maxt > rate_mod * outfit_delay(o) * ((q-1.) / q))
      return 0;
 
   /* Shoot the weapon. */
   ret += pilot_shootWeapon( p, p->outfits[ ws->slots[minh].slotid ], time, aim );
 
   return ret;
}
 
static int pilot_shootWeapon( Pilot *p, PilotOutfitSlot *w, double time, int aim )
{
   vec2 vp, vv;
   double rate_mod, energy_mod;
   double energy;
   int dockslot = -1;
 
   /* Make sure weapon has outfit. */
   if (w->outfit == NULL)
      return 0;
 
   /* Reset beam shut-off if needed. */
   if (outfit_isBeam(w->outfit) && w->outfit->u.bem.min_duration)
      w->stimer = INFINITY;
 
   /* check to see if weapon is ready */
   if (w->timer > 0.)
      return 0;
 
   /* Calculate rate modifier. */
   pilot_getRateMod( &rate_mod, &energy_mod, p, w->outfit );
 
   /* Get weapon mount position. */
   pilot_getMount( p, w, &vp );
 
   /* Modify velocity to take into account the rotation. */
   vec2_cset( &vv, p->solid->vel.x - vp.y*p->solid->dir_vel,
         p->solid->vel.y + vp.x*p->solid->dir_vel );
 
   /* Get absolute weapon mount position. */
   vp.x += p->solid->pos.x;
   vp.y += p->solid->pos.y;
 
   /*
    * regular bolt weapons
    */
   if (outfit_isBolt(w->outfit)) {
      /* enough energy? */
      if (outfit_energy(w->outfit)*energy_mod > p->energy)
         return 0;
 
      /* Lua test. */
      if ((w->outfit->lua_ontoggle != LUA_NOREF) &&
            !pilot_outfitLOntoggle( p, w, 1 ))
         return 0;
 
      energy      = outfit_energy(w->outfit)*energy_mod;
      p->energy  -= energy;
      pilot_heatAddSlot( p, w );
      if (!outfit_isProp( w->outfit, OUTFIT_PROP_SHOOT_DRY )) {
         for (int i=0; i<w->outfit->u.blt.shots; i++)
            weapon_add( w, w->heat_T, p->solid->dir,
                  &vp, &vv, p, p->target, time, aim );
      }
   }
 
   /*
    * Beam weapons.
    */
   else if (outfit_isBeam(w->outfit)) {
      /* Don't fire if the existing beam hasn't been destroyed yet. */
      if (w->u.beamid > 0)
         return 0;
 
      /* Check if enough energy to last a second. */
      if (outfit_energy(w->outfit)*energy_mod > p->energy)
         return 0;
 
      /* Lua test. */
      if ((w->outfit->lua_ontoggle != LUA_NOREF) &&
            !pilot_outfitLOntoggle( p, w, 1 ))
         return 0;
 
      w->state = PILOT_OUTFIT_ON;
      if (!outfit_isProp( w->outfit, OUTFIT_PROP_SHOOT_DRY )) {
         w->u.beamid = beam_start( w, p->solid->dir,
               &vp, &p->solid->vel, p, p->target, aim );
      }
 
      w->timer = w->outfit->u.bem.duration;
 
      return 1; /* Return early due to custom timer logic. */
   }
 
   /*
    * missile launchers
    *
    * must be a secondary weapon
    */
   else if (outfit_isLauncher(w->outfit)) {
 
      /* Shooter can't be the target - safety check for the player.p */
      if ((w->outfit->u.lau.ai != AMMO_AI_UNGUIDED) && (p->id==p->target))
         return 0;
 
      /* Must have ammo left. */
      if (w->u.ammo.quantity <= 0)
         return 0;
 
      /* enough energy? */
      if (outfit_energy(w->outfit)*energy_mod > p->energy)
         return 0;
 
      /* Lua test. */
      if ((w->outfit->lua_ontoggle != LUA_NOREF) &&
            !pilot_outfitLOntoggle( p, w, 1 ))
         return 0;
 
      energy      = outfit_energy(w->outfit)*energy_mod;
      p->energy  -= energy;
      pilot_heatAddSlot( p, w );
      if (!outfit_isProp( w->outfit, OUTFIT_PROP_SHOOT_DRY )) {
         for (int i=0; i<w->outfit->u.lau.shots; i++)
            weapon_add( w, w->heat_T, p->solid->dir,
                  &vp, &vv, p, p->target, time, aim );
      }
 
      pilot_rmAmmo( p, w, 1 );
 
      /* Make the AI aware a seeker has been shot */
      if (outfit_isSeeker(w->outfit))
         p->shoot_indicator = 1;
 
      /* If last ammo was shot, update the range */
      if (w->u.ammo.quantity <= 0) {
         for (int j=0; j<PILOT_WEAPON_SETS; j++)
            pilot_weapSetUpdateRange( p, &p->weapon_sets[j] );
      }
   }
 
   /*
    * Fighter bays.
    */
   else if (outfit_isFighterBay(w->outfit)) {
 
      /* Must have ammo left. */
      if (w->u.ammo.quantity <= 0)
         return 0;
 
      /* Lua test. */
      if ((w->outfit->lua_ontoggle != LUA_NOREF) &&
            !pilot_outfitLOntoggle( p, w, 1 ))
         return 0;
 
      /* Get index of outfit slot */
      for (int j=0; j<array_size(p->outfits); j++) {
         if (p->outfits[j] == w)
            dockslot = j;
      }
 
      /* Create the escort. */
      if (!outfit_isProp( w->outfit, OUTFIT_PROP_SHOOT_DRY ))
         escort_create( p, w->outfit->u.bay.ship,
               &vp, &p->solid->vel, p->solid->dir, ESCORT_TYPE_BAY, 1, dockslot );
 
      w->u.ammo.quantity -= 1; /* we just shot it */
      p->mass_outfit     -= w->outfit->u.bay.ship_mass;
      pilot_updateMass( p );
   }
   else
      WARN(_("Shooting unknown weapon type: %s"), w->outfit->name);
 
   /* Reset timer. */
   w->timer += rate_mod * outfit_delay( w->outfit );
 
   return 1;
}
 
void pilot_getRateMod( double *rate_mod, double* energy_mod,
      const Pilot* p, const Outfit *o )
{
   switch (o->type) {
      case OUTFIT_TYPE_BOLT:
      case OUTFIT_TYPE_BEAM:
         *rate_mod   = 1. / p->stats.fwd_firerate; /* Invert. */
         *energy_mod = p->stats.fwd_energy;
         break;
      case OUTFIT_TYPE_TURRET_BOLT:
      case OUTFIT_TYPE_TURRET_BEAM:
         *rate_mod   = 1. / p->stats.tur_firerate; /* Invert. */
         *energy_mod = p->stats.tur_energy;
         break;
 
      case OUTFIT_TYPE_LAUNCHER:
      case OUTFIT_TYPE_TURRET_LAUNCHER:
         *rate_mod   = 1. / p->stats.launch_rate;
         *energy_mod = 1.;
         break;
 
      case OUTFIT_TYPE_FIGHTER_BAY:
         *rate_mod   = 1. / p->stats.fbay_rate;
         *energy_mod = 1.;
         break;
 
      default:
         *rate_mod   = 1.;
         *energy_mod = 1.;
         break;
   }
}
 
void pilot_weaponClear( Pilot *p )
{
   for (int i=0; i<PILOT_WEAPON_SETS; i++) {
      PilotWeaponSet *ws = pilot_weapSet( p, i );
      array_erase( &ws->slots, array_begin(ws->slots), array_end(ws->slots) );
   }
}
 
void pilot_weaponAuto( Pilot *p )
{
   int level, id;
 
   /* Clear weapons. */
   pilot_weaponClear( p );
 
   /* Set modes. */
   pilot_weapSetType( p, 0, WEAPSET_TYPE_CHANGE );
   pilot_weapSetType( p, 1, WEAPSET_TYPE_CHANGE );
   pilot_weapSetType( p, 2, WEAPSET_TYPE_CHANGE );
   pilot_weapSetType( p, 3, WEAPSET_TYPE_CHANGE );
   pilot_weapSetType( p, 4, WEAPSET_TYPE_WEAPON );
   pilot_weapSetType( p, 5, WEAPSET_TYPE_WEAPON );
   pilot_weapSetType( p, 6, WEAPSET_TYPE_ACTIVE );
   pilot_weapSetType( p, 7, WEAPSET_TYPE_ACTIVE );
   pilot_weapSetType( p, 8, WEAPSET_TYPE_ACTIVE );
   pilot_weapSetType( p, 9, WEAPSET_TYPE_WEAPON );
 
   /* All should be inrange. */
   if (!pilot_isPlayer(p))
      for (int i=0; i<PILOT_WEAPON_SETS; i++) {
         pilot_weapSetInrange( p, i, 1 );
         /* Update range and speed (at 0)*/
         pilot_weapSetUpdateRange( p, &p->weapon_sets[i] );
      }
 
   /* Iterate through all the outfits. */
   for (int i=0; i<array_size(p->outfits); i++) {
      PilotOutfitSlot *slot = p->outfits[i];
      const Outfit *o       = slot->outfit;
 
      /* Must be non-empty, and a weapon or active outfit. */
      if ((o == NULL) || !outfit_isActive(o)) {
         slot->level   = -1; /* Clear level. */
         slot->weapset = -1;
         continue;
      }
 
      /* Set level based on secondary flag. */
      level  = outfit_isSecondary(o);
 
      /* Manually defined group preempts others. */
      if (o->group) {
         id    = o->group;
      }
      /* Bolts and beams. */
      else if (outfit_isBolt(o) || outfit_isBeam(o) ||
            (outfit_isLauncher(o) && !outfit_isSeeker(o))) {
         id    = outfit_isTurret(o) ? 2 : 1;
      }
      /* Seekers. */
      else if (outfit_isLauncher(o) && outfit_isSeeker(o)) {
         id    = 4;
      }
      /* Fighter bays. */
      else if (outfit_isFighterBay(o)) {
         id    = 5;
      }
      /* Ignore rest. */
      else {
         slot->level = -1;
         continue;
      }
 
      /* Add to its base group. */
      pilot_weapSetAdd( p, id, slot, level );
 
      /* Also add another copy to another group. */
      if (id == 1) { /* Forward. */
         pilot_weapSetAdd( p, 0, slot, level ); /* Also get added to 'All'. */
         pilot_weapSetAdd( p, 3, slot, 0 );     /* Also get added to 'Fwd/Tur'. */
      }
      else if (id == 2) { /* Turrets. */
         pilot_weapSetAdd( p, 0, slot, level ); /* Also get added to 'All'. */
         pilot_weapSetAdd( p, 3, slot, 1 );     /* Also get added to 'Fwd/Tur'. */
      }
      else if (id == 4) { /* Seekers */
         pilot_weapSetAdd( p, 0, slot, level ); /* Also get added to 'All'. */
         if (outfit_isTurret(o))
            pilot_weapSetAdd( p, 9, slot, level ); /* Also get added to 'Turreted Seekers'. */
      }
   }
 
   /* Update active weapon set. */
   pilot_weapSetUpdateOutfits( p, &p->weapon_sets[ p->active_set ] );
}
 
void pilot_weaponSetDefault( Pilot *p )
{
   int i;
 
   /* If current set isn't a fire group no need to worry. */
   if (p->weapon_sets[ p->active_set ].type == WEAPSET_TYPE_CHANGE) {
      /* Update active weapon set. */
      pilot_weapSetUpdateOutfits( p, &p->weapon_sets[ p->active_set ] );
      return;
   }
 
   /* Find first fire group. */
   for (i=0; i<PILOT_WEAPON_SETS; i++)
      if (p->weapon_sets[i].type == WEAPSET_TYPE_CHANGE)
         break;
 
   /* Set active set to first if all fire groups or first non-fire group. */
   if (i >= PILOT_WEAPON_SETS)
      p->active_set = 0;
   else
      p->active_set = i;
 
   /* Update active weapon set. */
   pilot_weapSetUpdateOutfits( p, &p->weapon_sets[ p->active_set ] );
}
 
void pilot_weaponSafe( Pilot *p )
{
   for (int j=0; j<PILOT_WEAPON_SETS; j++) {
      PilotWeaponSet *ws = &p->weapon_sets[j];
      int l = array_size(ws->slots);
      int n = 0;
      for (int i=0; i<l; i++) {
         PilotOutfitSlot *pos = p->outfits[ ws->slots[i].slotid ];
         if (pos->outfit != NULL)
            continue;
 
         /* Move down. */
         memmove( &ws->slots[i], &ws->slots[i+1], sizeof(PilotWeaponSetOutfit) * (l-i-1) );
         n++;
      }
      /* Remove surplus. */
      if (n > 0)
         array_erase( &ws->slots, &ws->slots[l-n], &ws->slots[l] );
 
      /* See if we must overwrite levels. */
      if ((ws->type == WEAPSET_TYPE_WEAPON) ||
            (ws->type == WEAPSET_TYPE_ACTIVE))
         for (int i=0; i<array_size(ws->slots); i++)
            ws->slots[i].level = 0;
 
      /* Update range. */
      pilot_weapSetUpdateRange( p, ws );
   }
}
 
int pilot_outfitOff( Pilot *p, PilotOutfitSlot *o )
{
   /* Must be equipped, not disabled, not cooling down. */
   if (o->outfit == NULL || (pilot_isDisabled(p)) || (pilot_isFlag(p, PILOT_COOLDOWN)))
      return 0;
 
   if (outfit_isAfterburner( o->outfit )) { /* Afterburners */
      if ((o->outfit->lua_ontoggle != LUA_NOREF) &&
            !pilot_outfitLOntoggle( p, o, 0 ))
         return 0;
      pilot_afterburnOver( p );
   }
   else if (outfit_isBeam( o->outfit )) {
      if ((o->outfit->lua_ontoggle != LUA_NOREF) &&
            !pilot_outfitLOntoggle( p, o, 0 ))
         return 0;
      /* Beams use stimer to represent minimum time until shutdown. */
      if (o->u.beamid>0) {
         beam_end( p->id, o->u.beamid );
         pilot_stopBeam(p, o);
      }
   }
   else if (!o->active)
      /* Case of a mod we can't toggle. */
      return 0;
   else if (o->outfit->lua_ontoggle != LUA_NOREF)
      /* TODO toggle Lua outfit. */
      return pilot_outfitLOntoggle( p, o, 0 );
   else {
      o->stimer = outfit_cooldown( o->outfit );
      o->state  = PILOT_OUTFIT_COOLDOWN;
   }
 
   return 1;
}
 
int pilot_outfitOn( Pilot *p, PilotOutfitSlot *o )
{
   if (o->outfit == NULL)
      return 0;
   if (outfit_isAfterburner(o->outfit))
      pilot_afterburn( p );
   else if (o->outfit->lua_ontoggle != LUA_NOREF)
      /* TODO toggle Lua outfit. */
      return pilot_outfitLOntoggle( p, o, 1 );
   else {
      o->state  = PILOT_OUTFIT_ON;
      o->stimer = outfit_duration( o->outfit ) * p->stats.cooldown_mod;
   }
 
   return 1;
}
 
int pilot_outfitOffAll( Pilot *p )
{
   int nchg;
 
   nchg = 0;
   for (int i=0; i<array_size(p->outfits); i++) {
      PilotOutfitSlot *o = p->outfits[i];
      /* Picky about our outfits. */
      if (o->outfit == NULL)
         continue;
      if (o->state == PILOT_OUTFIT_ON)
         nchg += pilot_outfitOff( p, o );
   }
   return (nchg > 0);
}
 
void pilot_afterburn( Pilot *p )
{
   double afb_mod;
 
   if (p == NULL)
      return;
 
   if (pilot_isFlag(p, PILOT_HYP_PREP) || pilot_isFlag(p, PILOT_HYPERSPACE) ||
         pilot_isFlag(p, PILOT_LANDING) || pilot_isFlag(p, PILOT_TAKEOFF) ||
         pilot_isDisabled(p) || pilot_isFlag(p, PILOT_COOLDOWN))
      return;
 
   /* Not under manual control if is player. */
   if (pilot_isFlag( p, PILOT_MANUAL_CONTROL ) && pilot_isFlag( p, PILOT_PLAYER ))
      return;
 
   if (p->afterburner == NULL)
      return;
 
   /* The afterburner only works if its efficiency is high enough. */
   if (pilot_heatEfficiencyMod( p->afterburner->heat_T,
         p->afterburner->outfit->u.afb.heat_base,
         p->afterburner->outfit->u.afb.heat_cap ) < 0.3)
      return;
 
   if (p->afterburner->state == PILOT_OUTFIT_OFF) {
      p->afterburner->state  = PILOT_OUTFIT_ON;
      p->afterburner->stimer = outfit_duration( p->afterburner->outfit );
      pilot_setFlag(p,PILOT_AFTERBURNER);
      pilot_calcStats( p );
      pilot_destealth( p ); /* No afterburning stealth. */
 
      /* @todo Make this part of a more dynamic activated outfit sound system. */
      sound_playPos(p->afterburner->outfit->u.afb.sound_on,
            p->solid->pos.x, p->solid->pos.y, p->solid->vel.x, p->solid->vel.y);
   }
 
   if (pilot_isPlayer(p)) {
      afb_mod = MIN( 1., player.p->afterburner->outfit->u.afb.mass_limit / player.p->solid->mass );
      spfx_shake( afb_mod * player.p->afterburner->outfit->u.afb.rumble );
   }
}
 
void pilot_afterburnOver( Pilot *p )
{
   if (p == NULL)
      return;
   if (p->afterburner == NULL)
      return;
 
   if (p->afterburner->state == PILOT_OUTFIT_ON) {
      p->afterburner->state  = PILOT_OUTFIT_OFF;
      pilot_rmFlag(p,PILOT_AFTERBURNER);
      pilot_calcStats( p );
 
      /* @todo Make this part of a more dynamic activated outfit sound system. */
      sound_playPos(p->afterburner->outfit->u.afb.sound_off,
            p->solid->pos.x, p->solid->pos.y, p->solid->vel.x, p->solid->vel.y);
   }
}
 
void ws_copy( PilotWeaponSet dest[PILOT_WEAPON_SETS], const PilotWeaponSet src[PILOT_WEAPON_SETS] )
{
   ws_free( dest );
   memcpy( dest, src, sizeof(PilotWeaponSet)*PILOT_WEAPON_SETS );
   for (int i=0; i<PILOT_WEAPON_SETS; i++)
      dest[i].slots = array_copy( PilotWeaponSetOutfit, src[i].slots );
}
 
void ws_free( PilotWeaponSet ws[PILOT_WEAPON_SETS] )
{
   for (int i=0; i<PILOT_WEAPON_SETS; i++) {
      array_free( ws[i].slots );
      ws[i].slots = NULL;
   }
}