pilot_ew.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <math.h>
 
#include "naev.h"
#include "array.h"
#include "hook.h"
#include "log.h"
#include "pilot.h"
#include "player.h"
#include "player_autonav.h"
#include "space.h"
 
#define EW_ASTEROID_DIST      7.5e3
#define EW_JUMPDETECT_DIST    7.5e3
#define EW_SPOBDETECT_DIST  20e3 /* TODO something better than this. */
 
static double ew_interference = 1.; 
/*
 * Prototypes.
 */
static void pilot_ewUpdate( Pilot *p );
static double pilot_ewMass( double mass );
static double pilot_ewAsteroid( const Pilot *p );
static double pilot_ewJumpPoint( const Pilot *p );
static int pilot_ewStealthGetNearby( const Pilot *p, double *mod, int *close, int *isplayer );
 
double pilot_ewScanTime( const Pilot *p )
{
   /* Here larger is "better", so we multiply by ew_hide instead of dividing. */
   return pow( p->solid->mass, 1./3. ) * 1.25 * p->stats.ew_hide * p->stats.ew_scanned_time;
}
 
void pilot_ewScanStart( Pilot *p )
{
   Pilot *target = pilot_getTarget( p );
   if (target==NULL)
      return;
 
   /* Player did bad stuff and is getting scanned. */
   if (pilot_isPlayer(target) && pilot_hasIllegal(target,p->faction))
      player_autonavResetSpeed();
 
   /* Scan time. */
   p->scantimer = pilot_ewScanTime(p);
}
 
int pilot_ewScanCheck( const Pilot *p )
{
   if (p->target == p->id)
      return 0;
   return (p->scantimer < 0.);
}
 
static void pilot_ewUpdate( Pilot *p )
{
   p->ew_detection = p->ew_mass * p->ew_asteroid / p->stats.ew_hide;
   p->ew_evasion   = p->ew_detection * 0.75 * ew_interference / p->stats.ew_evade;
   /* For stealth we apply the ew_asteroid and ew_interference bonus outside of the max, so that it can go below 1000 with in-system features. */
   p->ew_stealth   = MAX( 1000., p->ew_mass / p->stats.ew_hide * 0.25 / p->stats.ew_stealth ) * p->ew_asteroid * ew_interference * p->ew_jumppoint;
}
 
void pilot_ewUpdateStatic( Pilot *p )
{
   p->ew_mass = pilot_ewMass( p->solid->mass );
   pilot_ewUpdate( p );
}
 
void pilot_ewUpdateDynamic( Pilot *p, double dt )
{
   Pilot *t;
 
   /* Electronic warfare values. */
   p->ew_asteroid = pilot_ewAsteroid( p );
   p->ew_jumppoint = pilot_ewJumpPoint( p );
   pilot_ewUpdate( p );
 
   /* Already scanned so skipping. */
   if (p->scantimer < 0.)
      return;
 
   /* Get the target pilot. */
   t = pilot_getTarget( p );
   if (t == NULL)
      return;
 
   /* Must be in evasion range. */
   if (vec2_dist2( &p->solid->pos, &t->solid->pos ) < pow2( MAX( 0., p->stats.ew_detect * p->stats.ew_track * t->ew_evasion ) )) {
      p->scantimer -= dt;
 
      if (p->scantimer < 0.) {
         HookParam hparam = { .type = HOOK_PARAM_PILOT };
         /* Run scan hook. */
         hparam.u.lp = t->id;
         pilot_runHookParam( p, PILOT_HOOK_SCAN, &hparam, 1 );
         /* Run scanned hook. */
         hparam.u.lp = p->id;
         pilot_runHookParam( t, PILOT_HOOK_SCANNED, &hparam, 1 );
 
         /* Run outfit stuff. */
         pilot_outfitLOnscan( p );
         pilot_outfitLOnscanned( t, p );
 
         /* TODO handle case the player finished scanning by setting a flag or something. */
      }
   }
}
 
static double pilot_ewMass( double mass )
{
   return pow(mass, 1./1.8) * 350.;
}
 
static double pilot_ewAsteroid( const Pilot *p )
{
   int infield = asteroids_inField(&p->solid->pos);
   if (infield < 0)
      return 1.;
   return 1. / (1. + 0.4*cur_system->asteroids[infield].density);
}
 
static double pilot_ewJumpPoint( const Pilot *p )
{
   /* Don't have to really check when not in stealth. */
   if (!pilot_isFlag(p,PILOT_STEALTH))
      return 1.;
 
   /* Gets lower when near jump. */
   for (int i=0; i<array_size(cur_system->jumps); i++) {
      JumpPoint *jp = &cur_system->jumps[i];
      if (jp_isFlag(jp,JP_EXITONLY) || jp_isFlag(jp,JP_HIDDEN))
         continue;
      double d2 = vec2_dist2( &jp->pos, &p->solid->pos );
      if (d2 <= pow2(EW_JUMP_BONUS_RANGE))
         return MAX( 0.5, sqrt(d2) / EW_JUMP_BONUS_RANGE);
   }
   return 1.;
}
 
void pilot_updateSensorRange (void)
{
   ew_interference = 1. + cur_system->interference/100.;
}
 
double pilot_sensorRange( void )
{
   return 7500. / ew_interference;
}
 
int pilot_inRange( const Pilot *p, double x, double y )
{
   double d = pow2(x-p->solid->pos.x) + pow2(y-p->solid->pos.y);
   double sense = MAX( 0., pilot_sensorRange() * p->stats.ew_detect );
   if (d < pow2(sense))
      return 1;
   return 0;
}
 
int pilot_inRangePilot( const Pilot *p, const Pilot *target, double *dist2 )
{
   double d;
 
   /* Get distance if needed. */
   if (dist2 != NULL)
      *dist2 = vec2_dist2( &p->solid->pos, &target->solid->pos );
 
   /* Special case player or omni-visible. */
   if ((pilot_isPlayer(p) && pilot_isFlag(target, PILOT_VISPLAYER)) ||
         pilot_isFlag(target, PILOT_VISIBLE) ||
         target->parent == p->id)
      return 1;
 
   /* Stealth detection. */
   if (pilot_isFlag( target, PILOT_STEALTH ))
      return 0;
 
   /* No stealth so normal detection. */
   d = (dist2!=NULL ? *dist2 : vec2_dist2( &p->solid->pos, &target->solid->pos ) );
   if (d < pow2( MAX( 0., p->stats.ew_detect * p->stats.ew_track * target->ew_evasion )))
      return 1;
   else if  (d < pow2( MAX( 0., p->stats.ew_detect * target->ew_detection )))
      return -1;
 
   return 0;
}
 
int pilot_inRangeSpob( const Pilot *p, int target )
{
   double d;
   Spob *pnt;
   double sense;
 
   /* pilot must exist */
   if (p == NULL)
      return 0;
 
   /* Get the spob. */
   pnt = cur_system->spobs[target];
   sense = EW_SPOBDETECT_DIST;
 
   /* Get distance. */
   d = vec2_dist2( &p->solid->pos, &pnt->pos );
   if (d < pow2( MAX( 0., sense * p->stats.ew_detect * pnt->hide) ) )
      return 1;
 
   return 0;
}
 
int pilot_inRangeAsteroid( const Pilot *p, int ast, int fie )
{
   double d;
   Asteroid *as;
   AsteroidAnchor *f;
   double sense;
 
   /* pilot must exist */
   if (p == NULL)
      return 0;
 
   /* Get the asteroid. */
   f = &cur_system->asteroids[fie];
   as = &f->asteroids[ast];
 
   /* TODO something better than this. */
   sense = EW_ASTEROID_DIST;
 
   /* Get distance. */
   d = vec2_dist2( &p->solid->pos, &as->pos );
 
   /* By default, asteroid's hide score is 1. It could be made changeable via xml.*/
   if (d < pow2( MAX( 0., sense * p->stats.ew_detect ) ) )
      return 1;
 
   return 0;
}
 
int pilot_inRangeJump( const Pilot *p, int i )
{
   double d;
   JumpPoint *jp;
   double sense;
   double hide;
 
   /* pilot must exist */
   if (p == NULL)
      return 0;
 
   /* Get the jump point. */
   jp = &cur_system->jumps[i];
 
   /* We don't want exit-only jumps. */
   if (jp_isFlag(jp, JP_EXITONLY))
      return 0;
 
   /* Jumps with 0. hide are considered to be highway points and always visible. */
   hide = jp->hide;
   if (hide==0.)
      return 1;
 
   sense = EW_JUMPDETECT_DIST * p->stats.ew_jump_detect * p->stats.ew_detect;
   /* Handle hidden jumps separately, as they use a special range parameter. */
   if (jp_isFlag(jp, JP_HIDDEN))
      sense *= p->stats.misc_hidden_jump_detect;
 
   /* Get distance. */
   d = vec2_dist2( &p->solid->pos, &jp->pos );
   if (d < pow2( MAX( 0., sense * hide )))
      return 1;
 
   return 0;
}
 
double pilot_ewWeaponTrack( const Pilot *p, const Pilot *t, double trackmin, double trackmax )
{
   double mod = p->stats.ew_track * p->stats.ew_detect;
   return CLAMP( 0., 1., (t->ew_evasion * mod - trackmin) / (trackmax - trackmin) );
}
 
static int pilot_ewStealthGetNearby( const Pilot *p, double *mod, int *close, int *isplayer )
{
   Pilot *const* ps;
   int n;
 
   /* Check nearby non-allies. */
   if (mod != NULL)
      *mod = 0.;
   if (close != NULL)
      *close = 0;
   if (isplayer != NULL)
      *isplayer = 0;
   n = 0;
   ps = pilot_getAll();
   for (int i=0; i<array_size(ps); i++) {
      double dist;
      Pilot *t = ps[i];
 
      /* Quick checks first. */
      if (pilot_isDisabled(t))
         continue;
      if (!pilot_canTarget(t))
         continue;
 
      /* Must not be landing nor taking off. */
      if (pilot_isFlag(t, PILOT_LANDING) ||
            pilot_isFlag(t, PILOT_TAKEOFF))
         continue;
 
      /* Allies are ignored. */
      if (areAllies( p->faction, t->faction ) ||
            ((p->faction == FACTION_PLAYER) && pilot_isFriendly(t)) ||
            ((t->faction == FACTION_PLAYER) && pilot_isFriendly(p)))
         continue;
 
      /* Stealthed pilots don't reduce stealth. */
      //if (pilot_isFlag(t, PILOT_STEALTH))
      //   continue;
 
      /* Compute distance. */
      dist = vec2_dist2( &p->solid->pos, &t->solid->pos );
      /* TODO maybe not hardcode the close value. */
      if ((close != NULL) && !pilot_isFlag(t,PILOT_STEALTH) &&
            (dist < pow2( MAX( 0., p->ew_stealth * t->stats.ew_detect * 1.5 ))))
         (*close)++;
      if (dist > pow2( MAX( 0., p->ew_stealth * t->stats.ew_detect )))
         continue;
 
      if (mod != NULL)
         *mod += 1.0 - sqrt(dist) / (p->ew_stealth * t->stats.ew_detect);
 
      /* We found a pilot that is in range. */
      n++;
      if ((isplayer != NULL) && pilot_isPlayer(t))
         *isplayer = 1;
   }
 
   return n;
}
 
void pilot_ewUpdateStealth( Pilot *p, double dt )
{
   int n, close, isplayer;
   double mod;
 
   if (!pilot_isFlag( p, PILOT_STEALTH ))
      return;
 
   /* Get nearby pilots. */
   if (pilot_isPlayer(p)) {
      if (pilot_isFlag(p, PILOT_NONTARGETABLE))
         return;
 
      n = pilot_ewStealthGetNearby( p, &mod, &close, &isplayer );
 
      /* Stop autonav if pilots are nearby. */
      if (close>0)
         player_autonavResetSpeed();
   }
   else
      n = pilot_ewStealthGetNearby( p, &mod, NULL, &isplayer );
 
   /* Increases if nobody nearby. */
   if (n == 0) {
      p->ew_stealth_timer += dt * 5e3 / p->ew_stealth;
      if (p->ew_stealth_timer > 1.)
         p->ew_stealth_timer = 1.;
   }
   /* Otherwise decreases. */
   else {
      p->ew_stealth_timer -= dt * (p->ew_stealth / 10e3 + mod) * p->stats.ew_stealth_timer;
      if (p->ew_stealth_timer < 0.) {
         pilot_destealth( p );
         if (pilot_isPlayer(p))
            player_message( "#r%s", _("You have been uncovered!"));
         else if (isplayer)
            player_message(_("You have uncovered '#%c%s#0'!"), pilot_getFactionColourChar(p), p->name);
         ai_discovered( p );
      }
   }
}
 
int pilot_stealth( Pilot *p )
{
   int n;
 
   if (pilot_isFlag( p, PILOT_STEALTH ))
      return 1;
 
   /* Can't stealth if locked on. */
   if (p->lockons > 0)
      return 0;
 
   /* Can't stealth if pilots nearby. */
   pilot_setFlag( p, PILOT_STEALTH );
   n = pilot_ewStealthGetNearby( p, NULL, NULL, NULL );
   if (n > 0) {
      pilot_rmFlag( p, PILOT_STEALTH );
      return 0;
   }
 
   /* Turn off outfits. */
   pilot_outfitOffAll( p );
 
   /* Got into stealth. */
   if (!pilot_outfitLOnstealth( p ))
      pilot_calcStats(p);
   p->ew_stealth_timer = 0.;
 
   /* Run hook. */
   const HookParam hparam = { .type = HOOK_PARAM_BOOL, .u.b = 1 };
   pilot_runHookParam( p, PILOT_HOOK_STEALTH, &hparam, 1 );
   return 1;
}
 
void pilot_destealth( Pilot *p )
{
   if (!pilot_isFlag( p, PILOT_STEALTH ))
      return;
   pilot_rmFlag( p, PILOT_STEALTH );
   p->ew_stealth_timer = 0.;
   if (!pilot_outfitLOnstealth( p ))
      pilot_calcStats(p);
 
   /* Run hook. */
   const HookParam hparam = { .type = HOOK_PARAM_BOOL, .u.b = 0 };
   pilot_runHookParam( p, PILOT_HOOK_STEALTH, &hparam, 1 );
}