nlua_system.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <lauxlib.h>
 
#include "naev.h"
#include "nlua_system.h"
 
#include "array.h"
#include "land.h"
#include "land_outfits.h"
#include "log.h"
#include "gatherable.h"
#include "map.h"
#include "map_overlay.h"
#include "nebula.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 "rng.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_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 },
   { "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_getSystem( 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, _(sys->name));
   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;
   const char *start, *goal;
   int h, k;
 
   sys = luaL_validsystem(L,1);
   start = sys->name;
   h   = lua_toboolean(L,3);
   k   = !lua_toboolean(L,4);
 
   if (lua_gettop(L) > 1) {
      if (lua_isstring(L,2))
         goal = lua_tostring(L,2);
      else if (lua_issystem(L,2)) {
         const StarSystem *sysp = luaL_validsystem(L,2);
         goal = sysp->name;
      }
      else
         NLUA_INVALID_PARAMETER(L,2);
   }
   else {
      goal  = sys->name;
      start = cur_system->name;
   }
 
   /* Trivial case same system. */
   if (strcmp(start,goal)==0) {
      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;
   const char *start, *goal;
 
   h   = lua_toboolean(L,3);
 
   /* Foo to Bar */
   sys   = luaL_validsystem(L,1);
   start = sys->name;
   sid   = sys->id;
   sysp  = luaL_validsystem(L,2);
   goal  = sysp->name;
 
   s = map_getJumpPath( start, NULL, goal, 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_tags( lua_State *L )
{
   StarSystem *s = luaL_validsystem(L,1);
   lua_newtable(L);
   for (int i=0; i<array_size(s->tags); i++) {
      lua_pushstring(L,s->tags[i]);
      lua_pushboolean(L,1);
      lua_rawset(L,-3);
   }
   return 1;
}