ai.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <ctype.h>
#include <lauxlib.h>
#include <lualib.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include "physfs.h"
 
#include "naev.h"
#include "ai.h"
 
#include "conf.h"
#include "array.h"
#include "board.h"
#include "escort.h"
#include "faction.h"
#include "hook.h"
#include "gatherable.h"
#include "log.h"
#include "ndata.h"
#include "nlua.h"
#include "nlua_asteroid.h"
#include "nlua_faction.h"
#include "nlua_pilot.h"
#include "nlua_spob.h"
#include "nlua_rnd.h"
#include "nlua_vec2.h"
#include "nluadef.h"
#include "nstring.h"
#include "physics.h"
#include "pilot.h"
#include "player.h"
#include "rng.h"
#include "space.h"
 
/*
 * ai flags
 *
 * They can be used for stuff like movement or for pieces of code which might
 *  run AI stuff when the AI module is not reentrant.
 */
#define ai_setFlag(f)   (pilot_flags |= f ) 
#define ai_isFlag(f)    (pilot_flags & f ) 
/* flags */
#define AI_PRIMARY      (1<<0)   
#define AI_SECONDARY    (1<<1)   
#define AI_DISTRESS     (1<<2)   
/*
 * all the AI profiles
 */
static AI_Profile* profiles = NULL; 
static nlua_env equip_env = LUA_NOREF; 
/*
 * prototypes
 */
/* Internal C routines */
static void ai_run( nlua_env env, int nargs );
static int ai_loadProfile( AI_Profile *prof, const char* filename );
static void ai_setMemory (void);
static void ai_create( Pilot* pilot );
static int ai_loadEquip (void);
static int ai_sort( const void *p1, const void *p2 );
/* Task management. */
static void ai_taskGC( Pilot* pilot );
static Task* ai_createTask( lua_State *L, int subtask );
static int ai_tasktarget( lua_State *L, Task *t );
 
/*
 * AI routines for Lua
 */
/* tasks */
static int aiL_pushtask( lua_State *L ); /* pushtask( string, number/pointer ) */
static int aiL_poptask( lua_State *L ); /* poptask() */
static int aiL_taskname( lua_State *L ); /* string taskname() */
static int aiL_taskdata( lua_State *L ); /* pointer subtaskdata() */
static int aiL_pushsubtask( lua_State *L ); /* pushsubtask( string, number/pointer, number ) */
static int aiL_popsubtask( lua_State *L ); /* popsubtask() */
static int aiL_subtaskname( lua_State *L ); /* string subtaskname() */
static int aiL_subtaskdata( lua_State *L ); /* pointer subtaskdata() */
 
/* consult values */
static int aiL_pilot( lua_State *L ); /* number pilot() */
static int aiL_getrndpilot( lua_State *L ); /* number getrndpilot() */
static int aiL_getnearestpilot( lua_State *L ); /* number getnearestpilot() */
static int aiL_getdistance( lua_State *L ); /* number getdist(vec2) */
static int aiL_getdistance2( lua_State *L ); /* number getdist(vec2) */
static int aiL_getflybydistance( lua_State *L ); /* number getflybydist(vec2) */
static int aiL_minbrakedist( lua_State *L ); /* number minbrakedist( [number] ) */
static int aiL_isbribed( lua_State *L ); /* bool isbribed( number ) */
static int aiL_getGatherable( lua_State *L ); /* integer getgatherable( radius ) */
static int aiL_instantJump( lua_State *L ); /* bool instantJump() */
 
/* boolean expressions */
static int aiL_ismaxvel( lua_State *L ); /* boolean ismaxvel() */
static int aiL_isstopped( lua_State *L ); /* boolean isstopped() */
static int aiL_isenemy( lua_State *L ); /* boolean isenemy( number ) */
static int aiL_isally( lua_State *L ); /* boolean isally( number ) */
static int aiL_haslockon( lua_State *L ); /* boolean haslockon() */
static int aiL_hasprojectile( lua_State *L ); /* boolean hasprojectile() */
static int aiL_scandone( lua_State *L );
 
/* movement */
static int aiL_accel( lua_State *L ); /* accel(number); number <= 1. */
static int aiL_turn( lua_State *L ); /* turn(number); abs(number) <= 1. */
static int aiL_face( lua_State *L ); /* face( number/pointer, bool) */
static int aiL_careful_face( lua_State *L ); /* face( number/pointer, bool) */
static int aiL_aim( lua_State *L ); /* aim(number) */
static int aiL_iface( lua_State *L ); /* iface(number/pointer) */
static int aiL_dir( lua_State *L ); /* dir(number/pointer) */
static int aiL_idir( lua_State *L ); /* idir(number/pointer) */
static int aiL_drift_facing( lua_State *L ); /* drift_facing(number/pointer) */
static int aiL_brake( lua_State *L ); /* brake() */
static int aiL_getnearestspob( lua_State *L ); /* Vec2 getnearestspob() */
static int aiL_getspobfrompos( lua_State *L ); /* Vec2 getspobfrompos() */
static int aiL_getrndspob( lua_State *L ); /* Vec2 getrndspob() */
static int aiL_getlandspob( lua_State *L ); /* Vec2 getlandspob() */
static int aiL_land( lua_State *L ); /* bool land() */
static int aiL_stop( lua_State *L ); /* stop() */
static int aiL_relvel( lua_State *L ); /* relvel( number ) */
static int aiL_follow_accurate( lua_State *L ); /* follow_accurate() */
static int aiL_face_accurate( lua_State *L ); /* face_accurate() */
 
/* Hyperspace. */
static int aiL_sethyptarget( lua_State *L );
static int aiL_nearhyptarget( lua_State *L ); /* pointer rndhyptarget() */
static int aiL_rndhyptarget( lua_State *L ); /* pointer rndhyptarget() */
static int aiL_hyperspace( lua_State *L ); /* [number] hyperspace() */
 
/* escorts */
static int aiL_dock( lua_State *L ); /* dock( number ) */
 
/* combat */
static int aiL_combat( lua_State *L ); /* combat( number ) */
static int aiL_settarget( lua_State *L ); /* settarget( number ) */
static int aiL_weapSet( lua_State *L ); /* weapset( number ) */
static int aiL_shoot( lua_State *L ); /* shoot( number ); number = 1,2,3 */
static int aiL_hascannons( lua_State *L ); /* bool hascannons() */
static int aiL_hasturrets( lua_State *L ); /* bool hasturrets() */
static int aiL_hasfighterbays( lua_State *L ); /* bool hasfighterbays() */
static int aiL_hasafterburner( lua_State *L ); /* bool hasafterburner() */
static int aiL_getenemy( lua_State *L ); /* number getenemy() */
static int aiL_getenemy_size( lua_State *L ); /* number getenemy_size() */
static int aiL_getenemy_heuristic( lua_State *L ); /* number getenemy_heuristic() */
static int aiL_hostile( lua_State *L ); /* hostile( number ) */
static int aiL_getweaprange( lua_State *L ); /* number getweaprange() */
static int aiL_getweapspeed( lua_State *L ); /* number getweapspeed() */
static int aiL_getweapammo( lua_State *L );
static int aiL_canboard( lua_State *L ); /* boolean canboard( number ) */
static int aiL_relsize( lua_State *L ); /* boolean relsize( number ) */
static int aiL_reldps( lua_State *L ); /* boolean reldps( number ) */
static int aiL_relhp( lua_State *L ); /* boolean relhp( number ) */
 
/* timers */
static int aiL_settimer( lua_State *L ); /* settimer( number, number ) */
static int aiL_timeup( lua_State *L ); /* boolean timeup( number ) */
 
/* messages */
static int aiL_distress( lua_State *L ); /* distress( string [, bool] ) */
static int aiL_getBoss( lua_State *L ); /* number getBoss() */
 
/* loot */
static int aiL_credits( lua_State *L ); /* credits( number ) */
 
/* misc */
static int aiL_board( lua_State *L ); /* boolean board() */
static int aiL_refuel( lua_State *L ); /* boolean, boolean refuel() */
static int aiL_messages( lua_State *L );
static int aiL_setasterotarget( lua_State *L ); /* setasterotarget( Asteroid ) */
static int aiL_gatherablePos( lua_State *L ); /* gatherablepos( number ) */
static int aiL_shoot_indicator( lua_State *L ); /* get shoot indicator */
static int aiL_set_shoot_indicator( lua_State *L ); /* set shoot indicator */
static int aiL_stealth( lua_State *L );
 
static const luaL_Reg aiL_methods[] = {
   /* tasks */
   { "pushtask", aiL_pushtask },
   { "poptask", aiL_poptask },
   { "taskname", aiL_taskname },
   { "taskdata", aiL_taskdata },
   { "pushsubtask", aiL_pushsubtask },
   { "popsubtask", aiL_popsubtask },
   { "subtaskname", aiL_subtaskname },
   { "subtaskdata", aiL_subtaskdata },
   /* is */
   { "ismaxvel", aiL_ismaxvel },
   { "isstopped", aiL_isstopped },
   { "isenemy", aiL_isenemy },
   { "isally", aiL_isally },
   { "haslockon", aiL_haslockon },
   { "hasprojectile", aiL_hasprojectile },
   { "scandone", aiL_scandone },
   /* get */
   { "pilot", aiL_pilot },
   { "rndpilot", aiL_getrndpilot },
   { "nearestpilot", aiL_getnearestpilot },
   { "dist", aiL_getdistance },
   { "dist2", aiL_getdistance2 },
   { "flyby_dist", aiL_getflybydistance },
   { "minbrakedist", aiL_minbrakedist },
   { "isbribed", aiL_isbribed },
   { "getgatherable", aiL_getGatherable },
   { "instantJump", aiL_instantJump },
   /* movement */
   { "nearestspob", aiL_getnearestspob },
   { "spobfrompos", aiL_getspobfrompos },
   { "rndspob", aiL_getrndspob },
   { "landspob", aiL_getlandspob },
   { "land", aiL_land },
   { "accel", aiL_accel },
   { "turn", aiL_turn },
   { "face", aiL_face },
   { "careful_face", aiL_careful_face },
   { "iface", aiL_iface },
   { "dir", aiL_dir },
   { "idir", aiL_idir },
   { "drift_facing", aiL_drift_facing },
   { "brake", aiL_brake },
   { "stop", aiL_stop },
   { "relvel", aiL_relvel },
   { "follow_accurate", aiL_follow_accurate },
   { "face_accurate", aiL_face_accurate },
   /* Hyperspace. */
   { "sethyptarget", aiL_sethyptarget },
   { "nearhyptarget", aiL_nearhyptarget },
   { "rndhyptarget", aiL_rndhyptarget },
   { "hyperspace", aiL_hyperspace },
   { "dock", aiL_dock },
   /* combat */
   { "aim", aiL_aim },
   { "combat", aiL_combat },
   { "settarget", aiL_settarget },
   { "weapset", aiL_weapSet },
   { "hascannons", aiL_hascannons },
   { "hasturrets", aiL_hasturrets },
   { "hasfighterbays", aiL_hasfighterbays },
   { "hasafterburner", aiL_hasafterburner },
   { "shoot", aiL_shoot },
   { "getenemy", aiL_getenemy },
   { "getenemy_size", aiL_getenemy_size },
   { "getenemy_heuristic", aiL_getenemy_heuristic },
   { "hostile", aiL_hostile },
   { "getweaprange", aiL_getweaprange },
   { "getweapspeed", aiL_getweapspeed },
   { "getweapammo", aiL_getweapammo },
   { "canboard", aiL_canboard },
   { "relsize", aiL_relsize },
   { "reldps", aiL_reldps },
   { "relhp", aiL_relhp },
   /* timers */
   { "settimer", aiL_settimer },
   { "timeup", aiL_timeup },
   /* messages */
   { "distress", aiL_distress },
   { "getBoss", aiL_getBoss },
   /* loot */
   { "setcredits", aiL_credits },
   /* misc */
   { "board", aiL_board },
   { "refuel", aiL_refuel },
   { "messages", aiL_messages },
   { "setasterotarget", aiL_setasterotarget },
   { "gatherablepos", aiL_gatherablePos },
   { "shoot_indicator", aiL_shoot_indicator },
   { "set_shoot_indicator", aiL_set_shoot_indicator },
   { "stealth", aiL_stealth },
   {0,0} /* end */
}; 
/*
 * current pilot "thinking" and assorted variables
 */
Pilot *cur_pilot           = NULL; 
static double pilot_acc    = 0.; 
static double pilot_turn   = 0.; 
static int pilot_flags     = 0; 
static char aiL_distressmsg[STRMAX_SHORT]; 
/*
 * ai status, used so that create functions can't be used elsewhere
 */
#define AI_STATUS_NORMAL      1 
#define AI_STATUS_CREATE      2 
static int aiL_status = AI_STATUS_NORMAL; 
static void ai_taskGC( Pilot* pilot )
{
   Task *prev  = NULL;
   Task *t     = pilot->task;
   while (t != NULL) {
      if (t->done) {
         Task * pointer = t;
         /* Unattach pointer. */
         t       = t->next;
         if (prev == NULL)
            pilot->task = t;
         else
            prev->next  = t;
         /* Free pointer. */
         pointer->next = NULL;
         ai_freetask( pointer );
      }
      else {
         prev    = t;
         t       = t->next;
      }
   }
}
 
Task* ai_curTask( Pilot* pilot )
{
   /* Get last task. */
   for (Task *t=pilot->task; t!=NULL; t=t->next)
      if (!t->done)
         return t;
   return NULL;
}
 
static void ai_setMemory (void)
{
   nlua_env env = cur_pilot->ai->env;
   lua_rawgeti( naevL, LUA_REGISTRYINDEX, cur_pilot->lua_mem );
   nlua_setenv(naevL, env, "mem"); /* pm */
}
 
void ai_setPilot( Pilot *p )
{
   cur_pilot = p;
   ai_setMemory();
}
 
static void ai_run( nlua_env env, int nargs )
{
   if (nlua_pcall(env, nargs, 0)) { /* error has occurred */
      WARN( _("Pilot '%s' ai '%s' error: %s"), cur_pilot->name, cur_pilot->ai->name, lua_tostring(naevL,-1));
      lua_pop(naevL,1);
   }
}
 
int ai_pinit( Pilot *p, const char *ai )
{
   AI_Profile *prof;
   char buf[PATH_MAX];
 
   strncpy(buf, ai, sizeof(buf)-1);
   buf[sizeof(buf)-1] = '\0';
 
   /* Set up the profile. */
   prof = ai_getProfile(buf);
   if (prof == NULL) {
      WARN( _("AI Profile '%s' not found, using dummy fallback."), buf);
      snprintf(buf, sizeof(buf), "dummy" );
      prof = ai_getProfile(buf);
   }
   if (prof == NULL) {
      WARN( _("Dummy AI Profile not valid! Things are going to break.") );
      return -1;
   }
   p->ai = prof;
 
   /* Adds a new pilot memory in the memory table. */
   lua_newtable(naevL);              /* m  */
 
   /* Copy defaults over from the global memory table. */
   lua_rawgeti( naevL, LUA_REGISTRYINDEX, prof->lua_mem ); /* m, d */
   lua_pushnil(naevL);               /* m, d, nil */
   while (lua_next(naevL,-2) != 0) { /* m, d, k, v */
      lua_pushvalue(naevL,-2);       /* m, d, k, v, k */
      lua_pushvalue(naevL,-2);       /* m, d, k, v, k, v */
      lua_remove(naevL, -3);         /* m, d, k, k, v */
      lua_settable(naevL,-5);        /* m, d, k */
   }                                 /* m, d */
   lua_pop(naevL,1);                 /* m */
   p->lua_mem = luaL_ref( naevL, LUA_REGISTRYINDEX ); /* */
 
   /* Create the pilot. */
   ai_create( p );
   pilot_setFlag(p, PILOT_CREATED_AI);
 
   /* Initialize randomly within a control tick. */
   p->tcontrol = RNGF() * p->ai->control_rate;
 
   return 0;
}
 
void ai_cleartasks( Pilot* p )
{
   /* Clean up tasks. */
   if (p->task)
      ai_freetask( p->task );
   p->task = NULL;
}
 
void ai_destroy( Pilot* p )
{
   if (p->ai == NULL)
      return;
 
   /* Get rid of pilot's memory. */
   if (!pilot_isPlayer(p)) { /* Player is an exception as more than one ship shares pilot id. */
      luaL_unref( naevL, LUA_REGISTRYINDEX, p->lua_mem );
      p->lua_mem = LUA_NOREF;
   }
 
   /* Clear the tasks. */
   ai_cleartasks( p );
}
 
static int ai_sort( const void *p1, const void *p2 )
{
   const AI_Profile *ai1 = (const AI_Profile*) p1;
   const AI_Profile *ai2 = (const AI_Profile*) p2;
   return strcmp( ai1->name, ai2->name );
}
 
int ai_load (void)
{
   char** files;
   Uint32 time = SDL_GetTicks();
 
   /* get the file list */
   files = PHYSFS_enumerateFiles( AI_PATH );
 
   /* Create array. */
   profiles = array_create( AI_Profile );
 
   /* load the profiles */
   for (size_t i=0; files[i]!=NULL; i++) {
      AI_Profile prof;
      char path[PATH_MAX];
      int ret;
 
      if (!ndata_matchExt( files[i], "lua" ))
         continue;
 
      snprintf( path, sizeof(path), AI_PATH"%s", files[i] );
      ret = ai_loadProfile(&prof,path); /* Load the profile */
      if (ret == 0)
         array_push_back( &profiles, prof );
      else
         WARN( _("Error loading AI profile '%s'"), path);
 
      /* Render if necessary. */
      naev_renderLoadscreen();
   }
   qsort( profiles, array_size(profiles), sizeof(AI_Profile), ai_sort );
 
   /* More clean up. */
   PHYSFS_freeList( files );
 
   if (conf.devmode) {
      time = SDL_GetTicks() - time;
      DEBUG( n_("Loaded %d AI Profile in %.3f s", "Loaded %d AI Profiles in %.3f s", array_size(profiles) ), array_size(profiles), time/1000. );
   }
   else
      DEBUG( n_("Loaded %d AI Profile", "Loaded %d AI Profiles", array_size(profiles) ), array_size(profiles) );
 
   /* Load equipment thingy. */
   return ai_loadEquip();
}
 
static int ai_loadEquip (void)
{
   char *buf;
   size_t bufsize;
   const char *filename = AI_EQUIP_PATH;
 
   /* Make sure doesn't already exist. */
   nlua_freeEnv(equip_env);
 
   /* Create new state. */
   equip_env = nlua_newEnv();
   nlua_loadStandard(equip_env);
 
   /* Load the file. */
   buf = ndata_read( filename, &bufsize );
   if (nlua_dobufenv(equip_env, buf, bufsize, filename) != 0) {
      WARN( _("Error loading file: %s\n"
          "%s\n"
          "Most likely Lua file has improper syntax, please check"),
            filename, lua_tostring(naevL, -1));
      return -1;
   }
   free(buf);
 
   return 0;
}
 
static int ai_loadProfile( AI_Profile *prof, const char* filename )
{
   char* buf = NULL;
   size_t bufsize = 0;
   nlua_env env;
   size_t len;
   const char *str;
 
   /* Set name. */
   len = strlen(filename)-strlen(AI_PATH)-strlen(".lua");
   prof->name = malloc(len+1);
   strncpy( prof->name, &filename[strlen(AI_PATH)], len );
   prof->name[len] = '\0';
 
   /* Create Lua. */
   env = nlua_newEnv();
   nlua_loadStandard(env);
   prof->env = env;
 
   /* Register C functions in Lua */
   nlua_register(env, "ai", aiL_methods, 0);
 
   /* Mark as an ai. */
   lua_pushboolean( naevL, 1 );
   nlua_setenv( naevL, env, "__ai" );
 
   /* Set "mem" to be default template. */
   lua_newtable(naevL);              /* m */
   lua_pushvalue(naevL,-1);          /* m, m */
   prof->lua_mem = luaL_ref( naevL, LUA_REGISTRYINDEX ); /* m */
   nlua_setenv(naevL, env, "mem");   /*  */
 
   /* Now load the file since all the functions have been previously loaded */
   buf = ndata_read( filename, &bufsize );
   if (nlua_dobufenv(env, buf, bufsize, filename) != 0) {
      WARN( _("Error loading AI file: %s\n"
          "%s\n"
          "Most likely Lua file has improper syntax, please check"),
            filename, lua_tostring(naevL,-1));
      free(prof->name);
      nlua_freeEnv( env );
      free(buf);
      return -1;
   }
   free(buf);
 
   /* Find and set up the necessary references. */
   str = _("AI Profile '%s' is missing '%s' function!");
   prof->ref_control = nlua_refenvtype( env, "control", LUA_TFUNCTION );
   if (prof->ref_control == LUA_NOREF)
      WARN( str, filename, "control" );
   prof->ref_control_manual = nlua_refenvtype( env, "control_manual", LUA_TFUNCTION );
   if (prof->ref_control_manual == LUA_NOREF)
      WARN( str, filename, "control_manual" );
   prof->ref_refuel = nlua_refenvtype( env, "refuel", LUA_TFUNCTION );
   if (prof->ref_refuel == LUA_NOREF)
      WARN( str, filename, "refuel" );
   prof->ref_create = nlua_refenvtype( env, "create", LUA_TFUNCTION );
   if (prof->ref_create == LUA_NOREF)
      WARN( str, filename, "create" );
 
   /* Get the control rate. */
   nlua_getenv(naevL, env, "control_rate");
   prof->control_rate = lua_tonumber(naevL,-1);
   lua_pop(naevL,1);
 
   return 0;
}
 
AI_Profile* ai_getProfile( const char *name )
{
   const AI_Profile ai = { .name = (char*)name };
   AI_Profile *ret = bsearch( &ai, profiles, array_size(profiles), sizeof(AI_Profile), ai_sort );
   if (ret==NULL)
      WARN( _("AI Profile '%s' not found in AI stack"), name);
   return ret;
}
 
void ai_exit (void)
{
   /* Free AI profiles. */
   for (int i=0; i<array_size(profiles); i++) {
      free(profiles[i].name);
      nlua_freeEnv(profiles[i].env);
   }
   array_free( profiles );
 
   /* Free equipment Lua. */
   nlua_freeEnv(equip_env);
   equip_env = LUA_NOREF;
}
 
void ai_think( Pilot* pilot, const double dt )
{
   (void) dt;
   nlua_env env;
   int data;
   Task *t;
 
   /* Must have AI. */
   if (pilot->ai == NULL)
      return;
 
   ai_setPilot(pilot);
   env = cur_pilot->ai->env; /* set the AI profile to the current pilot's */
 
   /* Clean up some variables */
   pilot_acc         = 0;
   pilot_turn        = 0.;
   pilot_flags       = 0;
   /* So the way this works is that, for other than the player, we reset all
    * the weapon sets every frame, so that the AI has to redo them over and
    * over. Now, this is a horrible hack so shit works and needs a proper fix.
    * TODO fix. */
   /* pilot_setTarget( cur_pilot, cur_pilot->id ); */
   if (cur_pilot->id != PLAYER_ID)
      pilot_weapSetAIClear( cur_pilot );
 
   /* Get current task. */
   t = ai_curTask( cur_pilot );
 
   /* control function if pilot is idle or tick is up */
   if ((cur_pilot->tcontrol < 0.) || (t == NULL)) {
      double crate = cur_pilot->ai->control_rate;
      if (pilot_isFlag(pilot,PILOT_PLAYER) ||
          pilot_isFlag(cur_pilot, PILOT_MANUAL_CONTROL)) {
         lua_rawgeti( naevL, LUA_REGISTRYINDEX, cur_pilot->ai->ref_control_manual );
         lua_pushnumber( naevL, crate-cur_pilot->tcontrol );
         ai_run(env, 1);
      } else {
         lua_rawgeti( naevL, LUA_REGISTRYINDEX, cur_pilot->ai->ref_control );
         lua_pushnumber( naevL, crate-cur_pilot->tcontrol );
         ai_run(env, 1); /* run control */
      }
      cur_pilot->tcontrol = crate;
 
      /* Task may have changed due to control tick. */
      t = ai_curTask( cur_pilot );
   }
 
   if (pilot_isFlag(pilot,PILOT_PLAYER) &&
       !pilot_isFlag(cur_pilot, PILOT_MANUAL_CONTROL))
      return;
 
   /* pilot has a currently running task */
   if (t != NULL) {
      /* Run subtask if available, otherwise run main task. */
      if (t->subtask != NULL) {
         lua_rawgeti( naevL, LUA_REGISTRYINDEX, t->subtask->func );
         /* Use subtask data or task data if subtask is not set. */
         data = t->subtask->dat;
         if (data == LUA_NOREF)
            data = t->dat;
      }
      else {
         lua_rawgeti( naevL, LUA_REGISTRYINDEX, t->func );
         data = t->dat;
      }
      /* Function should be on the stack. */
      if (data != LUA_NOREF) {
         lua_rawgeti( naevL, LUA_REGISTRYINDEX, data );
         ai_run(env, 1);
      } else
         ai_run(env, 0);
 
      /* Manual control must check if IDLE hook has to be run. */
      if (pilot_isFlag(cur_pilot, PILOT_MANUAL_CONTROL)) {
         /* We must yet check again to see if there still is a current task running. */
         if (ai_curTask( cur_pilot ) == NULL)
            pilot_runHook( cur_pilot, PILOT_HOOK_IDLE );
      }
   }
 
   /* make sure pilot_acc and pilot_turn are legal */
   pilot_acc   = CLAMP( -1., 1., pilot_acc );
   pilot_turn  = CLAMP( -1., 1., pilot_turn );
 
   /* Set turn and thrust. */
   pilot_setTurn( cur_pilot, pilot_turn );
   pilot_setThrust( cur_pilot, pilot_acc );
 
   /* fire weapons if needed */
   if (ai_isFlag(AI_PRIMARY))
      pilot_shoot(cur_pilot, 0); /* primary */
   if (ai_isFlag(AI_SECONDARY))
      pilot_shoot(cur_pilot, 1 ); /* secondary */
 
   /* other behaviours. */
   if (ai_isFlag(AI_DISTRESS))
      pilot_distress(cur_pilot, NULL, aiL_distressmsg);
 
   /* Clean up if necessary. */
   ai_taskGC( cur_pilot );
}
 
void ai_init( Pilot *p )
{
   if ((p->ai==NULL) || (p->ai->ref_create==LUA_NOREF))
      return;
   ai_setPilot( p );
   lua_rawgeti( naevL, LUA_REGISTRYINDEX, p->ai->ref_create );
   ai_run( p->ai->env, 0 ); /* run control */
 
}
 
void ai_attacked( Pilot *attacked, const unsigned int attacker, double dmg )
{
   HookParam hparam[2];
 
   /* Custom hook parameters. */
   hparam[0].type    = HOOK_PARAM_PILOT;
   hparam[0].u.lp    = attacker;
   hparam[1].type    = HOOK_PARAM_NUMBER;
   hparam[1].u.num   = dmg;
 
   /* Behaves differently if manually overridden. */
   pilot_runHookParam( attacked, PILOT_HOOK_ATTACKED, hparam, 2 );
 
   /* Must have an AI profile. */
   if (attacked->ai == NULL)
      return;
 
   ai_setPilot( attacked ); /* Sets cur_pilot. */
   if (pilot_isFlag( attacked, PILOT_MANUAL_CONTROL ))
      nlua_getenv(naevL, cur_pilot->ai->env, "attacked_manual");
   else
      nlua_getenv(naevL, cur_pilot->ai->env, "attacked");
 
   lua_pushpilot(naevL, attacker);
   if (nlua_pcall(cur_pilot->ai->env, 1, 0)) {
      WARN( _("Pilot '%s' ai '%s' -> 'attacked': %s"), cur_pilot->name, cur_pilot->ai->name, lua_tostring(naevL, -1));
      lua_pop(naevL, 1);
   }
}
 
void ai_discovered( Pilot* discovered )
{
   /* Behaves differently if manually overridden. */
   pilot_runHook( discovered, PILOT_HOOK_DISCOVERED );
   if (pilot_isFlag( discovered, PILOT_MANUAL_CONTROL ))
      return;
 
   /* Must have an AI profile and not be player. */
   if (discovered->ai == NULL)
      return;
 
   ai_setPilot( discovered ); /* Sets cur_pilot. */
 
   /* Only run if discovered function exists. */
   nlua_getenv(naevL, cur_pilot->ai->env, "discovered");
   if (lua_isnil(naevL,-1)) {
      lua_pop(naevL,1);
      return;
   }
 
   if (nlua_pcall(cur_pilot->ai->env, 0, 0)) {
      WARN( _("Pilot '%s' ai '%s' -> 'discovered': %s"), cur_pilot->name, cur_pilot->ai->name, lua_tostring(naevL, -1));
      lua_pop(naevL, 1);
   }
}
 
void ai_hail( Pilot* recipient )
{
   /* Make sure it's getable. */
   if (!pilot_canTarget( recipient ))
      return;
 
   /* Must have an AI profile and not be player. */
   if (recipient->ai == NULL)
      return;
 
   ai_setPilot( recipient ); /* Sets cur_pilot. */
 
   /* Only run if hail function exists. */
   nlua_getenv(naevL, cur_pilot->ai->env, "hail");
   if (lua_isnil(naevL,-1)) {
      lua_pop(naevL,1);
      return;
   }
 
   if (nlua_pcall(cur_pilot->ai->env, 0, 0)) {
      WARN( _("Pilot '%s' ai '%s' -> 'hail': %s"), cur_pilot->name, cur_pilot->ai->name, lua_tostring(naevL, -1));
      lua_pop(naevL, 1);
   }
}
 
void ai_refuel( Pilot* refueler, unsigned int target )
{
   Task *t;
 
   if (cur_pilot->ai->ref_refuel==LUA_NOREF) {
      WARN(_("Pilot '%s' (ai '%s') is trying to refuel when no 'refuel' function is defined!"), cur_pilot->name, cur_pilot->ai->name);
      return;
   }
 
   /* Create the task. */
   t           = calloc( 1, sizeof(Task) );
   t->name     = strdup("refuel");
   lua_rawgeti(naevL, LUA_REGISTRYINDEX, cur_pilot->ai->ref_refuel);
   t->func     = luaL_ref(naevL, LUA_REGISTRYINDEX);
   lua_pushpilot(naevL, target);
   t->dat      = luaL_ref(naevL, LUA_REGISTRYINDEX);
 
   /* Prepend the task. */
   t->next     = refueler->task;
   refueler->task = t;
 
   return;
}
 
void ai_getDistress( Pilot *p, const Pilot *distressed, const Pilot *attacker )
{
   /* Ignore distress signals when under manual control. */
   if (pilot_isFlag( p, PILOT_MANUAL_CONTROL ))
      return;
 
   /* Must have AI. */
   if (cur_pilot->ai == NULL)
      return;
 
   /* Set up the environment. */
   ai_setPilot(p);
 
   /* See if function exists. */
   nlua_getenv(naevL, cur_pilot->ai->env, "distress");
   if (lua_isnil(naevL,-1)) {
      lua_pop(naevL,1);
      return;
   }
 
   /* Run the function. */
   lua_pushpilot(naevL, distressed->id);
   if (attacker != NULL)
      lua_pushpilot(naevL, attacker->id);
   else /* Default to the victim's current target. */
      lua_pushpilot(naevL, distressed->target);
 
   if (nlua_pcall(cur_pilot->ai->env, 2, 0)) {
      WARN( _("Pilot '%s' ai '%s' -> 'distress': %s"), cur_pilot->name, cur_pilot->ai->name, lua_tostring(naevL,-1));
      lua_pop(naevL,1);
   }
}
 
static void ai_create( Pilot* pilot )
{
   /* Set creation mode. */
   if (!pilot_isFlag(pilot, PILOT_CREATED_AI))
      aiL_status = AI_STATUS_CREATE;
 
   /* Create equipment first - only if creating for the first time. */
   if (!pilot_isFlag(pilot,PILOT_NO_OUTFITS) && (aiL_status==AI_STATUS_CREATE)) {
      nlua_env env = equip_env;
      char *func = "equip_generic";
 
      if (faction_getEquipper( pilot->faction ) != LUA_NOREF) {
         env = faction_getEquipper( pilot->faction );
         func = "equip";
      }
      nlua_getenv(naevL, env, func);
      nlua_pushenv(naevL, env);
      lua_setfenv(naevL, -2);
      lua_pushpilot(naevL, pilot->id);
      if (nlua_pcall(env, 1, 0)) { /* Error has occurred. */
         WARN( _("Pilot '%s' equip '%s' -> '%s': %s"), pilot->name, pilot->ai->name, func, lua_tostring(naevL, -1));
         lua_pop(naevL, 1);
      }
 
      /* Since the pilot changes outfits and cores, we must heal him up. */
      pilot_healLanded( pilot );
   }
 
   /* Must have AI. */
   if (pilot->ai == NULL)
      return;
 
   /* Set up. */
   ai_init( pilot );
 
   /* Recover normal mode. */
   if (!pilot_isFlag(pilot, PILOT_CREATED_AI))
      aiL_status = AI_STATUS_NORMAL;
}
 
Task *ai_newtask( lua_State *L, Pilot *p, const char *func, int subtask, int pos )
{
   Task *t, *curtask, *pointer;
 
   if (p->ai==NULL) {
      WARN(_("Trying to create new task for pilot '%s' that has no AI!"), p->name);
      return NULL;
   }
 
   /* Check if the function is good. */
   nlua_getenv( L, p->ai->env, func );
   luaL_checktype( L, -1, LUA_TFUNCTION );
 
   /* Create the new task. */
   t           = calloc( 1, sizeof(Task) );
   t->name     = strdup(func);
   t->func     = luaL_ref( L, LUA_REGISTRYINDEX );
   t->dat      = LUA_NOREF;
 
   /* Handle subtask and general task. */
   if (!subtask) {
      if ((pos == 1) && (p->task != NULL)) { /* put at the end */
         for (pointer = p->task; pointer->next != NULL; pointer = pointer->next);
         pointer->next = t;
      }
      else {
         t->next = p->task;
         p->task = t;
      }
   }
   else {
      /* Must have valid task. */
      curtask = ai_curTask( p );
      if (curtask == NULL) {
         ai_freetask( t );
         NLUA_ERROR( L, _("Trying to add subtask '%s' to non-existent task."), func);
      }
 
      /* Add the subtask. */
      if ((pos == 1) && (curtask->subtask != NULL)) { /* put at the end */
         for (pointer = curtask->subtask; pointer->next != NULL; pointer = pointer->next);
         pointer->next = t;
      }
      else {
         t->next           = curtask->subtask;
         curtask->subtask  = t;
      }
   }
 
   return t;
}
 
void ai_freetask( Task* t )
{
   if (t->func != LUA_NOREF)
      luaL_unref(naevL, LUA_REGISTRYINDEX, t->func);
 
   if (t->dat != LUA_NOREF)
      luaL_unref(naevL, LUA_REGISTRYINDEX, t->dat);
 
   /* Recursive subtask freeing. */
   if (t->subtask != NULL) {
      ai_freetask(t->subtask);
      t->subtask = NULL;
   }
 
   /* Free next task in the chain. */
   if (t->next != NULL) {
      ai_freetask(t->next); /* yay recursive freeing */
      t->next = NULL;
   }
 
   free(t->name);
   free(t);
}
 
static Task* ai_createTask( lua_State *L, int subtask )
{
   /* Parse basic parameters. */
   const char *func = luaL_checkstring(L,1);
 
   if (pilot_isPlayer(cur_pilot) && !pilot_isFlag(cur_pilot,PILOT_MANUAL_CONTROL))
      return NULL;
 
   /* Creates a new AI task. */
   Task *t = ai_newtask( L, cur_pilot, func, subtask, 0 );
 
   /* Set the data. */
   if (lua_gettop(L) > 1) {
      lua_pushvalue(L,2);
      t->dat = luaL_ref(L, LUA_REGISTRYINDEX);
   }
 
   return t;
}
 
static int ai_tasktarget( lua_State *L, Task *t )
{
   if (t->dat == LUA_NOREF)
      return 0;
   lua_rawgeti(L, LUA_REGISTRYINDEX, t->dat);
   return 1;
}
 
static int aiL_pushtask( lua_State *L )
{
   ai_createTask( L, 0 );
   return 0;
}
static int aiL_poptask( lua_State *L )
{
   Task *t = ai_curTask( cur_pilot );
   /* Tasks must exist. */
   if (t == NULL) {
      NLUA_ERROR(L, _("Trying to pop task when there are no tasks on the stack."));
      return 0;
   }
   t->done = 1;
   return 0;
}
 
static int aiL_taskname( lua_State *L )
{
   Task *t = ai_curTask( cur_pilot );
   if (t)
      lua_pushstring(L, t->name);
   else
      lua_pushnil(L);
   return 1;
}
 
static int aiL_taskdata( lua_State *L )
{
   Task *t = ai_curTask( cur_pilot );
 
   /* Must have a task. */
   if (t == NULL)
      return 0;
 
   return ai_tasktarget( L, t );
}
 
static int aiL_pushsubtask( lua_State *L )
{
   ai_createTask(L, 1);
   return 0;
}
 
static int aiL_popsubtask( lua_State *L )
{
   Task *t, *st;
   t = ai_curTask( cur_pilot );
 
   /* Tasks must exist. */
   if (t == NULL) {
      NLUA_ERROR(L, _("Trying to pop task when there are no tasks on the stack."));
      return 0;
   }
   if (t->subtask == NULL) {
      NLUA_ERROR(L, _("Trying to pop subtask when there are no subtasks for the task '%s'."), t->name);
      return 0;
   }
 
   /* Exterminate, annihilate destroy. */
   st          = t->subtask;
   t->subtask  = st->next;
   st->next    = NULL;
   ai_freetask(st);
   return 0;
}
 
static int aiL_subtaskname( lua_State *L )
{
   Task *t = ai_curTask( cur_pilot );
   if ((t != NULL) && (t->subtask != NULL))
      lua_pushstring(L, t->subtask->name);
   else
      lua_pushnil(L);
   return 1;
}
 
static int aiL_subtaskdata( lua_State *L )
{
   Task *t = ai_curTask( cur_pilot );
   /* Must have a subtask. */
   if ((t == NULL) || (t->subtask == NULL))
      return 0;
 
   return ai_tasktarget( L, t->subtask );
}
 
static int aiL_pilot( lua_State *L )
{
   lua_pushpilot(L, cur_pilot->id);
   return 1;
}
 
static int aiL_getrndpilot( lua_State *L )
{
   Pilot *const* pilot_stack = pilot_getAll();
   int p = RNG(0, array_size(pilot_stack)-1);
   /* Make sure it can't be the same pilot. */
   if (pilot_stack[p]->id == cur_pilot->id) {
      p++;
      if (p >= array_size(pilot_stack))
         p = 0;
   }
   /* Last check. */
   if (pilot_stack[p]->id == cur_pilot->id)
      return 0;
   /* Actually found a pilot. */
   lua_pushpilot(L, pilot_stack[p]->id);
   return 1;
}
 
static int aiL_getnearestpilot( lua_State *L )
{
   /* dist will be initialized to a number */
   /* this will only seek out pilots closer than dist */
   Pilot *const* pilot_stack = pilot_getAll();
   int dist = 1e6;
   int candidate_id = -1;
 
   /*cycle through all the pilots and find the closest one that is not the pilot */
   for (int i=0; i<array_size(pilot_stack); i++) {
      if (pilot_stack[i]->id == cur_pilot->id)
         continue;
      if (vec2_dist(&pilot_stack[i]->solid->pos, &cur_pilot->solid->pos) > dist)
         continue;
      dist = vec2_dist(&pilot_stack[i]->solid->pos, &cur_pilot->solid->pos);
      candidate_id = i;
   }
 
   /* Last check. */
   if (candidate_id == -1)
      return 0;
 
   /* Actually found a pilot. */
   lua_pushpilot(L, pilot_stack[candidate_id]->id);
   return 1;
}
 
static int aiL_getdistance( lua_State *L )
{
   vec2 *v;
 
   /* vector as a parameter */
   if (lua_isvector(L,1))
      v = lua_tovector(L,1);
   /* pilot as parameter */
   else if (lua_ispilot(L,1)) {
      Pilot *p = luaL_validpilot(L,1);
      v = &p->solid->pos;
   }
   /* wrong parameter */
   else
      NLUA_INVALID_PARAMETER(L);
 
   lua_pushnumber(L, vec2_dist(v, &cur_pilot->solid->pos));
   return 1;
}
 
static int aiL_getdistance2( lua_State *L )
{
   vec2 *v;
 
   /* vector as a parameter */
   if (lua_isvector(L,1))
      v = lua_tovector(L,1);
   /* pilot as parameter */
   else if (lua_ispilot(L,1)) {
      Pilot *p = luaL_validpilot(L,1);
      v = &p->solid->pos;
   }
   /* wrong parameter */
   else
      NLUA_INVALID_PARAMETER(L);
 
   lua_pushnumber(L, vec2_dist2(v, &cur_pilot->solid->pos));
   return 1;
}
 
static int aiL_getflybydistance( lua_State *L )
{
   vec2 *v;
   vec2 perp_motion_unit, offset_vect;
   int offset_distance;
 
   /* vector as a parameter */
   if (lua_isvector(L,1))
      v = lua_tovector(L,1);
   /* pilot id as parameter */
   else if (lua_ispilot(L,1)) {
      Pilot *p = luaL_validpilot(L,1);
      v = &p->solid->pos;
 
      /*vec2_cset(&v, VX(pilot->solid->pos) - VX(cur_pilot->solid->pos), VY(pilot->solid->pos) - VY(cur_pilot->solid->pos) );*/
   }
   else
      NLUA_INVALID_PARAMETER(L);
 
   vec2_cset(&offset_vect, VX(*v) - VX(cur_pilot->solid->pos), VY(*v) - VY(cur_pilot->solid->pos) );
   vec2_pset(&perp_motion_unit, 1, VANGLE(cur_pilot->solid->vel)+M_PI_2);
   offset_distance = vec2_dot(&perp_motion_unit, &offset_vect);
 
   lua_pushnumber(L, offset_distance);
   return 1;
}
 
static int aiL_minbrakedist( lua_State *L )
{
   double time, dist, vel;
   vec2 vv;
 
   /* More complicated calculation based on relative velocity. */
   if (lua_gettop(L) > 0) {
      Pilot *p = luaL_validpilot(L,1);
 
      /* Set up the vectors. */
      vec2_cset( &vv, p->solid->vel.x - cur_pilot->solid->vel.x,
            p->solid->vel.y - cur_pilot->solid->vel.y );
 
      /* Run the same calculations. */
      time = VMOD(vv) /
            (cur_pilot->thrust / cur_pilot->solid->mass);
 
      /* Get relative velocity. */
      vel = MIN(cur_pilot->speed - VMOD(p->solid->vel), VMOD(vv));
      if (vel < 0.)
         vel = 0.;
   }
   /* Simple calculation based on distance. */
   else {
      /* Get current time to reach target. */
      time = VMOD(cur_pilot->solid->vel) /
            (cur_pilot->thrust / cur_pilot->solid->mass);
 
      /* Get velocity. */
      vel = MIN(cur_pilot->speed,VMOD(cur_pilot->solid->vel));
   }
   /* Get distance to brake. */
   dist = vel*(time+1.1*M_PI/cur_pilot->turn) -
         0.5*(cur_pilot->thrust/cur_pilot->solid->mass)*time*time;
 
   lua_pushnumber(L, dist); /* return */
   return 1; /* returns one thing */
}
 
static int aiL_isbribed( lua_State *L )
{
   Pilot *p = luaL_validpilot(L,1);
   lua_pushboolean(L, pilot_isWithPlayer(p) && pilot_isFlag(cur_pilot, PILOT_BRIBED));
   return 1;
}
 
static int aiL_instantJump( lua_State *L )
{
   lua_pushboolean(L, cur_pilot->stats.misc_instant_jump);
   return 1;
}
 
static int aiL_ismaxvel( lua_State *L )
{
   //lua_pushboolean(L,(VMOD(cur_pilot->solid->vel) > (cur_pilot->speed-MIN_VEL_ERR)));
   lua_pushboolean(L,(VMOD(cur_pilot->solid->vel) >
                   (solid_maxspeed(cur_pilot->solid, cur_pilot->speed, cur_pilot->thrust)-MIN_VEL_ERR)));
   return 1;
}
 
static int aiL_isstopped( lua_State *L )
{
   lua_pushboolean(L,(VMOD(cur_pilot->solid->vel) < MIN_VEL_ERR));
   return 1;
}
 
static int aiL_isenemy( lua_State *L )
{
   Pilot *p = luaL_validpilot(L,1);
 
   /* Player needs special handling in case of hostility. */
   if (pilot_isWithPlayer(p)) {
      lua_pushboolean(L, pilot_isHostile(cur_pilot));
      return 1;
   }
 
   /* Check if is ally. */
   lua_pushboolean(L,areEnemies(cur_pilot->faction, p->faction));
   return 1;
}
 
static int aiL_isally( lua_State *L )
{
   Pilot *p = luaL_validpilot(L,1);
 
   /* Player needs special handling in case of friendliness. */
   if (pilot_isWithPlayer(p)) {
      lua_pushboolean(L, pilot_isFriendly(cur_pilot));
      return 1;
   }
 
   /* Check if is ally. */
   lua_pushboolean(L,areAllies(cur_pilot->faction, p->faction));
   return 1;
}
 
static int aiL_haslockon( lua_State *L )
{
   lua_pushboolean(L, cur_pilot->lockons > 0);
   return 1;
}
 
static int aiL_hasprojectile( lua_State *L )
{
   lua_pushboolean(L, cur_pilot->projectiles > 0);
   return 1;
}
 
static int aiL_scandone( lua_State *L )
{
   lua_pushboolean(L, pilot_ewScanCheck( cur_pilot ) );
   return 1;
}
 
static int aiL_accel( lua_State *L )
{
   double n = luaL_optnumber( L, 1, 1. );
   pilot_acc = CLAMP( 0., 1., n );
   return 0;
}
 
static int aiL_turn( lua_State *L )
{
   pilot_turn = luaL_checknumber(L,1);
   return 0;
}
 
static int aiL_face( lua_State *L )
{
   vec2 *tv; /* get the position to face */
   double k_diff, k_vel, diff, vx, vy, dx, dy;
   int vel;
 
   /* Get first parameter, aka what to face. */
   if (lua_ispilot(L,1)) {
      Pilot* p = luaL_validpilot(L,1);
      /* Target vector. */
      tv = &p->solid->pos;
   }
   else if (lua_isnumber(L,1)) {
      double d = lua_tonumber(L,1);
      if (d < 0.)
         tv = &cur_pilot->solid->pos;
      else
         NLUA_INVALID_PARAMETER(L);
   }
   else if (lua_isvector(L,1))
      tv = lua_tovector(L,1);
   else
      NLUA_INVALID_PARAMETER(L);
 
   /* Default gain. */
   k_diff = 10.;
   k_vel  = 100.; /* overkill gain! */
 
   /* Check if must invert. */
   if (lua_toboolean(L,2))
      k_diff *= -1;
 
   /* Third parameter. */
   vel = lua_toboolean(L, 3);
 
   /* Tangential component of velocity vector
    *
    * v: velocity vector
    * d: direction vector
    *
    *                  d       d                d
    * v_t = v - ( v . --- ) * --- = v - ( v . ----- ) * d
    *                 |d|     |d|             |d|^2
    */
   /* Velocity vector. */
   vx = cur_pilot->solid->vel.x;
   vy = cur_pilot->solid->vel.y;
   /* Direction vector. */
   dx = tv->x - cur_pilot->solid->pos.x;
   dy = tv->y - cur_pilot->solid->pos.y;
   if (vel && (dx || dy)) {
      /* Calculate dot product. */
      double d = (vx * dx + vy * dy) / (dx*dx + dy*dy);
      /* Calculate tangential velocity. */
      vx = vx - d * dx;
      vy = vy - d * dy;
 
      /* Add velocity compensation. */
      dx += -k_vel * vx;
      dy += -k_vel * vy;
   }
 
   /* Compensate error and rotate. */
   diff = angle_diff( cur_pilot->solid->dir, atan2( dy, dx ) );
 
   /* Make pilot turn. */
   pilot_turn = k_diff * diff;
 
   /* Return angle away from target. */
   lua_pushnumber(L, ABS(diff));
   return 1;
}
 
static int aiL_careful_face( lua_State *L )
{
   vec2 *tv, F, F1;
   Pilot* p;
   Pilot *p_i;
   double k_diff, k_goal, k_enemy, k_mult,
          d, diff, dist, factor;
   int i;
   Pilot *const* pilot_stack;
 
   /* Init some variables */
   pilot_stack = pilot_getAll();
   p = cur_pilot;
 
   /* Get first parameter, aka what to face. */
   if (lua_ispilot(L,1)) {
      p = luaL_validpilot(L,1);
      /* Target vector. */
      tv = &p->solid->pos;
   }
   else if (lua_isnumber(L,1)) {
      d = (double)lua_tonumber(L,1);
      if (d < 0.)
         tv = &cur_pilot->solid->pos;
      else
         NLUA_INVALID_PARAMETER(L);
   }
   else if (lua_isvector(L,1))
      tv = lua_tovector(L,1);
   else
      NLUA_INVALID_PARAMETER(L);
 
   /* Default gains. */
   k_diff = 10.;
   k_goal = 1.;
   k_enemy = 6000000.;
 
   /* Init the force */
   vec2_cset( &F, 0., 0.) ;
   vec2_cset( &F1, tv->x - cur_pilot->solid->pos.x, tv->y - cur_pilot->solid->pos.y) ;
   dist = VMOD(F1) + 0.1; /* Avoid / 0*/
   vec2_cset( &F1, F1.x * k_goal / dist, F1.y * k_goal / dist) ;
 
   /* Cycle through all the pilots in order to compute the force */
   for (i=0; i<array_size(pilot_stack); i++) {
      p_i = pilot_stack[i];
 
      /* Valid pilot isn't self, is in range, isn't the target and isn't disabled */
      if (pilot_isDisabled(p_i) ) continue;
      if (p_i->id == cur_pilot->id) continue;
      if (p_i->id == p->id) continue;
      if (pilot_inRangePilot(cur_pilot, p_i, NULL) != 1) continue;
 
      /* If the enemy is too close, ignore it*/
      dist = vec2_dist(&p_i->solid->pos, &cur_pilot->solid->pos);
      if (dist < 750) continue;
 
      k_mult = pilot_relhp( p_i, cur_pilot ) * pilot_reldps( p_i, cur_pilot );
 
      /* Check if friendly or not */
      if (areEnemies(cur_pilot->faction, p_i->faction)) {
         factor = k_enemy * k_mult / (dist*dist*dist);
         vec2_cset( &F, F.x + factor * (cur_pilot->solid->pos.x - p_i->solid->pos.x),
                F.y + factor * (cur_pilot->solid->pos.y - p_i->solid->pos.y) );
      }
   }
 
   vec2_cset( &F, F.x + F1.x, F.y + F1.y );
 
   /* Rotate. */
   diff = angle_diff( cur_pilot->solid->dir, VANGLE(F) );
 
   /* Make pilot turn. */
   pilot_turn = k_diff * diff;
 
   /* Return angle away from target. */
   lua_pushnumber(L, ABS(diff));
   return 1;
}
 
static int aiL_aim( lua_State *L )
{
   double diff, mod, angle;
 
   if (lua_isasteroid(L,1)) {
      Asteroid *a = luaL_validasteroid(L,1);
      angle = pilot_aimAngle( cur_pilot, &a->pos, &a->vel );
   }
   else {
      Pilot *p = luaL_validpilot(L,1);
      angle = pilot_aimAngle( cur_pilot, &p->solid->pos, &p->solid->vel );
   }
 
   /* Calculate what we need to turn */
   mod = 10.;
   diff = angle_diff(cur_pilot->solid->dir, angle);
   pilot_turn = mod * diff;
 
   lua_pushnumber(L, ABS(diff));
   return 1;
}
 
static int aiL_iface( lua_State *L )
{
   NLUA_MIN_ARGS(1);
   vec2 *vec, drift, reference_vector; /* get the position to face */
   Pilot* p;
   double diff, heading_offset_azimuth, drift_radial, drift_azimuthal;
   int azimuthal_sign;
   double speedmap;
 
   /* Get first parameter, aka what to face. */
   p  = NULL;
   vec = NULL;
   if (lua_ispilot(L,1))
      p = luaL_validpilot(L,1);
   else if (lua_isvector(L,1))
      vec = lua_tovector(L,1);
   else NLUA_INVALID_PARAMETER(L);
 
   if (vec==NULL) {
      if (p == NULL)
         return 0; /* Return silently when attempting to face an invalid pilot. */
      /* Establish the current pilot velocity and position vectors */
      vec2_cset( &drift, VX(p->solid->vel) - VX(cur_pilot->solid->vel), VY(p->solid->vel) - VY(cur_pilot->solid->vel));
      /* Establish the in-line coordinate reference */
      vec2_cset( &reference_vector, VX(p->solid->pos) - VX(cur_pilot->solid->pos), VY(p->solid->pos) - VY(cur_pilot->solid->pos));
   }
   else {
      /* Establish the current pilot velocity and position vectors */
      vec2_cset( &drift, -VX(cur_pilot->solid->vel), -VY(cur_pilot->solid->vel));
      /* Establish the in-line coordinate reference */
      vec2_cset( &reference_vector, VX(*vec) - VX(cur_pilot->solid->pos), VY(*vec) - VY(cur_pilot->solid->pos));
   }
 
   /* Break down the the velocity vectors of both craft into UV coordinates */
   vec2_uv(&drift_radial, &drift_azimuthal, &drift, &reference_vector);
   heading_offset_azimuth = angle_diff(cur_pilot->solid->dir, VANGLE(reference_vector));
 
   /* Now figure out what to do...
    * Are we pointing anywhere inside the correct UV quadrant?
    * if we're outside the correct UV quadrant, we need to get into it ASAP
    * Otherwise match velocities and approach */
   if (FABS(heading_offset_azimuth) < M_PI_2) {
      /* This indicates we're in the correct plane*/
      /* 1 - 1/(|x|+1) does a pretty nice job of mapping the reals to the interval (0...1). That forms the core of this angle calculation */
      /* There is nothing special about the scaling parameter of 200; it can be tuned to get any behavior desired. A lower
         number will give a more dramatic 'lead' */
      speedmap = -1*copysign(1 - 1 / (FABS(drift_azimuthal/200) + 1), drift_azimuthal) * M_PI_2;
      diff = angle_diff(heading_offset_azimuth, speedmap);
      azimuthal_sign = -1;
 
      /* This indicates we're drifting to the right of the target
       * And we need to turn CCW */
      if (diff > 0)
         pilot_turn = azimuthal_sign;
      /* This indicates we're drifting to the left of the target
       * And we need to turn CW */
      else if (diff < 0)
         pilot_turn = -1*azimuthal_sign;
      else
         pilot_turn = 0;
   }
   /* turn most efficiently to face the target. If we intercept the correct quadrant in the UV plane first, then the code above will kick in */
   /* some special case logic is added to optimize turn time. Reducing this to only the else cases would speed up the operation
      but cause the pilot to turn in the less-than-optimal direction sometimes when between 135 and 225 degrees off from the target */
   else {
      /* signal that we're not in a productive direction for thrusting */
      diff = M_PI;
      azimuthal_sign = 1;
 
      if (heading_offset_azimuth >0)
         pilot_turn = azimuthal_sign;
      else
         pilot_turn = -1*azimuthal_sign;
   }
 
   /* Return angle in degrees away from target. */
   lua_pushnumber(L, ABS(diff));
   return 1;
}
 
static int aiL_dir( lua_State *L )
{
   NLUA_MIN_ARGS(1);
   vec2 *vec, sv, tv; /* get the position to face */
   Pilot* p;
   double diff;
   int n;
 
   /* Get first parameter, aka what to face. */
   n  = -2;
   vec = NULL;
   if (lua_ispilot(L,1)) {
      p = luaL_validpilot(L,1);
      vec2_cset( &tv, VX(p->solid->pos), VY(p->solid->pos) );
   }
   else if (lua_isvector(L,1))
      vec = lua_tovector(L,1);
   else NLUA_INVALID_PARAMETER(L);
 
   vec2_cset( &sv, VX(cur_pilot->solid->pos), VY(cur_pilot->solid->pos) );
 
   if (vec==NULL) /* target is dynamic */
      diff = angle_diff(cur_pilot->solid->dir,
            (n==-1) ? VANGLE(sv) :
            vec2_angle(&sv, &tv));
   else /* target is static */
      diff = angle_diff( cur_pilot->solid->dir,
            (n==-1) ? VANGLE(cur_pilot->solid->pos) :
            vec2_angle(&cur_pilot->solid->pos, vec));
 
   /* Return angle in degrees away from target. */
   lua_pushnumber(L, diff);
   return 1;
}
 
static int aiL_idir( lua_State *L )
{
   NLUA_MIN_ARGS(1);
   vec2 *vec, drift, reference_vector; /* get the position to face */
   Pilot* p;
   double diff, heading_offset_azimuth, drift_radial, drift_azimuthal;
   double speedmap;
   /*char announcebuffer[255] = " ", announcebuffer2[128];*/
 
   /* Get first parameter, aka what to face. */
   p  = NULL;
   vec = NULL;
   if (lua_ispilot(L,1))
      p = luaL_validpilot(L,1);
   else if (lua_isvector(L,1))
      vec = lua_tovector(L,1);
   else NLUA_INVALID_PARAMETER(L);
 
   if (vec==NULL) {
      if (p == NULL)
         return 0; /* Return silently when attempting to face an invalid pilot. */
      /* Establish the current pilot velocity and position vectors */
      vec2_cset( &drift, VX(p->solid->vel) - VX(cur_pilot->solid->vel), VY(p->solid->vel) - VY(cur_pilot->solid->vel));
      /* Establish the in-line coordinate reference */
      vec2_cset( &reference_vector, VX(p->solid->pos) - VX(cur_pilot->solid->pos), VY(p->solid->pos) - VY(cur_pilot->solid->pos));
   }
   else {
      /* Establish the current pilot velocity and position vectors */
      vec2_cset( &drift, -VX(cur_pilot->solid->vel), -VY(cur_pilot->solid->vel));
      /* Establish the in-line coordinate reference */
      vec2_cset( &reference_vector, VX(*vec) - VX(cur_pilot->solid->pos), VY(*vec) - VY(cur_pilot->solid->pos));
   }
 
   /* Break down the the velocity vectors of both craft into UV coordinates */
   vec2_uv(&drift_radial, &drift_azimuthal, &drift, &reference_vector);
   heading_offset_azimuth = angle_diff(cur_pilot->solid->dir, VANGLE(reference_vector));
 
   /* now figure out what to do*/
   /* are we pointing anywhere inside the correct UV quadrant? */
   /* if we're outside the correct UV quadrant, we need to get into it ASAP */
   /* Otherwise match velocities and approach*/
   if (FABS(heading_offset_azimuth) < M_PI_2) {
      /* This indicates we're in the correct plane
       * 1 - 1/(|x|+1) does a pretty nice job of mapping the reals to the interval (0...1). That forms the core of this angle calculation
       * there is nothing special about the scaling parameter of 200; it can be tuned to get any behavior desired. A lower
       * number will give a more dramatic 'lead' */
      speedmap = -1*copysign(1 - 1 / (FABS(drift_azimuthal/200) + 1), drift_azimuthal) * M_PI_2;
      diff = angle_diff(heading_offset_azimuth, speedmap);
 
   }
   /* Turn most efficiently to face the target. If we intercept the correct quadrant in the UV plane first, then the code above will kick in
      some special case logic is added to optimize turn time. Reducing this to only the else cases would speed up the operation
      but cause the pilot to turn in the less-than-optimal direction sometimes when between 135 and 225 degrees off from the target */
   else {
      /* signal that we're not in a productive direction for thrusting */
      diff        = M_PI;
   }
 
   /* Return angle in degrees away from target. */
   lua_pushnumber(L, diff);
   return 1;
}
 
static int aiL_drift_facing( lua_State *L )
{
    double drift = angle_diff(VANGLE(cur_pilot->solid->vel), cur_pilot->solid->dir);
    lua_pushnumber(L, drift);
    return 1;
}
 
static int aiL_brake( lua_State *L )
{
   int ret = pilot_brake( cur_pilot );
 
   pilot_acc = cur_pilot->solid->thrust / cur_pilot->thrust;
   pilot_turn = cur_pilot->solid->dir_vel / cur_pilot->turn;
 
   lua_pushboolean(L, ret);
   return 1;
}
 
static int aiL_getnearestspob( lua_State *L )
{
   double dist, d;
   int i, j;
   LuaSpob spob;
 
   /* cycle through spobs */
   for (dist=HUGE_VAL, j=-1, i=0; i<array_size(cur_system->spobs); i++) {
      if (!spob_hasService(cur_system->spobs[i],SPOB_SERVICE_INHABITED))
         continue;
      d = vec2_dist( &cur_system->spobs[i]->pos, &cur_pilot->solid->pos );
      if ((!areEnemies(cur_pilot->faction,cur_system->spobs[i]->presence.faction)) &&
            (d < dist)) { /* closer friendly spob */
         j = i;
         dist = d;
      }
   }
 
   /* no friendly spob found */
   if (j == -1) return 0;
 
   cur_pilot->nav_spob = j;
   spob = cur_system->spobs[j]->id;
   lua_pushspob(L, spob);
 
   return 1;
}
 
static int aiL_getspobfrompos( lua_State *L )
{
   vec2 *pos;
   double dist, d;
   int i, j;
   LuaSpob spob;
 
   pos = luaL_checkvector(L,1);
 
   /* cycle through spobs */
   for (dist=HUGE_VAL, j=-1, i=0; i<array_size(cur_system->spobs); i++) {
      if (!spob_hasService(cur_system->spobs[i],SPOB_SERVICE_INHABITED))
         continue;
      d = vec2_dist( &cur_system->spobs[i]->pos, pos );
      if ((!areEnemies(cur_pilot->faction,cur_system->spobs[i]->presence.faction)) &&
            (d < dist)) { /* closer friendly spob */
         j = i;
         dist = d;
      }
   }
 
   /* no friendly spob found */
   if (j == -1) return 0;
 
   cur_pilot->nav_spob = j;
   spob = cur_system->spobs[j]->id;
   lua_pushspob(L, spob);
 
   return 1;
}
 
static int aiL_getrndspob( lua_State *L )
{
   LuaSpob spob;
   int p;
 
   /* No spobs. */
   if (array_size(cur_system->spobs) == 0)
      return 0;
 
   /* get a random spob */
   p = RNG(0, array_size(cur_system->spobs)-1);
 
   /* Copy the data into a vector */
   spob = cur_system->spobs[p]->id;
   lua_pushspob(L, spob);
 
   return 1;
}
 
static int aiL_getlandspob( lua_State *L )
{
   int *ind;
   int id;
   LuaSpob spob;
   Spob *p;
   int only_friend;
 
   /* If pilot can't land ignore. */
   if (pilot_isFlag(cur_pilot, PILOT_NOLAND))
      return 0;
 
   /* Check if we should get only friendlies. */
   only_friend = lua_toboolean(L, 1);
 
   /* Allocate memory. */
   ind = array_create_size( int, array_size(cur_system->spobs) );
 
   /* Copy friendly spob.s */
   for (int i=0; i<array_size(cur_system->spobs); i++) {
      Spob *pnt = cur_system->spobs[i];
 
      if (!spob_hasService(pnt, SPOB_SERVICE_LAND))
         continue;
      if (!spob_hasService(pnt, SPOB_SERVICE_INHABITED))
         continue;
 
      /* Check conditions. */
      if (only_friend && !areAllies( cur_pilot->faction, pnt->presence.faction ))
         continue;
      if (areEnemies( cur_pilot->faction, pnt->presence.faction ))
         continue;
 
      /* Add it. */
      array_push_back( &ind, i );
   }
 
   /* no spob to land on found */
   if (array_size(ind)==0) {
      array_free(ind);
      return 0;
   }
 
   /* we can actually get a random spob now */
   id = RNG(0,array_size(ind)-1);
   p = cur_system->spobs[ ind[ id ] ];
   spob = p->id;
   lua_pushspob( L, spob );
   cur_pilot->nav_spob = ind[ id ];
   array_free(ind);
 
   return 1;
}
 
static int aiL_land( lua_State *L )
{
   Spob *spob;
   HookParam hparam;
 
   if (!lua_isnoneornil(L,1)) {
      int i;
      Spob *pnt = luaL_validspob( L, 1 );
 
      /* Find the spob. */
      for (i=0; i < array_size(cur_system->spobs); i++) {
         if (cur_system->spobs[i] == pnt) {
            break;
         }
      }
      if (i >= array_size(cur_system->spobs)) {
         NLUA_ERROR( L, _("Spob '%s' not found in system '%s'"), pnt->name, cur_system->name );
         return 0;
      }
 
      cur_pilot->nav_spob = i;
   }
 
   if (cur_pilot->nav_spob < 0) {
      NLUA_ERROR( L, _("Pilot '%s' (ai '%s') has no land target"), cur_pilot->name, cur_pilot->ai->name );
      return 0;
   }
 
   /* Get spob. */
   spob = cur_system->spobs[ cur_pilot->nav_spob ];
 
   /* Check landability. */
   if ((spob->lua_can_land==LUA_NOREF) && !spob_hasService(spob,SPOB_SERVICE_LAND)) { /* Basic services */
      lua_pushboolean(L,0);
      return 1;
   }
   /* TODO can_land is player-specific, we need to implement this on a pilot level...
   if ((!pilot_isFlag(cur_pilot, PILOT_MANUAL_CONTROL) && !spob->can_land)) {
      lua_pushboolean(L,0);
      return 1;
   }
   */
 
   /* Check landing functionality. */
   if (pilot_isFlag(cur_pilot, PILOT_NOLAND)) {
      lua_pushboolean(L,0);
      return 1;
   }
 
   /* Check distance. */
   if (vec2_dist2(&cur_pilot->solid->pos,&spob->pos) > pow2(spob->radius)) {
      lua_pushboolean(L,0);
      return 1;
   }
 
   /* Check velocity. */
   if (vec2_odist2( &cur_pilot->solid->vel ) > pow2(MAX_HYPERSPACE_VEL)) {
      lua_pushboolean(L,0);
      return 1;
   }
 
   if (spob->lua_land == LUA_NOREF) {
      cur_pilot->landing_delay = PILOT_LANDING_DELAY * cur_pilot->ship->dt_default;
      cur_pilot->ptimer = cur_pilot->landing_delay;
      pilot_setFlag( cur_pilot, PILOT_LANDING );
   }
   else {
      lua_rawgeti(naevL, LUA_REGISTRYINDEX, spob->lua_land); /* f */
      lua_pushspob( naevL, spob_index(spob) );
      lua_pushpilot( naevL, cur_pilot->id );
      if (nlua_pcall( spob->lua_env, 2, 0 )) {
         WARN(_("Spob '%s' failed to run '%s':\n%s"), spob->name, "land", lua_tostring(naevL,-1));
         lua_pop(naevL,1);
      }
   }
 
   hparam.type    = HOOK_PARAM_SPOB;
   hparam.u.la    = spob->id;
 
   pilot_runHookParam( cur_pilot, PILOT_HOOK_LAND, &hparam, 1 );
   lua_pushboolean(L,1);
   return 1;
}
 
static int aiL_hyperspace( lua_State *L )
{
   int dist;
 
   /* Find the target jump. */
   if (!lua_isnoneornil(L,1)) {
      JumpPoint *jp = luaL_validjump( L, 1 );
      LuaJump *lj = luaL_checkjump( L, 1 );
      if (lj->srcid != cur_system->id)
         NLUA_ERROR(L, _("Jump point must be in current system."));
      cur_pilot->nav_hyperspace = jp - cur_system->jumps;
   }
 
   dist = space_hyperspace(cur_pilot);
   if (dist == 0.) {
      pilot_shootStop( cur_pilot, 0 );
      pilot_shootStop( cur_pilot, 1 );
      return 0;
   }
 
   lua_pushnumber(L,dist);
   return 1;
}
 
static int aiL_sethyptarget( lua_State *L )
{
   JumpPoint *jp;
   LuaJump *lj;
   vec2 vec;
   double a, rad;
 
   lj = luaL_checkjump( L, 1 );
   jp = luaL_validjump( L, 1 );
 
   if (lj->srcid != cur_system->id)
      NLUA_ERROR(L, _("Jump point must be in current system."));
 
   /* Copy vector. */
   vec = jp->pos;
 
   /* Introduce some error. */
   a     = RNGF() * M_PI * 2.;
   rad   = RNGF() * 0.5 * jp->radius;
   vec2_cadd( &vec, rad*cos(a), rad*sin(a) );
 
   /* Set up target. */
   cur_pilot->nav_hyperspace = jp - cur_system->jumps;
 
   /* Return vector. */
   lua_pushvector( L, vec );
 
   return 1;
}
 
static int aiL_nearhyptarget( lua_State *L )
{
   JumpPoint *jp;
   double mindist, dist;
   LuaJump lj;
 
   /* Find nearest jump .*/
   mindist = INFINITY;
   jp      = NULL;
   for (int i=0; i < array_size(cur_system->jumps); i++) {
      JumpPoint *jiter = &cur_system->jumps[i];
      int useshidden = faction_usesHiddenJumps( cur_pilot->faction );
 
      /* We want only standard jump points to be used. */
      if ((!useshidden && jp_isFlag(jiter, JP_HIDDEN)) || jp_isFlag(jiter, JP_EXITONLY))
         continue;
 
      /* TODO should they try to use systems only with their faction? */
 
      /* Get nearest distance. */
      dist  = vec2_dist2( &cur_pilot->solid->pos, &jiter->pos );
      if (dist < mindist) {
         jp       = jiter;
         mindist  = dist;
      }
   }
   /* None available. */
   if (jp == NULL)
      return 0;
 
   lj.destid = jp->targetid;
   lj.srcid = cur_system->id;
 
   /* Return Jump. */
   lua_pushjump( L, lj );
   return 1;
}
 
static int aiL_rndhyptarget( lua_State *L )
{
   JumpPoint **jumps;
   int r, useshidden;
   int *id;
   LuaJump lj;
 
   /* No jumps in the system. */
   if (array_size(cur_system->jumps) == 0)
      return 0;
 
   useshidden = faction_usesHiddenJumps( cur_pilot->faction );
 
   /* Find usable jump points. */
   jumps = array_create_size( JumpPoint*, array_size(cur_system->jumps) );
   id    = array_create_size( int, array_size(cur_system->jumps) );
   for (int i=0; i < array_size(cur_system->jumps); i++) {
      JumpPoint *jiter = &cur_system->jumps[i];
 
      /* We want only standard jump points to be used. */
      if ((!useshidden && jp_isFlag(jiter, JP_HIDDEN)) || jp_isFlag(jiter, JP_EXITONLY))
         continue;
 
      /* Only jump if there is presence there. */
      if (system_getPresence( jiter->target, cur_pilot->faction ) <= 0.)
         continue;
 
      array_push_back( &id, i );
      array_push_back( &jumps, jiter );
   }
 
   /* Try to be more lax. */
   if (array_size(jumps) <= 0) {
      for (int i=0; i < array_size(cur_system->jumps); i++) {
         JumpPoint *jiter = &cur_system->jumps[i];
 
         /* We want only standard jump points to be used. */
         if ((!useshidden && jp_isFlag(jiter, JP_HIDDEN)) || jp_isFlag(jiter, JP_EXITONLY))
            continue;
 
         array_push_back( &id, i );
         array_push_back( &jumps, jiter );
      }
   }
 
   if (array_size(jumps) <= 0) {
      WARN(_("Pilot '%s' can't find jump to leave system!"), cur_pilot->name);
      return 0;
   }
 
   /* Choose random jump point. */
   r = RNG( 0, MAX( array_size(jumps)-1, 0) );
 
   lj.destid = jumps[r]->targetid;
   lj.srcid = cur_system->id;
 
   /* Clean up. */
   array_free(jumps);
   array_free(id);
 
   /* Return Jump. */
   lua_pushjump( L, lj );
   return 1;
}
 
static int aiL_relvel( lua_State *L )
{
   double dot, mod;
   vec2 vv, pv;
   int absolute;
   Pilot *p = luaL_validpilot(L,1);
 
   if (lua_gettop(L) > 1)
      absolute = lua_toboolean(L,2);
   else
      absolute = 0;
 
   /* Get the projection of target on current velocity. */
   if (absolute == 0)
      vec2_cset( &vv, p->solid->vel.x - cur_pilot->solid->vel.x,
            p->solid->vel.y - cur_pilot->solid->vel.y );
   else
      vec2_cset( &vv, p->solid->vel.x, p->solid->vel.y);
 
   vec2_cset( &pv, p->solid->pos.x - cur_pilot->solid->pos.x,
         p->solid->pos.y - cur_pilot->solid->pos.y );
   dot = vec2_dot( &pv, &vv );
   mod = MAX(VMOD(pv), 1.); /* Avoid /0. */
 
   lua_pushnumber(L, dot / mod );
   return 1;
}
 
static int aiL_follow_accurate( lua_State *L )
{
   vec2 point, cons, goal, pv;
   double radius, angle, Kp, Kd, angle2;
   Pilot *p, *target;
   const char *method;
 
   p = cur_pilot;
   target = luaL_validpilot(L,1);
   radius = luaL_checknumber(L,2);
   angle = luaL_checknumber(L,3);
   Kp = luaL_checknumber(L,4);
   Kd = luaL_checknumber(L,5);
 
   if (lua_isnoneornil(L, 6))
      method = "velocity";
   else
      method = luaL_checkstring(L,6);
 
   if (strcmp( method, "absolute" ) == 0)
      angle2 = angle;
   else if (strcmp( method, "keepangle" ) == 0) {
      vec2_cset( &pv, p->solid->pos.x - target->solid->pos.x,
            p->solid->pos.y - target->solid->pos.y );
      angle2 = VANGLE(pv);
      }
   else /* method == "velocity" */
      angle2 = angle + VANGLE( target->solid->vel );
 
   vec2_cset( &point, VX(target->solid->pos) + radius * cos(angle2),
         VY(target->solid->pos) + radius * sin(angle2) );
 
   /*  Compute the direction using a pd controller */
   vec2_cset( &cons, (point.x - p->solid->pos.x) * Kp +
         (target->solid->vel.x - p->solid->vel.x) *Kd,
         (point.y - p->solid->pos.y) * Kp +
         (target->solid->vel.y - p->solid->vel.y) *Kd );
 
   vec2_cset( &goal, cons.x + p->solid->pos.x, cons.y + p->solid->pos.y);
 
   /* Push info */
   lua_pushvector( L, goal );
 
   return 1;
 
}
 
static int aiL_face_accurate( lua_State *L )
{
   vec2 point, cons, goal, *pos, *vel;
   double radius, angle, Kp, Kd;
   Pilot *p = cur_pilot;
   pos = lua_tovector(L,1);
   vel = lua_tovector(L,2);
   radius = luaL_checknumber(L,3);
   angle = luaL_checknumber(L,4);
   Kp = luaL_checknumber(L,5);
   Kd = luaL_checknumber(L,6);
 
   vec2_cset( &point, pos->x + radius * cos(angle),
         pos->y + radius * sin(angle) );
 
   /*  Compute the direction using a pd controller */
   vec2_cset( &cons, (point.x - p->solid->pos.x) * Kp +
         (vel->x - p->solid->vel.x) *Kd,
         (point.y - p->solid->pos.y) * Kp +
         (vel->y - p->solid->vel.y) *Kd );
 
   vec2_cset( &goal, cons.x + p->solid->pos.x, cons.y + p->solid->pos.y);
 
   /* Push info */
   lua_pushvector( L, goal );
 
   return 1;
 
}
 
static int aiL_stop( lua_State *L )
{
   (void) L; /* avoid gcc warning */
 
   if (VMOD(cur_pilot->solid->vel) < MIN_VEL_ERR)
      vec2_pset( &cur_pilot->solid->vel, 0., 0. );
 
   return 0;
}
 
static int aiL_dock( lua_State *L )
{
   /* Target is another ship. */
   Pilot *p = luaL_validpilot(L,1);
   pilot_dock(cur_pilot, p);
   return 0;
}
 
static int aiL_combat( lua_State *L )
{
   if (lua_gettop(L) > 0) {
      int i = lua_toboolean(L,1);
      if (i==1)
         pilot_setFlag(cur_pilot, PILOT_COMBAT);
      else if (i==0)
         pilot_rmFlag(cur_pilot, PILOT_COMBAT);
   }
   else
      pilot_setFlag(cur_pilot, PILOT_COMBAT);
 
   return 0;
}
 
static int aiL_settarget( lua_State *L )
{
   Pilot *p = luaL_validpilot(L,1);
   pilot_setTarget( cur_pilot, p->id );
   return 0;
}
 
static int aiL_setasterotarget( lua_State *L )
{
   LuaAsteroid_t *la = luaL_checkasteroid(L,1);
 
   /* Set the target asteroid. */
   cur_pilot->nav_anchor = la->parent;
   cur_pilot->nav_asteroid = la->id;
 
   /* Untarget pilot. */
   cur_pilot->target = cur_pilot->id;
   cur_pilot->ptarget = NULL;
 
   return 0;
}
 
static int aiL_getGatherable( lua_State *L )
{
   int i;
   double rad;
 
   if ((lua_gettop(L) < 1) || lua_isnil(L,1))
      rad = INFINITY;
   else
      rad = lua_tonumber(L,1);
 
   i = gatherable_getClosest( cur_pilot->solid->pos, rad );
 
   if (i != -1)
      lua_pushnumber(L,i);
   else
      lua_pushnil(L);
 
   return 1;
}
 
static int aiL_gatherablePos( lua_State *L )
{
   int i, did;
   vec2 pos, vel;
 
   i = lua_tointeger(L,1);
 
   did = gatherable_getPos( &pos, &vel, i );
 
   if (did == 0) /* No gatherable matching this ID. */
      return 0;
 
   lua_pushvector(L, pos);
   lua_pushvector(L, vel);
 
   return 2;
}
 
static int aiL_weapSet( lua_State *L )
{
   Pilot* p;
   int id, type;
   PilotWeaponSet *ws;
 
   p = cur_pilot;
   id = lua_tonumber(L,1);
 
   if (lua_gettop(L) > 1)
      type = lua_toboolean(L,2);
   else
      type = 1;
 
   ws = &p->weapon_sets[id];
 
   if (ws->type == WEAPSET_TYPE_ACTIVE) {
      /* Check if outfit is on */
      int on = 1;
      int l  = array_size(ws->slots);
      for (int i=0; i<l; i++) {
         if (p->outfits[ ws->slots[i].slotid ]->state == PILOT_OUTFIT_OFF) {
            on = 0;
            break;
         }
      }
 
      /* Active weapon sets only care about keypresses. */
      /* activate */
      if (type && !on)
         pilot_weapSetPress(p, id, +1 );
      /* deactivate */
      if (!type && on)
         pilot_weapSetPress(p, id, +1 );
   }
   else {
      /* weapset type is weapon or change */
      if (type)
         pilot_weapSetPress( cur_pilot, id, +1 );
      else
         pilot_weapSetPress( cur_pilot, id, -1 );
   }
   return 0;
}
 
static int aiL_hascannons( lua_State *L )
{
   lua_pushboolean( L, cur_pilot->ncannons > 0 );
   return 1;
}
 
static int aiL_hasturrets( lua_State *L )
{
   lua_pushboolean( L, cur_pilot->nturrets > 0 );
   return 1;
}
 
static int aiL_hasfighterbays( lua_State *L )
{
   lua_pushboolean( L, cur_pilot->nfighterbays > 0 );
   return 1;
}
 
static int aiL_hasafterburner( lua_State *L )
{
   lua_pushboolean( L, cur_pilot->nafterburners > 0 );
   return 1;
}
 
static int aiL_shoot( lua_State *L )
{
   /* Cooldown is similar to a ship being disabled, but the AI continues to
    * think during cooldown, and thus must not be allowed to fire weapons. */
   if (pilot_isFlag(cur_pilot, PILOT_COOLDOWN))
      return 0;
 
   if (lua_toboolean(L,1))
      ai_setFlag(AI_SECONDARY);
   else
      ai_setFlag(AI_PRIMARY);
   return 0;
}
 
static int aiL_getenemy( lua_State *L )
{
   unsigned int id;
 
   id = pilot_getNearestEnemy(cur_pilot);
 
   if (id==0) /* No enemy found */
      return 0;
 
   lua_pushpilot(L, id);
 
   return 1;
}
 
static int aiL_getenemy_size( lua_State *L )
{
   unsigned int id;
   unsigned int LB, UB;
 
   NLUA_MIN_ARGS(2);
 
   LB = luaL_checklong(L,1);
   UB = luaL_checklong(L,2);
 
   if (LB > UB) {
      NLUA_ERROR(L, _("Invalid Bounds"));
      return 0;
   }
 
   id = pilot_getNearestEnemy_size( cur_pilot, LB, UB );
 
   if (id==0) /* No enemy found */
      return 0;
 
   lua_pushpilot(L, id);
   return 1;
}
 
static int aiL_getenemy_heuristic( lua_State *L )
{
   double mass_factor    = luaL_checknumber(L,1);
   double health_factor  = luaL_checknumber(L,2);
   double damage_factor  = luaL_checknumber(L,3);
   double range_factor   = luaL_checknumber(L,4);
 
   unsigned int id = pilot_getNearestEnemy_heuristic( cur_pilot,
         mass_factor, health_factor, damage_factor, 1./range_factor );
 
   if (id==0) /* No enemy found */
      return 0;
 
   lua_pushpilot(L, id);
   return 1;
}
 
static int aiL_hostile( lua_State *L )
{
   Pilot *p = luaL_validpilot(L,1);
 
   if (pilot_isWithPlayer(p))
      pilot_setHostile(cur_pilot);
 
   return 0;
}
 
static int aiL_getweaprange( lua_State *L )
{
   int id    = luaL_optinteger( L, 1, cur_pilot->active_set );
   int level = luaL_optinteger( L, 2, -1 );
   lua_pushnumber(L, pilot_weapSetRange( cur_pilot, id, level ) );
   return 1;
}
 
static int aiL_getweapspeed( lua_State *L )
{
   int id    = luaL_optinteger( L, 1, cur_pilot->active_set );
   int level = luaL_optinteger( L, 2, -1 );
   lua_pushnumber(L, pilot_weapSetSpeed( cur_pilot, id, level ) );
   return 1;
}
 
static int aiL_getweapammo( lua_State *L )
{
   int id    = luaL_optinteger( L, 1, cur_pilot->active_set );
   int level = luaL_optinteger( L, 2, -1 );
   lua_pushnumber(L, pilot_weapSetAmmo( cur_pilot, id, level ) );
   return 1;
}
 
static int aiL_canboard( lua_State *L )
{
   Pilot *p = luaL_validpilot(L,1);
 
   /* Must be disabled. */
   if (!pilot_isDisabled(p)) {
      lua_pushboolean(L, 0);
      return 1;
   }
 
   /* Check if can be boarded. */
   lua_pushboolean(L, !pilot_isFlag(p, PILOT_BOARDED));
   return 1;
}
 
static int aiL_relsize( lua_State *L )
{
   Pilot *p = luaL_validpilot(L,1);
   lua_pushnumber(L, pilot_relsize(cur_pilot, p));
   return 1;
}
 
static int aiL_reldps( lua_State *L )
{
   Pilot *p = luaL_validpilot(L,1);
   lua_pushnumber(L, pilot_reldps(cur_pilot, p));
   return 1;
}
 
static int aiL_relhp( lua_State *L )
{
   Pilot *p = luaL_validpilot(L,1);
   lua_pushnumber(L, pilot_relhp(cur_pilot, p));
   return 1;
}
 
static int aiL_board( lua_State *L )
{
   lua_pushboolean(L, pilot_board( cur_pilot ));
   return 1;
}
 
static int aiL_refuel( lua_State *L )
{
   lua_pushboolean(L,pilot_refuelStart(cur_pilot));
   return 1;
}
 
static int aiL_settimer( lua_State *L )
{
   int n = luaL_checkint(L,1);
   /* Set timer. */
   cur_pilot->timer[n] = luaL_optnumber(L,2,0.);
   return 0;
}
 
static int aiL_timeup( lua_State *L )
{
   int n = luaL_checkint(L,1);
   lua_pushboolean(L, cur_pilot->timer[n] < 0.);
   return 1;
}
 
static int aiL_set_shoot_indicator( lua_State *L )
{
   cur_pilot->shoot_indicator = lua_toboolean(L,1);
   return 0;
}
 
static int aiL_shoot_indicator( lua_State *L )
{
   lua_pushboolean(L, cur_pilot->shoot_indicator);
   return 1;
}
 
static int aiL_distress( lua_State *L )
{
   if (lua_isstring(L,1))
      snprintf( aiL_distressmsg, sizeof(aiL_distressmsg), "%s", lua_tostring(L,1) );
   else if (lua_isnil(L,1))
      aiL_distressmsg[0] = '\0';
   else
      NLUA_INVALID_PARAMETER(L);
 
   /* Set flag because code isn't reentrant. */
   ai_setFlag(AI_DISTRESS);
 
   return 0;
}
 
static int aiL_getBoss( lua_State *L )
{
   unsigned int id;
 
   id = pilot_getBoss( cur_pilot );
 
   if (id==0) /* No boss found */
      return 0;
 
   lua_pushpilot(L, id);
 
   return 1;
}
 
static int aiL_credits( lua_State *L )
{
   if (aiL_status != AI_STATUS_CREATE) {
      /*NLUA_ERROR(L, "This function must be called in \"create\" only.");*/
      return 0;
   }
 
   cur_pilot->credits = luaL_checklong(L,1);
 
   return 0;
}
 
static int aiL_messages( lua_State *L )
{
   lua_rawgeti(L, LUA_REGISTRYINDEX, cur_pilot->messages);
   lua_newtable(L);
   lua_rawseti(L, LUA_REGISTRYINDEX, cur_pilot->messages);
   return 1;
}
 
static int aiL_stealth( lua_State *L )
{
   int b = 1;
   if (lua_gettop(L)>0)
      b = lua_toboolean(L,1);
 
   if (!b) {
      pilot_destealth( cur_pilot );
      lua_pushboolean(L,1); /* always succeeds */
      return 1;
   }
 
   lua_pushboolean(L, pilot_stealth( cur_pilot ));
   return 1;
}