nlua_player.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <lauxlib.h>
#include <lua.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
 
#include "naev.h"
#include "nlua_player.h"
 
#include "array.h"
#include "board.h"
#include "comm.h"
#include "event.h"
#include "gui.h"
#include "gui_omsg.h"
#include "hook.h"
#include "info.h"
#include "land.h"
#include "land_outfits.h"
#include "log.h"
#include "map.h"
#include "map_overlay.h"
#include "mission.h"
#include "ndata.h"
#include "nlua_colour.h"
#include "nlua_commodity.h"
#include "nlua_outfit.h"
#include "nlua_pilot.h"
#include "nlua_spob.h"
#include "nlua_ship.h"
#include "nlua_system.h"
#include "nlua_time.h"
#include "nlua_vec2.h"
#include "nluadef.h"
#include "nstring.h"
#include "pause.h"
#include "player.h"
#include "player_fleet.h"
#include "player_inventory.h"
#include "save.h"
 
#define PLAYER_CHECK() if (player.p == NULL) return 0
 
/* Player methods. */
static int playerL_getname( lua_State *L );
static int playerL_shipname( lua_State *L );
static int playerL_pay( lua_State *L );
static int playerL_credits( lua_State *L );
static int playerL_wealth( lua_State *L );
static int playerL_msg( lua_State *L );
static int playerL_msgClear( lua_State *L );
static int playerL_msgToggle( lua_State *L );
static int playerL_omsgAdd( lua_State *L );
static int playerL_omsgChange( lua_State *L );
static int playerL_omsgRm( lua_State *L );
static int playerL_allowSave( lua_State *L );
/* Faction stuff. */
static int playerL_getPosition( lua_State *L );
static int playerL_getPilot( lua_State *L );
/* Fuel stuff. */
static int playerL_jumps( lua_State *L );
static int playerL_fuel( lua_State *L );
static int playerL_refuel( lua_State *L );
static int playerL_autonav( lua_State *L );
static int playerL_autonavDest( lua_State *L );
static int playerL_autonavAbort( lua_State *L );
static int playerL_autonavReset( lua_State *L );
/* Cinematics. */
static int playerL_setSpeed( lua_State *L );
static int playerL_cinematics( lua_State *L );
static int playerL_damageSPFX( lua_State *L );
static int playerL_screenshot( lua_State *L );
/* Board stuff. */
static int playerL_unboard( lua_State *L );
/* Land stuff. */
static int playerL_isLanded( lua_State *L );
static int playerL_takeoff( lua_State *L );
static int playerL_land( lua_State *L );
static int playerL_allowLand( lua_State *L );
static int playerL_landWindow( lua_State *L );
/* Hail stuff. */
static int playerL_commclose( lua_State *L );
/* Shipvars. */
static int playerL_shipvarPeek( lua_State *L );
static int playerL_shipvarPush( lua_State *L );
static int playerL_shipvarPop( lua_State *L );
/* Outfit and ship management stuff. */
static int playerL_ships( lua_State *L );
static int playerL_shipOutfits( lua_State *L );
static int playerL_shipMetadata( lua_State *L );
static int playerL_shipDeploy( lua_State *L );
static int playerL_outfits( lua_State *L );
static int playerL_numOutfit( lua_State *L );
static int playerL_outfitAdd( lua_State *L );
static int playerL_outfitRm( lua_State *L );
static int playerL_shipAdd( lua_State *L );
static int playerL_shipSwap( lua_State *L );
/* Mission/event management stuff. */
static int playerL_missions( lua_State *L );
static int playerL_misnActive( lua_State *L );
static int playerL_misnDone( lua_State *L );
static int playerL_misnDoneList( lua_State *L );
static int playerL_evtActive( lua_State *L );
static int playerL_evtDone( lua_State *L );
/* Fleet stuff. */
static int playerL_fleetList( lua_State *L );
static int playerL_fleetCargoFree( lua_State *L );
static int playerL_fleetCargoUsed( lua_State *L );
static int playerL_fleetCargoOwned( lua_State *L );
static int playerL_fleetCargoAdd( lua_State *L );
static int playerL_fleetCargoRm( lua_State *L );
static int playerL_fleetCargoJet( lua_State *L );
static int playerL_fleetCargoList( lua_State *L );
/* Inventory. */
static int playerL_inventory( lua_State *L );
static int playerL_inventoryAdd( lua_State *L );
static int playerL_inventoryRm( lua_State *L );
static int playerL_inventoryOwned( lua_State *L );
/* Misc stuff. */
static int playerL_teleport( lua_State *L );
static int playerL_dt_mod( lua_State *L );
static int playerL_fleetCapacity( lua_State *L );
static int playerL_fleetCapacitySet( lua_State *L );
static int playerL_chapter( lua_State *L );
static int playerL_chapterSet( lua_State *L );
static int playerL_infoButtonRegister( lua_State *L );
static int playerL_infoButtonUnregister( lua_State *L );
static int playerL_canDiscover( lua_State *L );
static int playerL_save( lua_State *L );
static int playerL_saveBackup( lua_State *L );
static const luaL_Reg playerL_methods[] = {
   { "name", playerL_getname },
   { "ship", playerL_shipname },
   { "pay", playerL_pay },
   { "credits", playerL_credits },
   { "wealth", playerL_wealth },
   { "msg", playerL_msg },
   { "msgClear", playerL_msgClear },
   { "msgToggle", playerL_msgToggle },
   { "omsgAdd", playerL_omsgAdd },
   { "omsgChange", playerL_omsgChange },
   { "omsgRm", playerL_omsgRm },
   { "allowSave", playerL_allowSave },
   { "pos", playerL_getPosition },
   { "pilot", playerL_getPilot },
   { "jumps", playerL_jumps },
   { "fuel", playerL_fuel },
   { "refuel", playerL_refuel },
   { "autonav", playerL_autonav },
   { "autonavDest", playerL_autonavDest },
   { "autonavAbort", playerL_autonavAbort },
   { "autonavReset", playerL_autonavReset },
   { "setSpeed", playerL_setSpeed },
   { "cinematics", playerL_cinematics },
   { "damageSPFX", playerL_damageSPFX },
   { "screenshot", playerL_screenshot },
   { "unboard", playerL_unboard },
   { "isLanded", playerL_isLanded },
   { "takeoff", playerL_takeoff },
   { "land", playerL_land },
   { "allowLand", playerL_allowLand },
   { "landWindow", playerL_landWindow },
   { "commClose", playerL_commclose },
   { "shipvarPeek", playerL_shipvarPeek },
   { "shipvarPush", playerL_shipvarPush },
   { "shipvarPop", playerL_shipvarPop },
   { "ships", playerL_ships },
   { "shipOutfits", playerL_shipOutfits },
   { "shipMetadata", playerL_shipMetadata },
   { "shipDeploy", playerL_shipDeploy },
   { "outfits", playerL_outfits },
   { "numOutfit", playerL_numOutfit },
   { "outfitAdd", playerL_outfitAdd },
   { "outfitRm", playerL_outfitRm },
   { "shipAdd", playerL_shipAdd },
   { "shipSwap", playerL_shipSwap },
   { "missions", playerL_missions },
   { "misnActive", playerL_misnActive },
   { "misnDone", playerL_misnDone },
   { "misnDoneList", playerL_misnDoneList },
   { "evtActive", playerL_evtActive },
   { "evtDone", playerL_evtDone },
   { "fleetList", playerL_fleetList },
   { "fleetCargoFree", playerL_fleetCargoFree },
   { "fleetCargoUsed", playerL_fleetCargoUsed },
   { "fleetCargoOwned", playerL_fleetCargoOwned },
   { "fleetCargoAdd", playerL_fleetCargoAdd },
   { "fleetCargoRm", playerL_fleetCargoRm },
   { "fleetCargoJet", playerL_fleetCargoJet },
   { "fleetCargoList", playerL_fleetCargoList },
   { "inventory", playerL_inventory },
   { "inventoryAdd", playerL_inventoryAdd },
   { "inventoryRm", playerL_inventoryRm },
   { "inventoryOwned", playerL_inventoryOwned },
   { "teleport", playerL_teleport },
   { "dt_mod", playerL_dt_mod },
   { "fleetCapacity", playerL_fleetCapacity },
   { "fleetCapacitySet", playerL_fleetCapacitySet },
   { "chapter", playerL_chapter },
   { "chapterSet", playerL_chapterSet },
   { "infoButtonRegister", playerL_infoButtonRegister },
   { "infoButtonUnregister", playerL_infoButtonUnregister },
   { "canDiscover", playerL_canDiscover },
   { "save", playerL_save },
   { "saveBackup", playerL_saveBackup },
   {0,0}
}; 
int nlua_loadPlayer( nlua_env env )
{
   nlua_register(env, "player", playerL_methods, 0);
   return 0;
}
 
static int playerL_getname( lua_State *L )
{
   PLAYER_CHECK();
   lua_pushstring(L,player.name);
   return 1;
}
static int playerL_shipname( lua_State *L )
{
   PLAYER_CHECK();
   lua_pushstring(L,player.p->name);
   return 1;
}
static int playerL_pay( lua_State *L )
{
   HookParam p[3];
   credits_t money;
   int nohooks;
   const char *reason;
 
   PLAYER_CHECK();
 
   money = CLAMP( CREDITS_MIN, CREDITS_MAX, (credits_t)round(luaL_checknumber(L,1)) );
   player_modCredits( money );
   if (lua_isstring(L,2)) {
      nohooks = 0;
      reason = lua_tostring(L,2);
   }
   else {
      nohooks = lua_toboolean(L,2);
      reason = NULL;
   }
 
   if (!nohooks) {
      p[0].type = HOOK_PARAM_NUMBER;
      p[0].u.num = (double)money;
      if (reason != NULL) {
         p[1].type = HOOK_PARAM_STRING;
         p[1].u.str = reason;
      }
      else {
         p[1].type = HOOK_PARAM_NIL;
      }
      p[2].type = HOOK_PARAM_SENTINEL;
      hooks_runParam( "pay", p );
   }
 
   return 0;
}
 
static int playerL_credits( lua_State *L )
{
   PLAYER_CHECK();
   /* Parse parameters. */
   int decimals = luaL_optinteger(L,1,-1);
 
   /* Push return. */
   lua_pushnumber(L, player.p->credits);
   if (decimals >= 0) {
      char buf[ ECON_CRED_STRLEN ];
      credits2str( buf, player.p->credits, decimals );
      lua_pushstring(L, buf);
      return 2;
   }
   return 1;
}
 
static int playerL_wealth( lua_State *L )
{
   PLAYER_CHECK();
   const PlayerShip_t *ps = player_getShipStack();
   const PlayerOutfit_t *po = player_getOutfits();
   credits_t wealth = player.p->credits + pilot_worth( player.p );
   /* Parse parameters. */
   int decimals = luaL_optinteger(L,1,-1);
 
   /* Compute total wealth. */
   for (int i=0; i<array_size(ps); i++)
      wealth += pilot_worth( ps[i].p  );
   for (int i=0; i<array_size(po); i++)
      wealth += po[i].q * po[i].o->price;
 
   /* Push return. */
   lua_pushnumber(L, wealth);
   if (decimals >= 0) {
      char buf[ ECON_CRED_STRLEN ];
      credits2str( buf, wealth, decimals );
      lua_pushstring(L, buf);
      return 2;
   }
   return 1;
}
 
static int playerL_msg( lua_State *L )
{
   PLAYER_CHECK();
 
   const char *str = luaL_checkstring(L,1);
   int display = lua_toboolean(L,2);
   player_messageRaw(str);
   if (display)
      pilot_setCommMsg( player.p, str );
 
   return 0;
}
static int playerL_msgClear( lua_State *L )
{
   (void) L;
   PLAYER_CHECK();
   gui_clearMessages();
   return 0;
}
static int playerL_msgToggle( lua_State *L )
{
   PLAYER_CHECK();
   player_messageToggle( lua_toboolean(L,1) );
   return 0;
}
static int playerL_omsgAdd( lua_State *L )
{
   const char *str;
   double duration;
   unsigned int id;
   int fontsize;
   const glColour *col;
 
   PLAYER_CHECK();
 
   /* Input. */
   str      = luaL_checkstring(L,1);
   duration = luaL_optnumber(L,2,10.);
   fontsize = luaL_optinteger(L,3,OMSG_FONT_DEFAULT_SIZE);
   col      = luaL_optcolour(L,4,&cWhite);
 
   /* Infinity. */
   if (duration < 1e-10)
      duration = INFINITY;
 
   /* Output. */
   id       = omsg_add( str, duration, fontsize, col );
   lua_pushnumber( L, id );
   return 1;
}
static int playerL_omsgChange( lua_State *L )
{
   const char *str;
   double duration;
   unsigned int id;
   int ret;
 
   PLAYER_CHECK();
 
   /* Input. */
   id       = luaL_checklong(L,1);
   str      = luaL_checkstring(L,2);
   duration = luaL_checknumber(L,3);
 
   /* Infinity. */
   if (duration < 1e-10)
      duration = INFINITY;
 
   /* Output. */
   ret      = omsg_change( id, str, duration );
   lua_pushboolean(L,!ret);
   return 1;
}
static int playerL_omsgRm( lua_State *L )
{
   PLAYER_CHECK();
   unsigned int id = luaL_checklong(L,1);
   omsg_rm( id );
   return 0;
}
static int playerL_allowSave( lua_State *L )
{
   unsigned int b;
   PLAYER_CHECK();
   if (lua_gettop(L)==0)
      b = 1;
   else
      b = lua_toboolean(L, 1);
 
   if (b)
      player_rmFlag(PLAYER_NOSAVE);
   else
      player_setFlag(PLAYER_NOSAVE);
   return 0;
}
 
static int playerL_getPosition( lua_State *L )
{
   PLAYER_CHECK();
   lua_pushvector(L, player.p->solid->pos);
   return 1;
}
 
static int playerL_getPilot( lua_State *L )
{
   /* No need to run check here or stuff that depends on player.pilot() working will fail. */
   lua_pushpilot(L, PLAYER_ID);
   return 1;
}
 
static int playerL_jumps( lua_State *L )
{
   PLAYER_CHECK();
   lua_pushnumber(L, pilot_getJumps(player.p));
   return 1;
}
 
static int playerL_fuel( lua_State *L )
{
   PLAYER_CHECK();
   lua_pushnumber(L,player.p->fuel);
   lua_pushnumber(L,player.p->fuel_consumption);
   return 2;
}
 
static int playerL_refuel( lua_State *L )
{
   PLAYER_CHECK();
 
   if (lua_gettop(L) > 0) {
      double f = luaL_checknumber(L,1);
      player.p->fuel += f;
   }
   else
      player.p->fuel = player.p->fuel_max;
 
   /* Make sure value is valid. */
   player.p->fuel = CLAMP(0, player.p->fuel_max, player.p->fuel);
 
   return 0;
}
 
static int playerL_autonav( lua_State *L )
{
   PLAYER_CHECK();
   lua_pushboolean( L, player_isFlag( PLAYER_AUTONAV ) );
   return 1;
}
 
static int playerL_autonavDest( lua_State *L )
{
   LuaSystem ls;
   StarSystem *dest;
   int jumps;
 
   /* Get destination. */
   dest = map_getDestination( &jumps );
   if (dest == NULL)
      return 0;
 
   ls = system_index( dest );
   lua_pushsystem( L, ls );
   lua_pushnumber( L, jumps );
   return 2;
}
 
static int playerL_autonavAbort( lua_State *L )
{
   const char *str = luaL_optstring(L,1,NULL);
   player_autonavAbort( str );
   return 0;
}
 
static int playerL_autonavReset( lua_State *L )
{
   double timer = luaL_optnumber(L,1,0.);
   player_autonavResetSpeed();
   player.autonav_timer = timer;
   return 0;
}
 
static int playerL_setSpeed( lua_State *L )
{
   double speed = luaL_optnumber( L, 1, -1 );
 
   if (speed > 0.) {
      player.speed = speed;
      sound_setSpeed( speed );
      pause_setSpeed( speed );
   }
   else {
      player.speed = 1.;
      player_resetSpeed();
   }
 
   return 0;
}
 
static int playerL_cinematics( lua_State *L )
{
   int b, f_gui, f_2x;
   const char *abort_msg;
   double speed;
 
   /* Defaults. */
   abort_msg= NULL;
   f_gui    = 0;
   f_2x     = 0;
   speed    = 1.;
 
   /* Parse parameters. */
   b = lua_toboolean( L, 1 );
   if (!lua_isnoneornil(L,2)) {
      if (!lua_istable(L,2)) {
         NLUA_ERROR( L, _("Second parameter to cinematics should be a table of options or omitted!") );
         return 0;
      }
 
      lua_getfield( L, 2, "abort" );
      if (!lua_isnil( L, -1 ))
         abort_msg = luaL_checkstring( L, -1 );
      lua_pop( L, 1 );
 
      lua_getfield( L, 2, "gui" );
      f_gui = lua_toboolean(L, -1);
      lua_pop( L, 1 );
 
      lua_getfield( L, 2, "no2x" );
      f_2x = lua_toboolean(L, -1);
      lua_pop( L, 1 );
 
      lua_getfield( L, 2, "speed" );
      speed = luaL_optnumber(L,-1,1.);
      lua_pop( L, 1 );
   }
 
   if (b) {
      /* Reset speeds. This will override the player's ship base speed. */
      player.speed = speed;
      sound_setSpeed( speed );
      pause_setSpeed( speed );
 
      /* Get rid of stuff that could be bothersome. */
      player_autonavAbort( abort_msg );
      ovr_setOpen(0);
 
      /* Handle options. */
      player_setFlag( PLAYER_CINEMATICS );
      if (!f_gui)
         player_setFlag( PLAYER_CINEMATICS_GUI );
      if (f_2x)
         player_setFlag( PLAYER_CINEMATICS_2X );
 
      /* Redo viewport. */
      gl_setDefViewport( 0., 0., gl_screen.nw, gl_screen.nh );
   }
   else {
      /* Reset speed properly to player speed. */
      player_resetSpeed();
 
      /* Clean up flags. */
      player_rmFlag( PLAYER_CINEMATICS );
      player_rmFlag( PLAYER_CINEMATICS_GUI );
      player_rmFlag( PLAYER_CINEMATICS_2X );
 
      /* Reload GUI. */
      gui_reload();
   }
 
   return 0;
}
 
static int playerL_damageSPFX( lua_State *L )
{
   double spfx_mod = luaL_checknumber(L,1);
   spfx_shake( spfx_mod );
   spfx_damage( spfx_mod );
   return 0;
}
 
static int playerL_screenshot( lua_State *L )
{
   (void) L;
   player_screenshot();
   return 0;
}
 
static int playerL_unboard( lua_State *L )
{
   (void) L;
   board_unboard();
   return 0;
}
 
static int playerL_isLanded( lua_State *L )
{
   lua_pushboolean( L, landed );
   return 1;
}
 
static int playerL_takeoff( lua_State *L )
{
   if (!landed) {
      NLUA_ERROR(L,_("Player must be landed to force takeoff."));
      return 0;
   }
 
   land_queueTakeoff();
 
   return 0;
}
 
static int playerL_land( lua_State *L )
{
   PLAYER_CHECK();
 
   Spob *spob = luaL_validspob(L,1);
   const char *sysname = spob_getSystem( spob->name );
   if (sysname == NULL)
      NLUA_ERROR(L,_("Spob '%s' is not in a system!"), spob->name);
 
   if (strcmp(sysname,cur_system->name) != 0) {
      /* Refer to playerL_teleport for the voodoo that happens here. */
      pilot_rmFlag( player.p, PILOT_HYPERSPACE );
      pilot_rmFlag( player.p, PILOT_HYP_BEGIN );
      pilot_rmFlag( player.p, PILOT_HYP_BRAKE );
      pilot_rmFlag( player.p, PILOT_HYP_PREP );
      player_accelOver();
      player_autonavEnd();
 
      space_gfxUnload( cur_system );
 
      player_targetClearAll();
 
      space_init( sysname, 0 );
 
      ovr_initAlpha();
   }
   player.p->solid->pos = spob->pos; /* Set position to target. */
 
   /* Do whatever the spob wants to do. */
   if (spob->lua_land != LUA_NOREF) {
      spob_luaInitMem( spob );
      lua_rawgeti(naevL, LUA_REGISTRYINDEX, spob->lua_land); /* f */
      lua_pushspob( naevL, spob_index(spob) );
      lua_pushpilot( naevL, player.p->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);
      }
 
      return 0;
   }
 
   space_queueLand( spob );
   return 0;
}
 
static int playerL_allowLand( lua_State *L )
{
 
   int b;
   const char *str = NULL;
 
   if (lua_gettop(L) > 0) {
      b  = lua_toboolean(L,1);
      if (lua_isstring(L,2))
         str   = lua_tostring(L,2);
   }
   else
      b  = 1;
 
   if (b)
      player_rmFlag( PLAYER_NOLAND );
   else {
      player_setFlag( PLAYER_NOLAND );
      player_nolandMsg( str );
   }
   return 0;
}
 
static int playerL_landWindow( lua_State *L )
{
   int ret;
   const char *str;
   int win;
 
   if (!landed) {
      NLUA_ERROR(L, _("Must be landed to set the active land window."));
      return 0;
   }
 
   str = luaL_checkstring(L,1);
   if (strcasecmp(str,"main")==0)
      win = LAND_WINDOW_MAIN;
   else if (strcasecmp(str,"bar")==0)
      win = LAND_WINDOW_BAR;
   else if (strcasecmp(str,"missions")==0)
      win = LAND_WINDOW_MISSION;
   else if (strcasecmp(str,"outfits")==0)
      win = LAND_WINDOW_OUTFITS;
   else if (strcasecmp(str,"shipyard")==0)
      win = LAND_WINDOW_SHIPYARD;
   else if (strcasecmp(str,"equipment")==0)
      win = LAND_WINDOW_EQUIPMENT;
   else if (strcasecmp(str,"commodity")==0)
      win = LAND_WINDOW_COMMODITY;
   else
      NLUA_INVALID_PARAMETER(L);
 
   /* Sets the window. */
   ret = land_setWindow( win );
 
   lua_pushboolean( L, !ret );
   return 1;
}
 
static int playerL_commclose( lua_State *L )
{
   (void) L;
   comm_queueClose();
   return 0;
}
 
static PlayerShip_t *playerL_shipvarShip( lua_State *L, int idx )
{
   if (lua_isnoneornil(L,idx))
      return &player.ps;
   return player_getPlayerShip( luaL_checkstring(L,idx) );
}
 
static int playerL_shipvarPeek( lua_State *L )
{
   const char *str  = luaL_checkstring(L,1);
   PlayerShip_t *ps = playerL_shipvarShip(L,2);
   lvar *var        = lvar_get( ps->p->shipvar, str );
   if (var != NULL)
      return lvar_push( L, var );
   return 0;
}
 
static int playerL_shipvarPush( lua_State *L )
{
   const char *str  = luaL_checkstring(L,1);
   lvar var         = lvar_tovar( L, str, 2 );
   PlayerShip_t *ps = playerL_shipvarShip(L,3);
   if (ps->p->shipvar==NULL)
      ps->p->shipvar = array_create( lvar );
   lvar_addArray( &ps->p->shipvar, &var, 1 );
   return 0;
}
 
static int playerL_shipvarPop( lua_State *L )
{
   const char *str  = luaL_checkstring(L,1);
   PlayerShip_t *ps = playerL_shipvarShip(L,2);
   lvar *var        = lvar_get( ps->p->shipvar, str );
   if (var != NULL)
      lvar_rmArray( &ps->p->shipvar, var );
   return 0;
}
 
static int playerL_ships( lua_State *L )
{
   PLAYER_CHECK();
 
   const PlayerShip_t *ships = player_getShipStack();
   lua_newtable(L);  /* t */
   for (int i=0; i<array_size(ships); i++) {
      lua_newtable(L);        /* t, k, t */
 
      lua_pushstring(L, ships[i].p->name); /* t, k, t, s */
      lua_setfield(L, -2, "name"); /* t, k, t */
 
      lua_pushship(L, ships[i].p->ship); /* t, k, t, s */
      lua_setfield(L, -2, "ship"); /* t, k, t */
 
      lua_pushboolean(L, ships[i].deployed); /* t, k, t, s */
      lua_setfield(L, -2, "deployed"); /* t, k, t */
 
      lua_rawseti(L, -2, i+1); /* t */
   }
   return 1;
}
 
static int playerL_shipOutfits( lua_State *L )
{
   PLAYER_CHECK();
 
   const char *str;
   int j;
   const PlayerShip_t *ships;
   Pilot *p;
 
   /* Get name. */
   str = luaL_optstring(L, 1, NULL);
   ships = player_getShipStack();
 
   /* Get outfit. */
   lua_newtable(L);
 
   p = NULL;
   if ((str==NULL) || (strcmp(str, player.p->name)==0))
      p = player.p;
   else {
      for (int i=0; i<array_size(ships); i++) {
         if (strcmp(str, ships[i].p->name)==0) {
            p = ships[i].p;
            break;
         }
      }
   }
 
   if (p == NULL) {
      NLUA_ERROR( L, _("Player does not own a ship named '%s'"), str );
      return 0;
   }
 
   lua_newtable( L );
   j = 1;
   for (int i=0; i<array_size(p->outfits); i++) {
      if (p->outfits[i]->outfit == NULL)
         continue;
 
      /* Set the outfit. */
      lua_pushoutfit( L, p->outfits[i]->outfit );
      lua_rawseti( L, -2, j++ );
   }
 
   return 1;
}
 
static int playerL_shipMetadata( lua_State *L )
{
   PLAYER_CHECK();
 
   int destroyed = 0;
   const char *str = luaL_optstring(L, 1, NULL);
   const PlayerShip_t *ships = player_getShipStack();
   const PlayerShip_t *ps = NULL;
   if ((str==NULL) || (strcmp(str, player.p->name)==0))
      ps = &player.ps;
   else {
      for (int i=0; i<array_size(ships); i++) {
         if (strcmp(str, ships[i].p->name)==0) {
            ps = &ships[i];
            break;
         }
      }
   }
   if (ps == NULL) {
      NLUA_ERROR( L, _("Player does not own a ship named '%s'"), str );
      return 0;
   }
 
   lua_newtable(L);
 
   lua_pushnumber( L, ps->time_played );
   lua_setfield( L, -2, "time_played" );
 
   lua_pushstring( L, ps->acquired );
   lua_setfield( L, -2, "acquired" );
 
   lua_pushtime( L, ps->acquired_date );
   lua_setfield( L, -2, "acquired_date" );
 
   lua_pushnumber( L, ps->dmg_done_shield );
   lua_setfield( L, -2, "dmg_done_shield" );
 
   lua_pushnumber( L, ps->dmg_done_armour );
   lua_setfield( L, -2, "dmg_done_armour" );
 
   lua_pushnumber( L, ps->dmg_done_shield+ps->dmg_done_armour );
   lua_setfield( L, -2, "dmg_done" );
 
   lua_pushnumber( L, ps->dmg_taken_shield );
   lua_setfield( L, -2, "dmg_taken_shield" );
 
   lua_pushnumber( L, ps->dmg_taken_armour );
   lua_setfield( L, -2, "dmg_taken_armour" );
 
   lua_pushnumber( L, ps->dmg_taken_shield+ps->dmg_taken_armour );
   lua_setfield( L, -2, "dmg_taken" );
 
   lua_pushinteger( L, ps->jumped_times );
   lua_setfield( L, -2, "jumped_times" );
 
   lua_pushinteger( L, ps->landed_times );
   lua_setfield( L, -2, "landed_times" );
 
   lua_pushinteger( L, ps->death_counter );
   lua_setfield( L, -2, "death_counter" );
 
   for (int i=0; i<SHIP_CLASS_TOTAL; i++)
      destroyed += ps->ships_destroyed[i];
   lua_pushinteger( L, destroyed );
   lua_setfield( L, -2, "ships_destroyed" );
 
   return 1;
}
 
static int playerL_shipDeploy( lua_State *L )
{
   const char *shipname = luaL_checkstring(L,1);
   int deploy = lua_toboolean(L,2);
   PlayerShip_t *ps = player_getPlayerShip( shipname );
   ps->deployed = deploy;
   return 0;
}
 
static int playerL_outfits( lua_State *L )
{
   PLAYER_CHECK();
 
   const PlayerOutfit_t *outfits = player_getOutfits();
   lua_newtable(L);
   for (int i=0; i<array_size(outfits); i++) {
      lua_pushoutfit(L, outfits[i].o );
      lua_rawseti(L, -2, i+1);
   }
   return 1;
}
 
static int playerL_numOutfit( lua_State *L )
{
   PLAYER_CHECK();
 
   const Outfit *o;
   int q, unequipped_only;
 
   /* Handle parameters. */
   o = luaL_validoutfit(L, 1);
   unequipped_only = lua_toboolean(L, 2);
 
   /* Count the outfit. */
   if (unequipped_only)
      q = player_outfitOwned( o );
   else
      q = player_outfitOwnedTotal( o );
   lua_pushnumber( L, q );
 
   return 1;
}
static int playerL_outfitAdd( lua_State *L  )
{
 
   /* Handle parameters. */
   const Outfit *o = luaL_validoutfit(L, 1);
   int q = luaL_optinteger(L, 2, 1);
 
   /* Add the outfits. */
   player_addOutfit( o, q );
 
   /* Update equipment list. */
   outfits_updateEquipmentOutfits();
 
   return 0;
}
static int playerL_outfitRm( lua_State *L )
{
   NLUA_MIN_ARGS(1);
 
   const Outfit *o;
   int q = luaL_optinteger(L, 2, 1);
 
   /* Handle special case it's "all". */
   if (lua_isstring(L, 1)) {
      const char *str = luaL_checkstring(L, 1);
 
      if (strcmp(str,"all")==0) {
         const PlayerOutfit_t *poutfits = player_getOutfits();
         const Outfit **outfits = array_create_size( const Outfit*, array_size( poutfits ) );
         for (int i=0; i<array_size(poutfits); i++)
            array_push_back( &outfits, poutfits[i].o );
 
         for (int i=0; i<array_size(outfits); i++) {
            o = outfits[i];
            q = player_outfitOwned(o);
            player_rmOutfit(o, q);
         }
         /* Clean up. */
         array_free(outfits);
 
         /* Update equipment list. */
         outfits_updateEquipmentOutfits();
         return 0;
      }
   }
 
   /* Usual case. */
   o = luaL_validoutfit(L, 1);
   player_rmOutfit( o, q );
 
   /* Update equipment list. */
   outfits_updateEquipmentOutfits();
 
   return 0;
}
 
static int playerL_shipAdd( lua_State *L )
{
   PlayerShip_t *new_ship;
   /* Handle parameters. */
   const Ship *s     = luaL_validship(L, 1);
   const char *name  = luaL_optstring(L, 2, _(s->name));
   const char *acquired = luaL_optstring(L, 3, NULL);
   int noname        = lua_toboolean(L, 4);
   /* Add the ship, look in case it's cancelled. */
   do {
      new_ship = player_newShip( s, name, 0, acquired, noname );
   } while (new_ship == NULL);
   /* Return the new name. */
   lua_pushstring( L, new_ship->p->name );
   return 1;
}
 
static int playerL_shipSwap( lua_State *L )
{
   PLAYER_CHECK();
 
   const char *str = luaL_checkstring(L,1);
   int ignore_cargo= lua_toboolean(L,2);
   const char *cur = player.p->name;
   player_swapShip( str, !ignore_cargo );
   if (lua_toboolean(L,3))
      player_rmShip( cur );
 
   return 0;
}
 
static int playerL_missions( lua_State *L )
{
   int j = 1;
   lua_newtable(L);
   for (int i=0; i<array_size(player_missions); i++) {
      if (player_missions[i]->id == 0)
         continue;
      lua_pushstring( L, player_missions[i]->data->name );
      lua_rawseti( L, -2, j++ );
   }
   return 1;
}
 
static int playerL_misnActive( lua_State *L )
{
   const char *str = luaL_checkstring(L,1);
   const MissionData *misn = mission_getFromName( str );
   if (misn == NULL) {
      NLUA_ERROR(L, _("Mission '%s' not found in stack"), str);
      return 0;
   }
   int n = mission_alreadyRunning( misn );
   if (n > 0)
      lua_pushinteger( L, n );
   else
      lua_pushboolean( L, 0 );
   return 1;
}
 
static int playerL_misnDone( lua_State *L )
{
   const char *str = luaL_checkstring(L, 1);
   int id          = mission_getID( str );
   if (id == -1) {
      NLUA_ERROR(L, _("Mission '%s' not found in stack"), str);
      return 0;
   }
   lua_pushboolean( L, player_missionAlreadyDone( id ) );
   return 1;
}
 
static int playerL_misnDoneList( lua_State *L )
{
   int *done = player_missionsDoneList();
   lua_newtable(L);
   for (int i=0; i<array_size(done); i++) {
      mission_toLuaTable( L, mission_get( done[i] ) );
      lua_rawseti(L,-2,i+1);
   }
   return 1;
}
 
static int playerL_evtActive( lua_State *L )
{
   const char *str= luaL_checkstring(L,1);
   int evtid      = event_dataID( str );
   if (evtid < 0) {
      NLUA_ERROR(L, _("Event '%s' not found in stack"), str);
      return 0;
   }
   lua_pushboolean( L, event_alreadyRunning( evtid ) );
   return 1;
}
 
static int playerL_evtDone( lua_State *L )
{
   const char *str = luaL_checkstring(L, 1);
   int id          = event_dataID( str );
   if (id == -1) {
      NLUA_ERROR(L, _("Event '%s' not found in stack"), str);
      return 0;
   }
   lua_pushboolean( L, player_eventAlreadyDone( id ) );
   return 1;
}
 
static int playerL_fleetList( lua_State *L )
{
   int n = 1;
   const PlayerShip_t* pstack = player_getShipStack();
   lua_newtable(L);
   for (int i=0; i<array_size(pstack); i++) {
      const PlayerShip_t *ps = &pstack[i];
      if (!ps->deployed)
         continue;
      /* We can avoid the spaceWorthy check as they will be set to false due to not having a pilot. */
      /*if (!!pilot_isSpaceworthy(ps->p))
         continue;*/
 
      if (ps->p==NULL)
         lua_pushboolean( L, 0 );
      else
         lua_pushpilot( L, ps->p->id );
      lua_rawseti( L, -2, n++ );
   }
   return 1;
}
 
static int playerL_fleetCargoFree( lua_State *L )
{
   lua_pushinteger( L, pfleet_cargoFree() );
   return 1;
}
 
static int playerL_fleetCargoUsed( lua_State *L )
{
   lua_pushinteger( L, pfleet_cargoUsed() );
   return 1;
}
 
static int playerL_fleetCargoOwned( lua_State *L )
{
   Commodity *c = luaL_validcommodity( L, 1 );
   lua_pushinteger( L, pfleet_cargoOwned( c ) );
   return 1;
}
 
static int playerL_fleetCargoAdd( lua_State *L )
{
   Commodity *c = luaL_validcommodity( L, 1 );
   int q = luaL_checkinteger( L, 2 );
   lua_pushinteger( L, pfleet_cargoAdd( c, q ) );
   return 1;
}
 
static int playerL_fleetCargoRm( lua_State *L )
{
   Commodity *c = luaL_validcommodity( L, 1 );
   int q = luaL_checkinteger( L, 2 );
   lua_pushinteger( L, pfleet_cargoRm( c, q, 0 ) );
   return 1;
}
 
static int playerL_fleetCargoJet( lua_State *L )
{
   Commodity *c = luaL_validcommodity( L, 1 );
   int q = luaL_checkinteger( L, 2 );
   lua_pushinteger( L, pfleet_cargoRm( c, q, 1 ) );
   return 1;
}
 
static int playerL_fleetCargoList( lua_State *L )
{
   Commodity *call = commodity_getAll();
   int n = 0;
   lua_newtable(L);                 /* t */
   for (int i=0; i<array_size(call); i++) {
      Commodity *c = &call[i];
      int q = pfleet_cargoOwned( c );
      if (q <= 0)
         continue;
 
      lua_newtable(L);              /* t, t */
 
      lua_pushcommodity( L, c );    /* t, t, c */
      lua_setfield( L, -2, "c" );   /* t, t  */
 
      lua_pushinteger( L, q );      /* t, t, q */
      lua_setfield( L, -2, "q" );   /* t, t */
 
      lua_rawseti( L, -2, ++n );    /* t */
   }
   return 1;
}
 
static int playerL_inventory( lua_State *L )
{
   const PlayerItem *inv = player_inventory();
   lua_newtable(L);
   for (int i=0; i<array_size(inv); i++) {
      const PlayerItem *pi = &inv[i];
      lua_newtable(L);
 
      lua_pushstring(L,pi->name);
      lua_setfield(L,-2,"name");
 
      lua_pushinteger(L,pi->quantity);
      lua_setfield(L,-2,"quantity");
 
      lua_rawseti(L,-2,i+1);
   }
   return 1;
}
 
static int playerL_inventoryAdd( lua_State *L )
{
   const char *name = luaL_checkstring(L,1);
   int q = luaL_optinteger(L,2,1);
   lua_pushinteger( L, player_inventoryAdd( name, q ) );
   return 1;
}
 
static int playerL_inventoryRm( lua_State *L )
{
   const char *name = luaL_checkstring(L,1);
   int q = luaL_optinteger(L,2,1);
   lua_pushinteger( L, player_inventoryRemove( name, q ) );
   return 1;
}
 
static int playerL_inventoryOwned( lua_State *L )
{
   const char *name = luaL_checkstring(L,1);
   lua_pushinteger( L, player_inventoryAmount( name ) );
   return 1;
}
 
static int playerL_teleport( lua_State *L )
{
   Spob *pnt;
   const char *name, *pntname;
   int no_simulate, silent;
 
   PLAYER_CHECK();
 
   /* Must not be landed. */
   if (landed)
      NLUA_ERROR(L,_("Can not teleport the player while landed!"));
   if (comm_isOpen())
      NLUA_ERROR(L,_("Can not teleport the player while the comm is open!"));
   if (player_isBoarded())
      NLUA_ERROR(L,_("Can not teleport the player while they are boarded!"));
   pnt = NULL;
 
   /* Get a system. */
   if (lua_issystem(L,1)) {
      StarSystem *sys = luaL_validsystem(L,1);
      name = system_getIndex(sys->id)->name;
   }
   /* Get a spob. */
   else if (lua_isspob(L,1)) {
      pnt   = luaL_validspob(L,1);
      name  = spob_getSystem( pnt->name );
      if (name == NULL) {
         NLUA_ERROR( L, _("Spob '%s' does not belong to a system."), pnt->name );
         return 0;
      }
   }
   /* Get destination from string. */
   else if (lua_isstring(L,1)) {
      const char *sysname;
      name = lua_tostring(L,1);
      sysname = system_existsCase( name );
      if (sysname == NULL) {
         /* No system found, assume destination string is the name of a spob. */
         pntname = name;
         name = spob_getSystem( pntname );
         pnt  = spob_get( pntname );
         if (pnt == NULL) {
            NLUA_ERROR( L, _("'%s' is not a valid teleportation target."), name );
            return 0;
         }
 
         if (name == NULL) {
            NLUA_ERROR( L, _("Spob '%s' does not belong to a system."), pntname );
            return 0;
         }
      }
      else
         name = sysname;
   }
   else
      NLUA_INVALID_PARAMETER(L);
 
   no_simulate = lua_toboolean(L,2);
   silent = lua_toboolean(L,3);
 
   /* Check if system exists. */
   if (system_get( name ) == NULL) {
      NLUA_ERROR( L, _("System '%s' does not exist."), name );
      return 0;
   }
 
   /* Jump out hook is run first. */
   hooks_run( "jumpout" );
 
   /* Just in case remove hyperspace flags. */
   pilot_rmFlag( player.p, PILOT_HYPERSPACE );
   pilot_rmFlag( player.p, PILOT_HYP_BEGIN );
   pilot_rmFlag( player.p, PILOT_HYP_BRAKE );
   pilot_rmFlag( player.p, PILOT_HYP_PREP );
   /* Don't follow anything. */
   player_accelOver();
   player_autonavEnd();
 
   /* Free graphics. */
   space_gfxUnload( cur_system );
 
   /* Reset targets when teleporting.
    * Both of these functions invoke gui_setNav(), which updates jump and
    * spob targets simultaneously. Thus, invalid reads may arise and the
    * target reset must be done prior to calling space_init and destroying
    * the old system. */
   player_targetClearAll();
 
   /* Hide messages if not needed. */
   if (silent)
      player_messageToggle(0); /* space_init will reset it, so no need to. */
 
   /* Go to the new system. */
   space_init( name, !no_simulate );
 
   /* Map gets deformed when jumping this way. */
   map_clear();
 
   /* Initialize alpha as needed. */
   ovr_initAlpha();
 
   /* Run hooks - order is important. */
   pilot_outfitLOnjumpin( player.p );
   hooks_run( "jumpin" );
   hooks_run( "enter" );
   events_trigger( EVENT_TRIGGER_ENTER );
   missions_run( MIS_AVAIL_ENTER, -1, NULL, NULL );
 
   /* Move to spob. */
   if (pnt != NULL)
      player.p->solid->pos = pnt->pos;
 
   /* Move all escorts to new position. */
   Pilot *const* pilot_stack = pilot_getAll();
   for (int i=0; i<array_size(pilot_stack); i++) {
      Pilot *p = pilot_stack[i];
      if (p->parent == PLAYER_ID) {
         memcpy( &p->solid->pos, &player.p->solid->pos, sizeof(vec2) );
         vec2_padd( &p->solid->pos, 200.+200.*RNGF(), 2.*M_PI*RNGF() );
 
         /* Clean up trails. */
         pilot_clearTrails( p );
      }
   }
 
   return 0;
}
 
static int playerL_dt_mod( lua_State *L )
{
   lua_pushnumber(L,dt_mod);
   return 1;
}
 
static int playerL_fleetCapacity( lua_State *L )
{
   int nships = 0;
   const PlayerShip_t *pships;
   pfleet_update();
   lua_pushnumber(L,player.fleet_capacity);
   lua_pushnumber(L,player.fleet_used);
   pships = player_getShipStack();
   for (int i=0; i<array_size(pships); i++) {
      if (!pships[i].deployed)
         continue;
      nships++;
   }
   lua_pushboolean(L, (nships==0) || (player.fleet_used <= player.fleet_capacity));
   return 3;
}
 
static int playerL_fleetCapacitySet( lua_State *L )
{
   player.fleet_capacity = luaL_checkinteger(L,1);
   return 0;
}
 
static int playerL_chapter( lua_State *L )
{
   lua_pushstring( L, player.chapter );
   return 1;
}
 
static int playerL_chapterSet( lua_State *L )
{
   const char *str = luaL_checkstring(L,1);
   free( player.chapter );
   player.chapter = strdup(str);
   return 0;
}
 
static int playerL_infoButtonRegister( lua_State *L )
{
   int id;
   const char *caption = luaL_checkstring( L, 1 );
   int priority = luaL_optinteger( L, 3, 5 );
   const char *key = luaL_optstring( L, 4, "" );
   luaL_checktype( L, 2, LUA_TFUNCTION );
   lua_pushvalue( L, 2 );
   id = info_buttonRegister( caption, priority, SDL_GetKeyFromName( key ) );
   lua_pushinteger( L, id );
   return 1;
}
 
static int playerL_infoButtonUnregister( lua_State *L )
{
   int id = luaL_checkinteger(L,1);
   int ret = info_buttonUnregister( id );
   if (ret != 0)
      WARN(_("Failed to unregister info button with id '%d'!"), id);
   return 0;
}
 
static int playerL_canDiscover( lua_State *L )
{
   player.discover_off = !lua_toboolean(L,1);
   return 0;
}
 
static int playerL_save( lua_State *L )
{
   const char *savename = luaL_optstring( L, 1, "autosave" );
   Spob *savespob = NULL;
   Spob *prevspob;
   if (!lua_isnoneornil(L,2))
      savespob = luaL_validspob(L,2);
 
   if (!landed && (savespob==NULL))
      NLUA_ERROR(L,_("Unable to save when not landed and land spob is not specified!"));
   else if (landed && (savespob!=land_spob))
      NLUA_ERROR(L,_("Unable to save when landed and land_spob does not match landed spob!"));
 
   if (savespob != NULL) {
      prevspob = land_spob;
      land_spob = savespob;
   }
   lua_pushboolean( L, save_all_with_name( savename ) );
   if (savespob != NULL)
      land_spob = prevspob;
 
   return 1;
}
 
static int playerL_saveBackup( lua_State *L )
{
   char file[PATH_MAX], backup[PATH_MAX];
   const char *filename = luaL_checkstring(L,1); /* TODO sanitize path and such. */
   if (strcmp(filename,"autosave")==0)
      NLUA_ERROR(L,_("Can not back up save to 'autosave'."));
   snprintf( file, sizeof(file), "saves/%s/autosave.ns", player.name );
   snprintf( backup, sizeof(backup), "saves/%s/%s.ns", player.name, filename );
   lua_pushboolean( L, ndata_copyIfExists(file, backup) );
   return 1;
}