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 "camera.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 "map.h"
#include "map_overlay.h"
#include "menu.h"
#include "mission.h"
#include "ndata.h"
#include "nlua_colour.h"
#include "nlua_commodity.h"
#include "nlua_misn.h"
#include "nlua_outfit.h"
#include "nlua_pilot.h"
#include "nlua_ship.h"
#include "nlua_spob.h"
#include "nlua_system.h"
#include "nlua_time.h"
#include "nlua_vec2.h"
#include "nluadef.h"
#include "pause.h"
#include "player.h"
#include "player_autonav.h"
#include "player_fleet.h"
#include "player_gui.h"
#include "player_inventory.h"
#include "rng.h"
#include "save.h"
#include "sound.h"
#include "start.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_autonavSetSpeed( lua_State *L );
static int playerL_autonavSetTarget( lua_State *L );
static int playerL_autonavSetPos( lua_State *L );
static int playerL_autonavRoute( lua_State *L );
static int playerL_autonavDest( lua_State *L );
static int playerL_autonavAbort( lua_State *L );
static int playerL_autonavReset( lua_State *L );
static int playerL_autonavEnd( lua_State *L );
/* Cinematics. */
static int playerL_dt_default( lua_State *L );
static int playerL_speed( lua_State *L );
static int playerL_setSpeed( lua_State *L );
static int playerL_cinematics( lua_State *L );
static int playerL_cinematicsCheck( lua_State *L );
static int playerL_damageSPFX( lua_State *L );
static int playerL_screenshot( lua_State *L );
/* Board stuff. */
static int playerL_tryBoard( lua_State *L );
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_tryLand( lua_State *L );
static int playerL_land( lua_State *L );
static int playerL_landAllow( lua_State *L );
static int playerL_landWindow( lua_State *L );
/* Hail stuff. */
static int playerL_commOpen( lua_State *L );
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_outfitNum( 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 );
static int playerL_evtDoneList( lua_State *L );
/* Handle GUI. */
static int playerL_gui( lua_State *L );
static int playerL_guiList( lua_State *L );
static int playerL_guiSet( lua_State *L );
/* Fleet stuff. */
static int playerL_fleetList( lua_State *L );
static int playerL_fleetCargoFree( lua_State *L );
static int playerL_fleetCargoMissionFree( 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 int playerL_gameover( lua_State *L );
static int playerL_start( 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 },
   { "autonavSetSpeed", playerL_autonavSetSpeed },
   { "autonavSetTarget", playerL_autonavSetTarget },
   { "autonavSetPos", playerL_autonavSetPos },
   { "autonavRoute", playerL_autonavRoute },
   { "autonavDest", playerL_autonavDest },
   { "autonavAbort", playerL_autonavAbort },
   { "autonavReset", playerL_autonavReset },
   { "autonavEnd", playerL_autonavEnd },
   { "dt_default", playerL_dt_default },
   { "speed", playerL_speed },
   { "setSpeed", playerL_setSpeed },
   { "cinematics", playerL_cinematics },
   { "cinematicsCheck", playerL_cinematicsCheck },
   { "damageSPFX", playerL_damageSPFX },
   { "screenshot", playerL_screenshot },
   { "tryBoard", playerL_tryBoard },
   { "unboard", playerL_unboard },
   { "isLanded", playerL_isLanded },
   { "takeoff", playerL_takeoff },
   { "tryLand", playerL_tryLand },
   { "land", playerL_land },
   { "landAllow", playerL_landAllow },
   { "landWindow", playerL_landWindow },
   { "commOpen", playerL_commOpen },
   { "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 },
   { "outfitNum", playerL_outfitNum },
   { "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 },
   { "evtDoneList", playerL_evtDoneList },
   { "gui", playerL_gui },
   { "guiList", playerL_guiList },
   { "guiSet", playerL_guiSet },
   { "fleetList", playerL_fleetList },
   { "fleetCargoFree", playerL_fleetCargoFree },
   { "fleetCargoMissionFree", playerL_fleetCargoMissionFree },
   { "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 },
   { "gameover", playerL_gameover },
   { "start", playerL_start },
   { 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 )
{
   PLAYER_CHECK();
 
   credits_t   money;
   int         nohooks;
   const char *reason;
 
   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 ) {
      HookParam p[3];
      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 )
{
   credits_t creds = ( player.p == NULL ) ? 0 : player.p->credits;
 
   /* Parse parameters. */
   int decimals = luaL_optinteger( L, 1, -1 );
 
   /* Push return. */
   lua_pushnumber( L, creds );
   if ( decimals >= 0 ) {
      char buf[ECON_CRED_STRLEN];
      credits2str( buf, creds, decimals );
      lua_pushstring( L, buf );
      return 2;
   }
   return 1;
}

static int playerL_wealth( lua_State *L )
{
   credits_t wealth;
   /* Parse parameters. */
   int decimals = luaL_optinteger( L, 1, -1 );
 
   if ( player.p != NULL ) {
      const PlayerShip_t   *ps = player_getShipStack();
      const PlayerOutfit_t *po = player_getOutfits();
      wealth                   = player.p->credits + pilot_worth( player.p, 0 );
 
      /* Compute total wealth. */
      for ( int i = 0; i < array_size( ps ); i++ )
         wealth += pilot_worth( ps[i].p, 0 );
      for ( int i = 0; i < array_size( po ); i++ )
         wealth += po[i].q * po[i].o->price;
   } else
      wealth = 0;
 
   /* 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 < DOUBLE_TOL )
      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 < DOUBLE_TOL )
      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 )
{
   PLAYER_CHECK();
   unsigned int b;
   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 )
{
   if ( player.p == NULL )
      lua_pushnumber( L, 0 );
   else
      lua_pushnumber( L, pilot_getJumps( player.p ) );
   return 1;
}

static int playerL_fuel( lua_State *L )
{
   if ( player.p == NULL ) {
      lua_pushnumber( L, 0 );
      lua_pushnumber( L, 0 );
   } else {
      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 ) );
   lua_pushnumber( L, player.speed_autonav );
   return 2;
}

static int playerL_autonavSetSpeed( lua_State *L )
{
   double speed = luaL_optnumber( L, 1, -1 );
   double sound = luaL_optnumber( L, 2, speed );
 
   if ( speed > 0. ) {
      pause_setSpeed( speed * conf.game_speed );
      sound_setSpeed( sound );
      player.speed_autonav = speed;
   } else {
      player_resetSpeed();
   }
 
   return 0;
}

static int playerL_autonavSetTarget( lua_State *L )
{
   PLAYER_CHECK();
   const StarSystem *sys = luaL_validsystem( L, 1 );
   if ( pilot_isFlag( player.p, PILOT_HYP_PREP ) ||
        pilot_isFlag( player.p, PILOT_HYP_BEGIN ) ||
        pilot_isFlag( player.p, PILOT_HYPERSPACE ) ) {
      WARN( _( "Unable to set autonav target while jumping!" ) );
      return 0;
   }
   map_select( sys, lua_toboolean( L, 2 ) );
   return 0;
}

static int playerL_autonavSetPos( lua_State *L )
{
   PLAYER_CHECK();
   const vec2 *pos = luaL_optvector( L, 1, NULL );
   if ( pos == NULL )
      ovr_autonavClear();
   else
      ovr_autonavPos( pos->x, pos->y );
   return 0;
}

static int playerL_autonavDest( lua_State *L )
{
   PLAYER_CHECK();
   LuaSystem         ls;
   const 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_autonavRoute( lua_State *L )
{
   PLAYER_CHECK();
   StarSystem *const *path = map_getRoute();
   lua_newtable( L );
   for ( int i = 0; i < array_size( path ); i++ ) {
      LuaSystem ls = system_index( path[i] );
      lua_pushsystem( L, ls );
      lua_rawseti( L, -2, i + 1 );
   }
   return 1;
}

static int playerL_autonavAbort( lua_State *L )
{
   PLAYER_CHECK();
   const char *str = luaL_optstring( L, 1, NULL );
   player_autonavAbort( str );
   return 0;
}

static int playerL_autonavReset( lua_State *L )
{
   PLAYER_CHECK();
   double timer = luaL_optnumber( L, 1, 0. );
   player_autonavReset( timer );
   return 0;
}

static int playerL_autonavEnd( lua_State *L )
{
   PLAYER_CHECK();
   (void)L;
   player_autonavEnd();
   return 0;
}

static int playerL_dt_default( lua_State *L )
{
   lua_pushnumber( L, player_dt_default() );
   return 1;
}

static int playerL_speed( lua_State *L )
{
   lua_pushnumber( L, player.speed / conf.game_speed );
   return 1;
}

static int playerL_setSpeed( lua_State *L )
{
   double speed = luaL_optnumber( L, 1, -1 );
   double sound = luaL_optnumber( L, 2, speed );
 
   if ( speed > 0. ) {
      player.speed = speed * conf.game_speed * player.speed_autonav;
      pause_setSpeed( player.speed );
      sound_setSpeed( sound );
   } else {
      player.speed = conf.game_speed * player.speed_autonav;
      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 ) )
         return NLUA_ERROR( L, _( "Second parameter to cinematics should be a "
                                  "table of options or omitted!" ) );
 
      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_cinematicsCheck( lua_State *L )
{
   lua_pushboolean( L, player_isFlag( PLAYER_CINEMATICS ) );
   return 1;
}

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_tryBoard( lua_State *L )
{
   int ret = player_tryBoard( lua_toboolean( L, 1 ) );
   switch ( ret ) {
   case PLAYER_BOARD_IMPOSSIBLE:
      lua_pushstring( L, "impossible" );
      break;
   case PLAYER_BOARD_RETRY:
      lua_pushstring( L, "retry" );
      break;
   case PLAYER_BOARD_OK:
      lua_pushstring( L, "ok" );
      break;
   default:
      lua_pushstring( L, "error" );
      break;
   }
   return 1;
}

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 )
{
   PLAYER_CHECK();
 
   if ( !landed )
      return NLUA_ERROR( L, _( "Player must be landed to force takeoff." ) );
   if ( !pilot_isSpaceworthy( player.p ) )
      return NLUA_ERROR( L,
                         _( "Player must be spaceworthy to force takeoff!" ) );
 
   land_queueTakeoff();
 
   return 0;
}

static int playerL_tryLand( lua_State *L )
{
   int ret = player_land( lua_toboolean( L, 1 ) );
   switch ( ret ) {
   case PLAYER_LAND_DENIED:
      lua_pushstring( L, "impossible" );
      break;
   case PLAYER_LAND_OK:
      lua_pushstring( L, "ok" );
      break;
   case PLAYER_LAND_AGAIN:
      lua_pushstring( L, "retry" );
      break;
   default:
      lua_pushstring( L, "error" );
      break;
   }
   return 1;
}

static int playerL_land( lua_State *L )
{
   PLAYER_CHECK();
 
   Spob       *spob    = luaL_validspob( L, 1 );
   const char *sysname = spob_getSystemName( spob->name );
   if ( sysname == NULL )
      return NLUA_ERROR( L, _( "Spob '%s' is not in a system!" ), spob->name );
 
   /* Unboard just in case. */
   board_unboard();
 
   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. */
 
   /* End autonav. */
   player_autonavEnd();
 
   /* Stop afterburning. */
   pilot_afterburnOver( player.p );
   /* Stop accelerating. */
   player_accelOver();
   /* Stop stealth. */
   pilot_destealth( player.p );
 
   /* Stop all on outfits. */
   if ( pilot_outfitOffAll( player.p ) > 0 )
      pilot_calcStats( player.p );
 
   /* 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 ) ) {
         NLUA_WARN( L, _( "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_landAllow( 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 )
      return NLUA_ERROR( L,
                         _( "Must be landed to set the active land window." ) );
 
   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, 1 );
 
   /* Sets the window. */
   ret = land_setWindow( win );
 
   lua_pushboolean( L, !ret );
   return 1;
}

static int playerL_commOpen( lua_State *L )
{
   if ( lua_ispilot( L, 1 ) ) {
      const Pilot *p   = luaL_validpilot( L, 1 );
      int          ret = comm_openPilot( p->id );
      lua_pushboolean( L, ret == 0 );
      return 1;
   } else if ( lua_isspob( L, 1 ) ) {
      Spob *spb = luaL_validspob( L, 1 );
      int   ret = comm_openSpob( spb );
      lua_pushboolean( L, ret == 0 );
      return 1;
   } else
      NLUA_INVALID_PARAMETER( L, 1 );
   return 0;
}

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 )
{
   PLAYER_CHECK();
   const char   *str = luaL_checkstring( L, 1 );
   PlayerShip_t *ps  = playerL_shipvarShip( L, 2 );
   const 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 )
{
   PLAYER_CHECK();
   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 )
{
   PLAYER_CHECK();
   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 )
{
   if ( player.p == NULL ) {
      lua_newtable( L );
      return 1;
   }
 
   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 )
{
   if ( player.p == NULL ) {
      lua_newtable( L );
      return 1;
   }
 
   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 )
      return NLUA_ERROR( L, _( "Player does not own a ship named '%s'" ), str );
 
   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 )
      return NLUA_ERROR( L, _( "Player does not own a ship named '%s'" ), str );
 
   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 )
{
   PLAYER_CHECK();
   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 )
{
   if ( player.p == NULL ) {
      lua_newtable( L );
      return 1;
   }
 
   const PlayerOutfit_t *outfits         = player_getOutfits();
   int                   unequipped_only = lua_toboolean( L, 1 );
   const PlayerShip_t   *pstack          = player_getShipStack();
   int                   n               = 1;
   /* Set up and get owned outfits. */
   lua_newtable( L );
   for ( int i = 0; i < array_size( outfits ); i++ ) {
      lua_pushoutfit( L, outfits[i].o );
      lua_rawseti( L, -2, n++ );
   }
   /* Add all outfits on player ships. */
   if ( !unequipped_only ) {
      for ( int i = 0; i < array_size( pstack ); i++ ) {
         for ( int j = 0; j < array_size( pstack[i].p->outfits ); j++ ) {
            const Outfit *o     = pstack[i].p->outfits[j]->outfit;
            int           found = 0;
            for ( int k = 0; k < array_size( outfits ); k++ ) {
               if ( outfits[k].o == o ) {
                  found = 1;
                  break;
               }
            }
            if ( found ) {
               lua_pushoutfit( L, o );
               lua_rawseti( L, -2, n++ );
            }
         }
      }
   }
   return 1;
}

static int playerL_outfitNum( lua_State *L )
{
   if ( player.p == NULL ) {
      lua_pushnumber( L, 0. );
      return 1;
   }
 
   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 )
{
   PLAYER_CHECK();
 
   /* 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 )
{
   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 )
{
   if ( player.p == NULL ) {
      lua_newtable( L );
      return 1;
   }
   int j = 1;
   lua_newtable( L );
   for ( int i = 0; i < array_size( player_missions ); i++ ) {
      const Mission     *pm = player_missions[i];
      const MissionData *md = pm->data;
      if ( pm->id == 0 )
         continue;
 
      misn_pushMissionData( L, md );
      /* Add player mission-specific data. */
      if ( pm->title != NULL ) {
         lua_pushstring( L, pm->title );
         lua_setfield( L, -2, "title" );
      }
      if ( pm->desc != NULL ) {
         lua_pushstring( L, pm->desc );
         lua_setfield( L, -2, "desc" );
      }
      if ( pm->reward != NULL ) {
         lua_pushstring( L, pm->reward );
         lua_setfield( L, -2, "reward" );
      }
      lua_pushinteger( L, md->avail.chance );
      lua_setfield( L, -2, "chance" );
      lua_pushinteger( L, md->avail.priority );
      lua_setfield( L, -2, "priority" );
      if ( md->avail.chapter != NULL ) {
         lua_pushstring( L, md->avail.chapter );
         lua_setfield( L, -2, "chapter" );
      }
      if ( md->avail.cond != NULL ) {
         lua_pushstring( L, md->avail.cond );
         lua_setfield( L, -2, "cond" );
      }
      if ( md->avail.done != NULL ) {
         lua_pushstring( L, md->avail.done );
         lua_setfield( L, -2, "done" );
      }
      if ( md->avail.spob != NULL ) {
         lua_pushstring( L, md->avail.spob );
         lua_setfield( L, -2, "spob" );
      }
      if ( md->avail.system != NULL ) {
         lua_pushstring( L, md->avail.system );
         lua_setfield( L, -2, "system" );
      }
      if ( mis_isFlag( md, MISSION_UNIQUE ) ) {
         lua_pushboolean( L, 1 );
         lua_setfield( L, -2, "unique" );
      }
      /* Tags. */
      lua_newtable( L );
      for ( int k = 0; k < array_size( md->tags ); k++ ) {
         lua_pushboolean( L, 1 );
         lua_setfield( L, -2, md->tags[k] );
      }
      lua_setfield( L, -2, "tags" );
      lua_rawseti( L, -2, j++ );
   }
   return 1;
}

static int playerL_misnActive( lua_State *L )
{
   PLAYER_CHECK();
   const char        *str  = luaL_checkstring( L, 1 );
   const MissionData *misn = mission_getFromName( str );
   if ( misn == NULL )
      return NLUA_ERROR( L, _( "Mission '%s' not found in stack" ), str );
   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 )
{
   PLAYER_CHECK();
   const char *str = luaL_checkstring( L, 1 );
   int         id  = mission_getID( str );
   if ( id == -1 )
      return NLUA_ERROR( L, _( "Mission '%s' not found in stack" ), str );
   lua_pushboolean( L, player_missionAlreadyDone( id ) );
   return 1;
}

static int playerL_misnDoneList( lua_State *L )
{
   if ( player.p == NULL ) {
      lua_newtable( L );
      return 1;
   }
   const 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 )
{
   PLAYER_CHECK();
   const char *str   = luaL_checkstring( L, 1 );
   int         evtid = event_dataID( str );
   if ( evtid < 0 )
      return NLUA_ERROR( L, _( "Event '%s' not found in stack" ), str );
   lua_pushboolean( L, event_alreadyRunning( evtid ) );
   return 1;
}

static int playerL_evtDone( lua_State *L )
{
   PLAYER_CHECK();
   const char *str = luaL_checkstring( L, 1 );
   int         id  = event_dataID( str );
   if ( id == -1 )
      return NLUA_ERROR( L, _( "Event '%s' not found in stack" ), str );
   lua_pushboolean( L, player_eventAlreadyDone( id ) );
   return 1;
}

static int playerL_evtDoneList( lua_State *L )
{
   if ( player.p == NULL ) {
      lua_newtable( L );
      return 1;
   }
   const int *done = player_eventsDoneList();
   lua_newtable( L );
   for ( int i = 0; i < array_size( done ); i++ ) {
      event_toLuaTable( L, done[i] );
      lua_rawseti( L, -2, i + 1 );
   }
   return 1;
}

static int playerL_gui( lua_State *L )
{
   lua_pushstring( L, gui_pick() );
   return 1;
}

static int playerL_guiList( lua_State *L )
{
   const char **gui = player_guiList();
 
   lua_newtable( L );
   for ( int i = 0; i < array_size( gui ); i++ ) {
      lua_pushstring( L, gui[i] );
      lua_rawseti( L, -2, i + 1 );
   }
 
   return 1;
}

static int playerL_guiSet( lua_State *L )
{
   const char *name = luaL_checkstring( L, 1 );
   if ( !gui_exists( name ) )
      return NLUA_ERROR( L, _( "GUI '%s' does not exist!" ), name );
   free( player.gui );
   player.gui = strdup( name );
   gui_load( gui_pick() );
   return 0;
}

static int playerL_fleetList( lua_State *L )
{
   if ( player.p == NULL ) {
      lua_newtable( L );
      return 1;
   }
   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 )
{
   if ( player.p == NULL )
      lua_pushinteger( L, 0 );
   else
      lua_pushinteger( L, pfleet_cargoFree() );
   return 1;
}

static int playerL_fleetCargoMissionFree( lua_State *L )
{
   if ( player.p == NULL ) {
      lua_pushinteger( L, 0 );
      return 0;
   }
   lua_pushinteger( L, pfleet_cargoMissionFree() );
   return 1;
}

static int playerL_fleetCargoUsed( lua_State *L )
{
   if ( player.p == NULL )
      lua_pushinteger( L, 0 );
   else
      lua_pushinteger( L, pfleet_cargoUsed() );
   return 1;
}

static int playerL_fleetCargoOwned( lua_State *L )
{
   const Commodity *c = luaL_validcommodity( L, 1 );
   if ( player.p == NULL )
      lua_pushinteger( L, 0 );
   else
      lua_pushinteger( L, pfleet_cargoOwned( c ) );
   return 1;
}

static int playerL_fleetCargoAdd( lua_State *L )
{
   const Commodity *c = luaL_validcommodity( L, 1 );
   int              q = luaL_checkinteger( L, 2 );
   if ( player.p == NULL )
      lua_pushinteger( L, 0 );
   else
      lua_pushinteger( L, pfleet_cargoAdd( c, q ) );
   return 1;
}

static int playerL_fleetCargoRm( lua_State *L )
{
   const Commodity *c = luaL_validcommodity( L, 1 );
   int              q = luaL_checkinteger( L, 2 );
   if ( player.p == NULL )
      lua_pushinteger( L, 0 );
   else
      lua_pushinteger( L, pfleet_cargoRm( c, q, 0 ) );
   return 1;
}

static int playerL_fleetCargoJet( lua_State *L )
{
   const Commodity *c = luaL_validcommodity( L, 1 );
   int              q = luaL_checkinteger( L, 2 );
   if ( player.p == NULL )
      lua_pushinteger( L, 0 );
   else
      lua_pushinteger( L, pfleet_cargoRm( c, q, 1 ) );
   return 1;
}

static int playerL_fleetCargoList( lua_State *L )
{
   if ( player.p == NULL ) {
      lua_newtable( L );
      return 1;
   }
   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 )
{
   if ( player.p == NULL ) {
      lua_newtable( L );
      return 1;
   }
   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 );
   if ( player.p == NULL )
      lua_pushinteger( L, 0 );
   else
      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 );
   if ( player.p == NULL )
      lua_pushinteger( L, 0 );
   else
      lua_pushinteger( L, player_inventoryRemove( name, q ) );
   return 1;
}

static int playerL_inventoryOwned( lua_State *L )
{
   const char *name = luaL_checkstring( L, 1 );
   if ( player.p == NULL )
      lua_pushinteger( L, 0 );
   else
      lua_pushinteger( L, player_inventoryAmount( name ) );
   return 1;
}

static int playerL_teleport( lua_State *L )
{
   PLAYER_CHECK();
   Spob       *pnt;
   const char *name, *pntname;
   int         no_simulate, silent;
 
   /* Must not be landed. */
   if ( landed )
      return NLUA_ERROR( L, _( "Can not teleport the player while landed!" ) );
   if ( comm_isOpen() )
      return NLUA_ERROR(
         L, _( "Can not teleport the player while the comm is open!" ) );
   if ( player_isBoarded() )
      return NLUA_ERROR(
         L, _( "Can not teleport the player while they are boarded!" ) );
   pnt = NULL;
 
   pilot_rmFlag( player.p, PILOT_LANDING );
 
   /* Get a system. */
   if ( lua_issystem( L, 1 ) ) {
      const 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_getSystemName( pnt->name );
      if ( name == NULL )
         return NLUA_ERROR( L, _( "Spob '%s' does not belong to a system." ),
                            pnt->name );
   }
   /* 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_getSystemName( pntname );
         pnt     = spob_get( pntname );
         if ( pnt == NULL )
            return NLUA_ERROR(
               L, _( "'%s' is not a valid teleportation target." ), name );
 
         if ( name == NULL )
            return NLUA_ERROR( L, _( "Spob '%s' does not belong to a system." ),
                               pntname );
      } else
         name = sysname;
   } else
      NLUA_INVALID_PARAMETER( L, 1 );
 
   no_simulate = lua_toboolean( L, 2 );
   silent      = lua_toboolean( L, 3 );
 
   /* Check if system exists. */
   if ( system_get( name ) == NULL )
      return NLUA_ERROR( L, _( "System '%s' does not exist." ), name );
 
   /* Unboard just in case. */
   board_unboard();
 
   /* 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();
   cam_vel( 0., 0. );
 
   /* 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 )
{
   PLAYER_CHECK();
   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_CHECK();
   player.fleet_capacity = luaL_checkinteger( L, 1 );
   return 0;
}

static int playerL_chapter( lua_State *L )
{
   PLAYER_CHECK();
   lua_pushstring( L, player.chapter );
   return 1;
}

static int playerL_chapterSet( lua_State *L )
{
   PLAYER_CHECK();
   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 )
      NLUA_WARN( L, _( "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 = NULL;
   if ( !lua_isnoneornil( L, 2 ) )
      savespob = luaL_validspob( L, 2 );
 
   if ( !landed && ( savespob == NULL ) )
      return NLUA_ERROR( L, _( "Unable to save when not landed and land spob "
                               "is not specified!" ) );
   else if ( landed && ( savespob != NULL ) )
      return 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 )
      return 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;
}

static int playerL_gameover( lua_State *L )
{
   (void)L;
   player_setFlag( PLAYER_DESTROYED );
   menu_death();
   return 0;
}

static int playerL_start( lua_State *L )
{
   double x, y;
   vec2   v;
   lua_newtable( L );
 
   lua_pushstring( L, start_name() );
   lua_setfield( L, -2, "name" );
 
   lua_pushship( L, ship_get( start_ship() ) );
   lua_setfield( L, -2, "ship" );
 
   lua_pushstring( L, start_shipname() );
   lua_setfield( L, -2, "shipname" );
 
   lua_pushstring( L, start_acquired() );
   lua_setfield( L, -2, "acquired" );
 
   lua_pushstring( L, start_gui() );
   lua_setfield( L, -2, "gui" );
 
   lua_pushinteger( L, start_credits() );
   lua_setfield( L, -2, "credits" );
 
   lua_pushtime( L, start_date() );
   lua_setfield( L, -2, "date" );
 
   lua_pushsystem( L, system_index( system_get( start_system() ) ) );
   lua_setfield( L, -2, "system" );
 
   start_position( &x, &y );
   vec2_cset( &v, x, y );
   lua_pushvector( L, v );
   lua_setfield( L, -2, "position" );
 
   if ( start_mission() != NULL ) {
      lua_pushstring( L, start_mission() );
      lua_setfield( L, -2, "mission" );
   }
 
   if ( start_event() != NULL ) {
      lua_pushstring( L, start_event() );
      lua_setfield( L, -2, "event" );
   }
 
   lua_pushstring( L, start_chapter() );
   lua_setfield( L, -2, "chapter" );
 
   lua_pushstring( L, start_spob_lua_default() );
   lua_setfield( L, -2, "spob_lua_default" );
 
   lua_pushstring( L, start_dtype_default() );
   lua_setfield( L, -2, "dtype_default" );
 
   return 1;
}