nlua_system.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <lauxlib.h>
 
#include "nlua_system.h"
 
#include "array.h"
#include "gatherable.h"
#include "land_outfits.h"
#include "map.h"
#include "map_overlay.h"
#include "nlua_commodity.h"
#include "nlua_faction.h"
#include "nlua_jump.h"
#include "nlua_spob.h"
#include "nlua_vec2.h"
#include "nluadef.h"
#include "space.h"
 
/* System metatable methods */
static int systemL_cur( lua_State *L );
static int systemL_get( lua_State *L );
static int systemL_getAll( lua_State *L );
static int systemL_eq( lua_State *L );
static int systemL_name( lua_State *L );
static int systemL_nameRaw( lua_State *L );
static int systemL_position( lua_State *L );
static int systemL_faction( lua_State *L );
static int systemL_background( lua_State *L );
static int systemL_nebula( lua_State *L );
static int systemL_interference( lua_State *L );
static int systemL_jumpdistance( lua_State *L );
static int systemL_jumpPath( lua_State *L );
static int systemL_adjacent( lua_State *L );
static int systemL_jumps( lua_State *L );
static int systemL_asteroidFields( lua_State *L );
static int systemL_addGatherable( lua_State *L );
static int systemL_presences( lua_State *L );
static int systemL_spobs( lua_State *L );
static int systemL_presence( lua_State *L );
static int systemL_radius( lua_State *L );
static int systemL_isknown( lua_State *L );
static int systemL_setknown( lua_State *L );
static int systemL_hidden( lua_State *L );
static int systemL_setHidden( lua_State *L );
static int systemL_markerClear( lua_State *L );
static int systemL_markerAdd( lua_State *L );
static int systemL_markerRm( lua_State *L );
static int systemL_reputation( lua_State *L );
static int systemL_setReputation( lua_State *L );
static int systemL_tags( lua_State *L );
 
static const luaL_Reg system_methods[] = {
   { "cur", systemL_cur },
   { "get", systemL_get },
   { "getAll", systemL_getAll },
   { "__eq", systemL_eq },
   { "__tostring", systemL_name },
   { "name", systemL_name },
   { "nameRaw", systemL_nameRaw },
   { "pos", systemL_position },
   { "faction", systemL_faction },
   { "background", systemL_background },
   { "nebula", systemL_nebula },
   { "interference", systemL_interference },
   { "jumpDist", systemL_jumpdistance },
   { "jumpPath", systemL_jumpPath },
   { "adjacentSystems", systemL_adjacent },
   { "jumps", systemL_jumps },
   { "asteroidFields", systemL_asteroidFields },
   { "addGatherable", systemL_addGatherable },
   { "presences", systemL_presences },
   { "spobs", systemL_spobs },
   { "presence", systemL_presence },
   { "radius", systemL_radius },
   { "known", systemL_isknown },
   { "setKnown", systemL_setknown },
   { "hidden", systemL_hidden },
   { "setHidden", systemL_setHidden },
   { "markerClear", systemL_markerClear },
   { "markerAdd", systemL_markerAdd },
   { "markerRm", systemL_markerRm },
   { "reputation", systemL_reputation },
   { "setReputation", systemL_setReputation },
   { "tags", systemL_tags },
   { 0, 0 } }; 

int nlua_loadSystem( nlua_env env )
{
   nlua_register( env, SYSTEM_METATABLE, system_methods, 1 );
   return 0; /* No error */
}

LuaSystem lua_tosystem( lua_State *L, int ind )
{
   return *( (LuaSystem *)lua_touserdata( L, ind ) );
}

LuaSystem luaL_checksystem( lua_State *L, int ind )
{
   if ( lua_issystem( L, ind ) )
      return lua_tosystem( L, ind );
   luaL_typerror( L, ind, SYSTEM_METATABLE );
   return 0;
}

StarSystem *luaL_validsystem( lua_State *L, int ind )
{
   StarSystem *s;
 
   if ( lua_issystem( L, ind ) ) {
      LuaSystem ls = luaL_checksystem( L, ind );
      s            = system_getIndex( ls );
   } else if ( lua_isstring( L, ind ) )
      s = system_get( lua_tostring( L, ind ) );
   else {
      luaL_typerror( L, ind, SYSTEM_METATABLE );
      return NULL;
   }
 
   if ( s == NULL )
      NLUA_ERROR( L, _( "System is invalid" ) );
 
   return s;
}

LuaSystem *lua_pushsystem( lua_State *L, LuaSystem sys )
{
   LuaSystem *s = (LuaSystem *)lua_newuserdata( L, sizeof( LuaSystem ) );
   *s           = sys;
   luaL_getmetatable( L, SYSTEM_METATABLE );
   lua_setmetatable( L, -2 );
   return s;
}

int lua_issystem( lua_State *L, int ind )
{
   int ret;
 
   if ( lua_getmetatable( L, ind ) == 0 )
      return 0;
   lua_getfield( L, LUA_REGISTRYINDEX, SYSTEM_METATABLE );
 
   ret = 0;
   if ( lua_rawequal( L, -1, -2 ) ) /* does it have the correct mt? */
      ret = 1;
 
   lua_pop( L, 2 ); /* remove both metatables */
   return ret;
}

static int systemL_cur( lua_State *L )
{
   lua_pushsystem( L, system_index( cur_system ) );
   return 1;
}

static int systemL_get( lua_State *L )
{
   StarSystem *ss;
   Spob       *pnt;
 
   /* Passing a string (systemname) */
   if ( lua_isstring( L, 1 ) ) {
      ss = system_get( lua_tostring( L, 1 ) );
   }
   /* Passing a spob */
   else if ( lua_isspob( L, 1 ) ) {
      pnt = luaL_validspob( L, 1 );
      ss  = system_get( spob_getSystemName( pnt->name ) );
   } else if ( lua_issystem( L, 1 ) ) {
      lua_pushvalue( L, 1 );
      return 1;
   } else
      NLUA_INVALID_PARAMETER( L, 1 );
 
   /* Error checking. */
   if ( ss == NULL )
      return NLUA_ERROR( L, _( "No matching systems found." ) );
 
   /* return the system */
   lua_pushsystem( L, system_index( ss ) );
   return 1;
}

static int systemL_getAll( lua_State *L )
{
   StarSystem *sys = system_getAll();
   lua_newtable( L );
   for ( int i = 0; i < array_size( sys ); i++ ) {
      lua_pushsystem( L, system_index( &sys[i] ) );
      lua_rawseti( L, -2, i + 1 );
   }
   return 1;
}

static int systemL_eq( lua_State *L )
{
   LuaSystem a, b;
   a = luaL_checksystem( L, 1 );
   b = luaL_checksystem( L, 2 );
   if ( a == b )
      lua_pushboolean( L, 1 );
   else
      lua_pushboolean( L, 0 );
   return 1;
}

static int systemL_name( lua_State *L )
{
   const StarSystem *sys = luaL_validsystem( L, 1 );
   lua_pushstring( L, system_name( sys ) );
   return 1;
}

static int systemL_position( lua_State *L )
{
   const StarSystem *sys = luaL_validsystem( L, 1 );
   lua_pushvector( L, sys->pos );
   return 1;
}

static int systemL_nameRaw( lua_State *L )
{
   StarSystem *sys = luaL_validsystem( L, 1 );
   lua_pushstring( L, sys->name );
   return 1;
}

static int systemL_faction( lua_State *L )
{
   const StarSystem *s = luaL_validsystem( L, 1 );
   if ( s->faction == -1 )
      return 0;
   lua_pushfaction( L, s->faction );
   return 1;
}

static int systemL_background( lua_State *L )
{
   StarSystem *s = luaL_validsystem( L, 1 );
   if ( s->background == NULL )
      return 0;
   lua_pushstring( L, s->background );
   return 1;
}

static int systemL_nebula( lua_State *L )
{
   StarSystem *s = luaL_validsystem( L, 1 );
   /* Push the density and volatility. */
   lua_pushnumber( L, s->nebu_density );
   lua_pushnumber( L, s->nebu_volatility );
   return 2;
}

static int systemL_interference( lua_State *L )
{
   StarSystem *s = luaL_validsystem( L, 1 );
   lua_pushnumber( L, s->interference );
   return 1;
}

static int systemL_jumpdistance( lua_State *L )
{
   StarSystem  *sys;
   StarSystem **s;
   StarSystem  *start, *goal;
   int          h, k;
 
   sys = luaL_validsystem( L, 1 );
   h   = lua_toboolean( L, 3 );
   k   = !lua_toboolean( L, 4 );
 
   if ( !lua_isnoneornil( L, 2 ) ) {
      goal  = luaL_validsystem( L, 2 );
      start = sys;
   } else {
      goal  = sys;
      start = cur_system;
   }
 
   /* Trivial case same system. */
   if ( start->id == goal->id ) {
      lua_pushnumber( L, 0. );
      return 1;
   }
 
   s = map_getJumpPath( start, NULL, goal, k, h, NULL, NULL );
   if ( s == NULL ) {
      lua_pushnumber( L, HUGE_VAL );
      return 1;
   }
 
   lua_pushnumber( L, array_size( s ) );
   array_free( s );
   return 1;
}

static int systemL_jumpPath( lua_State *L )
{
   LuaJump      lj;
   StarSystem  *sys, *sysp;
   StarSystem **s;
   int          sid, pushed, h;
 
   h = lua_toboolean( L, 3 );
 
   /* Foo to Bar */
   sys  = luaL_validsystem( L, 1 );
   sid  = sys->id;
   sysp = luaL_validsystem( L, 2 );
 
   s = map_getJumpPath( sys, NULL, sysp, 1, h, NULL, NULL );
   if ( s == NULL )
      return 0;
 
   /* Create the jump table. */
   lua_newtable( L );
   pushed = 0;
 
   /* Map path doesn't contain the start system, push it manually. */
   lj.srcid  = sid;
   lj.destid = s[0]->id;
 
   lua_pushjump( L, lj ); /* value. */
   lua_rawseti( L, -2, ++pushed );
 
   for ( int i = 0; i < array_size( s ) - 1; i++ ) {
      lj.srcid  = s[i]->id;
      lj.destid = s[i + 1]->id;
 
      lua_pushjump( L, lj ); /* value. */
      lua_rawseti( L, -2, ++pushed );
   }
   array_free( s );
 
   return 1;
}

static int systemL_adjacent( lua_State *L )
{
   int         id, h;
   StarSystem *s;
 
   id = 1;
   s  = luaL_validsystem( L, 1 );
   h  = lua_toboolean( L, 2 );
 
   /* Push all adjacent systems. */
   lua_newtable( L );
   for ( int i = 0; i < array_size( s->jumps ); i++ ) {
      LuaSystem sysp;
      if ( jp_isFlag( &s->jumps[i], JP_EXITONLY ) )
         continue;
      if ( !h && jp_isFlag( &s->jumps[i], JP_HIDDEN ) )
         continue;
      sysp = system_index( s->jumps[i].target );
      lua_pushsystem( L, sysp ); /* value. */
      lua_rawseti( L, -2, id++ );
   }
 
   return 1;
}

static int systemL_jumps( lua_State *L )
{
   StarSystem *s        = luaL_validsystem( L, 1 );
   int         exitonly = lua_toboolean( L, 2 );
   int         pushed   = 0;
 
   /* Push all jumps. */
   lua_newtable( L );
   for ( int i = 0; i < array_size( s->jumps ); i++ ) {
      LuaJump lj;
      /* Skip exit-only jumps if requested. */
      if ( ( exitonly ) && ( jp_isFlag( &s->jumps[i], JP_EXITONLY ) ) )
         continue;
 
      lj.srcid  = s->id;
      lj.destid = s->jumps[i].targetid;
      lua_pushjump( L, lj ); /* value. */
      lua_rawseti( L, -2, ++pushed );
   }
 
   return 1;
}

static int systemL_asteroidFields( lua_State *L )
{
   StarSystem *s = luaL_validsystem( L, 1 );
   /* Push all jumps. */
   lua_newtable( L );
   for ( int i = 0; i < array_size( s->asteroids ); i++ ) {
      lua_newtable( L );
 
      lua_pushinteger( L, i + 1 );
      lua_setfield( L, -2, "id" );
 
      lua_pushvector( L, s->asteroids[i].pos );
      lua_setfield( L, -2, "pos" );
 
      lua_pushnumber( L, s->asteroids[i].density );
      lua_setfield( L, -2, "density" );
 
      lua_pushnumber( L, s->asteroids[i].radius );
      lua_setfield( L, -2, "radius" );
 
      lua_rawseti( L, -2, i + 1 );
   }
   return 1;
}

static int systemL_addGatherable( lua_State *L )
{
   int          nb;
   unsigned int player_only;
   Commodity   *commodity;
   vec2        *pos, *vel;
   vec2         zero = { .x = 0., .y = 0., .mod = 0., .angle = 0. };
   double       lifelength;
 
   /* Handle parameters. */
   commodity  = luaL_validcommodity( L, 1 );
   nb         = luaL_checkint( L, 2 );
   pos        = luaL_optvector( L, 3, &zero );
   vel        = luaL_optvector( L, 4, &zero );
   lifelength = luaL_optnumber( L, 5, -1. ); /* -1. means random life length. */
   player_only = lua_toboolean( L, 6 );
 
   lua_pushnumber(
      L, gatherable_init( commodity, pos, vel, lifelength, nb, player_only ) );
   return 1;
}

static int systemL_presences( lua_State *L )
{
   StarSystem *s = luaL_validsystem( L, 1 );
   /* Return result in table */
   lua_newtable( L );
   for ( int i = 0; i < array_size( s->presence ); i++ ) {
      /* Only return positive presences. */
      if ( s->presence[i].value <= 0 )
         continue;
 
      lua_pushstring( L, faction_name( s->presence[i].faction ) ); /* t, k */
      lua_pushnumber( L, s->presence[i].value );                   /* t, k, v */
      lua_settable( L, -3 );                                       /* t */
      /* allows syntax foo = system.presences(); if foo["bar"] then ... end */
   }
   return 1;
}

static int systemL_spobs( lua_State *L )
{
   const StarSystem *s = luaL_validsystem( L, 1 );
   /* Push all spobs. */
   lua_newtable( L );
   for ( int i = 0; i < array_size( s->spobs ); i++ ) {
      lua_pushspob( L, spob_index( s->spobs[i] ) ); /* value */
      lua_rawseti( L, -2, i + 1 );
   }
   return 1;
}

static int systemL_presence( lua_State *L )
{
   StarSystem *sys;
   int        *fct;
   double      presence;
   int         used;
 
   /* Get parameters. */
   sys = luaL_validsystem( L, 1 );
 
   /* Allow fall-through. */
   used = 0;
   fct  = NULL;
 
   /* Get the second parameter. */
   if ( lua_isstring( L, 2 ) ) {
      /* A string command has been given. */
      const char *cmd = lua_tostring( L, 2 );
      used            = 1;
 
      /* Check the command string and get the appropriate faction group.*/
      if ( strcmp( cmd, "all" ) == 0 )
         fct = faction_getGroup( 0 );
      else if ( strcmp( cmd, "friendly" ) == 0 )
         fct = faction_getGroup( 1 );
      else if ( strcmp( cmd, "hostile" ) == 0 )
         fct = faction_getGroup( 3 );
      else if ( strcmp( cmd, "neutral" ) == 0 )
         fct = faction_getGroup( 2 );
      else /* Invalid command string. */
         used = 0;
   }
 
   if ( !used ) {
      /* A faction id was given. */
      int f = luaL_validfaction( L, 2 );
      fct   = array_create( int );
      array_push_back( &fct, f );
   }
 
   /* Add up the presence values. */
   presence = 0;
   for ( int i = 0; i < array_size( fct ); i++ ) {
      /* Only count positive presences. */
      double v = system_getPresence( sys, fct[i] );
      if ( v > 0 )
         presence += v;
   }
 
   /* Clean up after ourselves. */
   array_free( fct );
 
   /* Push it back to Lua. */
   lua_pushnumber( L, presence );
   return 1;
}

static int systemL_radius( lua_State *L )
{
   StarSystem *sys = luaL_validsystem( L, 1 );
   lua_pushnumber( L, sys->radius );
   return 1;
}

static int systemL_isknown( lua_State *L )
{
   const StarSystem *sys = luaL_validsystem( L, 1 );
   lua_pushboolean( L, sys_isKnown( sys ) );
   return 1;
}

static int systemL_setknown( lua_State *L )
{
   int         b, r;
   StarSystem *sys;
 
   r   = 0;
   sys = luaL_validsystem( L, 1 );
   b   = lua_toboolean( L, 2 );
   if ( lua_gettop( L ) > 2 )
      r = lua_toboolean( L, 3 );
 
   if ( b )
      sys_setFlag( sys, SYSTEM_KNOWN );
   else
      sys_rmFlag( sys, SYSTEM_KNOWN );
 
   if ( r ) {
      if ( b ) {
         for ( int i = 0; i < array_size( sys->spobs ); i++ )
            spob_setKnown( sys->spobs[i] );
         for ( int i = 0; i < array_size( sys->jumps ); i++ )
            jp_setFlag( &sys->jumps[i], JP_KNOWN );
      } else {
         for ( int i = 0; i < array_size( sys->spobs ); i++ )
            spob_rmFlag( sys->spobs[i], SPOB_KNOWN );
         for ( int i = 0; i < array_size( sys->jumps ); i++ )
            jp_rmFlag( &sys->jumps[i], JP_KNOWN );
      }
   }
 
   /* Update outfits image array. */
   outfits_updateEquipmentOutfits();
   ovr_refresh(); /* Update overlay as necessary. */
 
   return 0;
}

static int systemL_hidden( lua_State *L )
{
   const StarSystem *sys = luaL_validsystem( L, 1 );
   lua_pushboolean( L, sys_isFlag( sys, SYSTEM_HIDDEN ) );
   return 1;
}

static int systemL_setHidden( lua_State *L )
{
   StarSystem *sys = luaL_validsystem( L, 1 );
   int         b   = lua_toboolean( L, 2 );
   if ( b )
      sys_setFlag( sys, SYSTEM_HIDDEN );
   else
      sys_rmFlag( sys, SYSTEM_HIDDEN );
   return 0;
}

static int systemL_markerClear( lua_State *L )
{
   (void)L;
   ovr_mrkClear();
   return 0;
}

static int systemL_markerAdd( lua_State *L )
{
   const char  *str;
   vec2        *vec;
   unsigned int id;
   double       r;
 
   /* Handle parameters. */
   vec = luaL_checkvector( L, 1 );
   str = luaL_optstring( L, 2, NULL );
   r   = luaL_optnumber( L, 3, -1. );
 
   /* Create marker. */
   if ( r < 0. )
      id = ovr_mrkAddPoint( str, vec->x, vec->y );
   else
      id = ovr_mrkAddCircle( str, vec->x, vec->y, r );
   lua_pushnumber( L, id );
   return 1;
}

static int systemL_markerRm( lua_State *L )
{
   unsigned int id = luaL_checklong( L, 1 );
   ovr_mrkRm( id );
   return 0;
}

static int systemL_reputation( lua_State *L )
{
   const StarSystem *sys = luaL_validsystem( L, 1 );
   if ( lua_isnoneornil( L, 2 ) ) {
      lua_newtable( L );
      for ( int i = 0; i < array_size( sys->presence ); i++ ) {
         const char *name = faction_name( sys->presence[i].faction );
         lua_pushnumber( L, sys->presence[i].local );
         lua_setfield( L, -2, name );
      }
      return 1;
   }
 
   int f = luaL_validfaction( L, 2 );
   for ( int i = 0; i < array_size( sys->presence ); i++ ) {
      if ( sys->presence[i].faction == f ) {
         lua_pushnumber( L, sys->presence[i].local );
         return 1;
      }
   }
   lua_pushnumber( L, faction_reputation( f ) );
   return 1;
}

static int systemL_setReputation( lua_State *L )
{
   StarSystem     *sys = luaL_validsystem( L, 1 );
   int             f   = luaL_validfaction( L, 2 );
   double          m   = luaL_checknumber( L, 3 );
   SystemPresence *sp  = system_getFactionPresence( sys, f );
   if ( sp != NULL )
      sp->local = m;
   faction_updateSingle( f ); /* Brute-force propagate to global. */
   return 0;
}

static int systemL_tags( lua_State *L )
{
   const StarSystem *s = luaL_validsystem( L, 1 );
   return nlua_helperTags( L, 2, s->tags );
}