nlua_spob.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include "naev.h"
 
#include <lauxlib.h>
#include "nlua_spob.h"
 
#include "array.h"
#include "land.h"
#include "land_outfits.h"
#include "log.h"
#include "map.h"
#include "map_overlay.h"
#include "nlua_colour.h"
#include "nlua_commodity.h"
#include "nlua_faction.h"
#include "nlua_outfit.h"
#include "nlua_ship.h"
#include "nlua_system.h"
#include "nlua_tex.h"
#include "nlua_time.h"
#include "nlua_vec2.h"
#include "nluadef.h"
#include "nmath.h"
#include "nstring.h"
#include "rng.h"
 
/* Spob metatable methods */
static int spobL_cur( lua_State *L );
static int spobL_get( lua_State *L );
static int spobL_getS( lua_State *L );
static int spobL_getLandable( lua_State *L );
static int spobL_getAll( lua_State *L );
static int spobL_system( lua_State *L );
static int spobL_eq( lua_State *L );
static int spobL_name( lua_State *L );
static int spobL_nameRaw( lua_State *L );
static int spobL_population( lua_State *L );
static int spobL_radius( lua_State *L );
static int spobL_faction( lua_State *L );
static int spobL_colour( lua_State *L );
static int spobL_colourChar( lua_State *L );
static int spobL_class( lua_State *L );
static int spobL_classLong( lua_State *L );
static int spobL_position( lua_State *L );
static int spobL_services( lua_State *L );
static int spobL_flags( lua_State *L );
static int spobL_canland( lua_State *L );
static int spobL_landAllow( lua_State *L );
static int spobL_landDeny( lua_State *L );
static int spobL_getLandAllow( lua_State *L );
static int spobL_getLandDeny( lua_State *L );
static int spobL_gfxSpace( lua_State *L );
static int spobL_gfxExterior( lua_State *L );
static int spobL_gfxExteriorPath( lua_State *L );
static int spobL_gfxComm( lua_State *L );
static int spobL_shipsSold( lua_State *L );
static int spobL_outfitsSold( lua_State *L );
static int spobL_commoditiesSold( lua_State *L );
static int spobL_isBlackMarket( lua_State *L );
static int spobL_isKnown( lua_State *L );
static int spobL_setKnown( lua_State *L );
static int spobL_recordCommodityPriceAtTime( lua_State *L );
static int spobL_tags( lua_State *L );
static const luaL_Reg spob_methods[] = {
   { "cur", spobL_cur },
   { "get", spobL_get },
   { "getS", spobL_getS },
   { "getLandable", spobL_getLandable },
   { "getAll", spobL_getAll },
   { "system", spobL_system },
   { "__eq", spobL_eq },
   { "__tostring", spobL_name },
   { "name", spobL_name },
   { "nameRaw", spobL_nameRaw },
   { "population", spobL_population },
   { "radius", spobL_radius },
   { "faction", spobL_faction },
   { "colour", spobL_colour },
   { "colourChar", spobL_colourChar },
   { "class", spobL_class },
   { "classLong", spobL_classLong },
   { "pos", spobL_position },
   { "services", spobL_services },
   { "flags", spobL_flags },
   { "canLand", spobL_canland },
   { "landAllow", spobL_landAllow },
   { "landDeny", spobL_landDeny },
   { "getLandAllow", spobL_getLandAllow },
   { "getLandDeny", spobL_getLandDeny },
   { "gfxSpace", spobL_gfxSpace },
   { "gfxExterior", spobL_gfxExterior },
   { "gfxExteriorPath", spobL_gfxExteriorPath },
   { "gfxComm", spobL_gfxComm },
   { "shipsSold", spobL_shipsSold },
   { "outfitsSold", spobL_outfitsSold },
   { "commoditiesSold", spobL_commoditiesSold },
   { "blackmarket", spobL_isBlackMarket },
   { "known", spobL_isKnown },
   { "setKnown", spobL_setKnown },
   { "recordCommodityPriceAtTime", spobL_recordCommodityPriceAtTime },
   { "tags", spobL_tags },
   {0,0}
}; 
int nlua_loadSpob( nlua_env env )
{
   nlua_register(env, SPOB_METATABLE, spob_methods, 1);
   return 0; /* No error */
}
 
LuaSpob lua_tospob( lua_State *L, int ind )
{
   return *((LuaSpob*) lua_touserdata(L,ind));
}
LuaSpob luaL_checkspob( lua_State *L, int ind )
{
   if (lua_isspob(L,ind))
      return lua_tospob(L,ind);
   luaL_typerror(L, ind, SPOB_METATABLE);
   return 0;
}
Spob* luaL_validspob( lua_State *L, int ind )
{
   Spob *p;
 
   if (lua_isspob(L, ind)) {
      LuaSpob lp = luaL_checkspob(L, ind);
      p  = spob_getIndex(lp);
   }
   else if (lua_isstring(L, ind))
      p = spob_get( lua_tostring(L, ind) );
   else {
      luaL_typerror(L, ind, SPOB_METATABLE);
      return NULL;
   }
 
   if (p == NULL)
      NLUA_ERROR(L, _("Spob is invalid"));
 
   return p;
}
LuaSpob* lua_pushspob( lua_State *L, LuaSpob spob )
{
   LuaSpob *p = (LuaSpob*) lua_newuserdata(L, sizeof(LuaSpob));
   *p = spob;
   luaL_getmetatable(L, SPOB_METATABLE);
   lua_setmetatable(L, -2);
   return p;
}
int lua_isspob( lua_State *L, int ind )
{
   int ret;
 
   if (lua_getmetatable(L,ind)==0)
      return 0;
   lua_getfield(L, LUA_REGISTRYINDEX, SPOB_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 spobL_cur( lua_State *L )
{
   LuaSystem sys;
   if (land_spob == NULL)
      return NLUA_ERROR(L,_("Attempting to get landed spob when player not landed."));
   lua_pushspob(L,spob_index(land_spob));
   sys = system_index( system_get( spob_getSystem(land_spob->name) ) );
   lua_pushsystem(L,sys);
   return 2;
}
 
static int spobL_getBackend( lua_State *L, int system, int landable )
{
   char **spobs;
   const char *rndspob;
   Spob *pnt;
 
   rndspob = NULL;
   spobs   = NULL;
 
   /* If boolean return random. */
   if (lua_isboolean(L,1)) {
      pnt = spob_get( space_getRndSpob(landable, 0, NULL) );
      rndspob = pnt->name;
   }
   /* Get a spob by faction */
   else if (lua_isfaction(L,1)) {
      int *factions = array_create( int );
      array_push_back( &factions, lua_tofaction(L,1) );
      spobs  = space_getFactionSpob( factions, landable );
      array_free( factions );
   }
   /* Get a spob by name */
   else if (lua_isstring(L,1)) {
      rndspob = lua_tostring(L,1);
 
      if (landable) {
         pnt = spob_get( rndspob );
         if (pnt == NULL)
            return NLUA_ERROR(L, _("Spob '%s' not found in stack"), rndspob);
 
         /* Check if can land. */
         spob_updateLand( pnt );
         if (!pnt->can_land)
            return 0;
      }
   }
   /* Get a spob from faction list */
   else if (lua_istable(L,1)) {
      /* Get table length and preallocate. */
      int *factions = array_create_size( int, lua_objlen(L,1) );
      /* Load up the table. */
      lua_pushnil(L);
      while (lua_next(L, -2) != 0) {
         if (lua_isfaction(L, -1))
            array_push_back( &factions, lua_tofaction(L, -1) );
         lua_pop(L,1);
      }
 
      /* get the spobs */
      spobs = space_getFactionSpob( factions, landable );
      array_free(factions);
   }
   /* Just get a spob. */
   else if (lua_isspob(L,1)) {
      pnt = luaL_validspob( L, 1 );
      if (landable) {
         /* Check if can land. */
         spob_updateLand( pnt );
         if (!pnt->can_land)
            return 0;
      }
      rndspob = pnt->name;
   }
   else
      NLUA_INVALID_PARAMETER(L,1); /* Bad Parameter */
 
   /* Pick random spob */
   if (rndspob == NULL) {
      arrayShuffle( (void**)spobs );
 
      for (int i=0; i<array_size(spobs); i++) {
         if (landable) {
            /* Check landing. */
            pnt = spob_get( spobs[i] );
            if (pnt == NULL)
               continue;
 
            spob_updateLand( pnt );
            if (!pnt->can_land)
               continue;
         }
 
         rndspob = spobs[i];
         break;
      }
   }
   array_free(spobs);
 
   /* No suitable spob found */
   if (rndspob == NULL && array_size( spobs ) == 0)
      return 0;
 
   /* Push the spob */
   pnt = spob_get(rndspob); /* The real spob */
   if (pnt == NULL)
      return NLUA_ERROR(L, _("Spob '%s' not found in stack"), rndspob);
   lua_pushspob(L,spob_index( pnt ));
   if (system) {
      LuaSystem sys;
      const char *sysname = spob_getSystem( rndspob );
      if (sysname == NULL)
         return 1;
      sys = system_index( system_get( sysname ) );
      lua_pushsystem( L, sys );
      return 2;
   }
   return 1;
}
 
static int spobL_get( lua_State *L )
{
   return spobL_getBackend( L, 0, 0 );
}
 
static int spobL_getS( lua_State *L )
{
   return spobL_getBackend( L, 1, 0 );
}
 
static int spobL_getLandable( lua_State *L )
{
   return spobL_getBackend( L, 1, 1 );
}
 
static int spobL_getAll( lua_State *L )
{
   Spob *p = spob_getAll();
   int n = 1;
   int all_spob = lua_toboolean(L,1);
   lua_newtable(L);
   for (int i=0; i<array_size(p); i++) {
      if (!all_spob && !spob_hasSystem(&p[i]))
         continue;
      lua_pushspob( L, spob_index( &p[i] ) );
      lua_rawseti( L, -2, n++ );
   }
   return 1;
}
 
static int spobL_system( lua_State *L )
{
   LuaSystem sys;
   const Spob *p = luaL_validspob(L,1);
   const char *sysname = spob_getSystem( p->name );
   if (sysname == NULL)
      return 0;
   sys = system_index( system_get( sysname ) );
   lua_pushsystem( L, sys );
   return 1;
}
 
static int spobL_eq( lua_State *L )
{
   LuaSpob a, b;
   a = luaL_checkspob(L,1);
   b = luaL_checkspob(L,2);
   lua_pushboolean(L,(a == b));
   return 1;
}
 
static int spobL_name( lua_State *L )
{
   const Spob *p = luaL_validspob(L,1);
   lua_pushstring(L, spob_name(p));
   return 1;
}
 
static int spobL_nameRaw( lua_State *L )
{
   Spob *p = luaL_validspob(L,1);
   lua_pushstring(L, p->name);
   return 1;
}
 
static int spobL_population( lua_State *L )
{
   Spob *p = luaL_validspob(L,1);
   lua_pushnumber(L,p->population);
   return 1;
}
 
static int spobL_radius( lua_State *L )
{
   Spob *p = luaL_validspob(L,1);
   /* Ensure graphics measurements are available. */
   if (p->radius < 0.)
      spob_gfxLoad(p);
   lua_pushnumber(L,p->radius);
   return 1;
}
 
static int spobL_faction( lua_State *L )
{
   Spob *p = luaL_validspob(L,1);
   if (p->presence.faction < 0)
      return 0;
   lua_pushfaction(L, p->presence.faction);
   return 1;
}
 
static int spobL_colour( lua_State *L )
{
   const Spob *p = luaL_validspob(L,1);
   const glColour *col = spob_getColour( p );
   lua_pushcolour( L, *col );
   return 1;
}
 
static int spobL_colourChar( lua_State *L )
{
   const Spob *p = luaL_validspob(L,1);
   char str[2];
   str[0] = spob_getColourChar( p );
   str[1] = '\0';
   lua_pushstring( L, str );
   return 1;
}
 
static int spobL_class(lua_State *L )
{
   Spob *p = luaL_validspob(L,1);
   lua_pushstring(L,p->class);
   return 1;
}
 
static int spobL_classLong(lua_State *L )
{
   const Spob *p = luaL_validspob(L,1);
   lua_pushstring(L, spob_getClassName(p->class));
   return 1;
}
 
static int spobL_services( lua_State *L )
{
   const Spob *p = luaL_validspob(L,1);
   /* Return result in table */
   lua_newtable(L);
   /* allows syntax like foo = spob.get("foo"); if foo["bar"] then ... end */
   for (int i=1; i<SPOB_SERVICES_MAX; i<<=1) {
      if (spob_hasService(p, i)) {
         char lower[STRMAX_SHORT];
         const char *name = spob_getServiceName(i);
         size_t len = strlen(name) + 1;
         snprintf( lower, MIN(len,sizeof(lower)), "%c%s", tolower(name[0]), &name[1] );
 
         /* GUI depends on this returning the service name. */
         lua_pushstring(L, _(name));
         lua_setfield(L, -2, lower );
      }
   }
   return 1;
}
 
static int spobL_flags( lua_State *L )
{
   const Spob *p = luaL_validspob(L,1);
   lua_newtable(L);
   if (spob_isFlag( p, SPOB_NOMISNSPAWN )) {
      lua_pushstring(L, "nomissionspawn");
      lua_pushboolean(L, 1);
      lua_settable(L,-3);
   }
   return 1;
}
 
static int spobL_canland( lua_State *L )
{
   Spob *p = luaL_validspob(L,1);
   spob_updateLand( p ); /* Update to make sure it's correct. */
   lua_pushboolean( L, p->can_land );
   return 1;
}
 
static int landAllowDeny( lua_State *L, int allowdeny )
{
   Spob *p = luaL_validspob(L,1);
   int old = p->land_override;
   p->land_override = allowdeny * !!lua_toboolean(L,2);
   /* Set the message as necessary. */
   free( p->land_msg );
   p->land_msg = NULL;
   if (!lua_isnoneornil(L,3))
      p->land_msg = strdup( luaL_checkstring(L,3) );
 
   /* If the value has changed, re-run the landing Lua next frame. */
   if (p->land_override != old)
      space_factionChange();
   return 0;
}
 
static int spobL_landAllow( lua_State *L )
{
   return landAllowDeny( L, +1 );
}
 
static int spobL_landDeny( lua_State *L )
{
   return landAllowDeny( L, -1 );
}
 
static int spobL_getLandAllow( lua_State *L )
{
   const Spob *p = luaL_validspob(L,1);
   lua_pushboolean(L, p->land_override>0);
   return 1;
}
 
static int spobL_getLandDeny( lua_State *L )
{
   const Spob *p = luaL_validspob(L,1);
   lua_pushboolean(L, p->land_override<0);
   return 1;
}
 
static int spobL_position( lua_State *L )
{
   const Spob *p = luaL_validspob(L,1);
   lua_pushvector(L, p->pos);
   return 1;
}
 
static int spobL_gfxSpace( lua_State *L )
{
   glTexture *tex;
   const Spob *p = luaL_validspob(L,1);
   if (p->gfx_space == NULL) { /* Not loaded. */
      /* If the spob has no texture, just return nothing. */
      if (p->gfx_spaceName == NULL)
         return 0;
      tex = gl_newImage( p->gfx_spaceName, OPENGL_TEX_MIPMAPS );
   }
   else
      tex = gl_dupTexture( p->gfx_space );
   lua_pushtex( L, tex );
   return 1;
}
 
static int spobL_gfxExterior( lua_State *L )
{
   const Spob *p = luaL_validspob(L,1);
 
   /* If no exterior image just return nothing instead of crashing. */
   if (p->gfx_exterior==NULL)
      return 0;
 
   lua_pushtex( L, gl_newImage( p->gfx_exterior, 0 ) );
   return 1;
}
 
static int spobL_gfxExteriorPath( lua_State *L )
{
   const Spob *p = luaL_validspob(L,1);
   lua_pushstring( L, p->gfx_exteriorPath );
   return 1;
}
 
static int spobL_gfxComm( lua_State *L )
{
   const Spob *p = luaL_validspob(L,1);
   if (p->gfx_comm==NULL)
      return spobL_gfxSpace(L);
   lua_pushtex( L, gl_newImage( p->gfx_comm, 0 ) );
   return 1;
}
 
static int spobL_shipsSold( lua_State *L )
{
   const Spob *p = luaL_validspob(L,1);
   Ship **s = tech_getShip( p->tech );
 
   /* Push results in a table. */
   lua_newtable(L);
   for (int i=0; i<array_size(s); i++) {
      lua_pushship(L,s[i]); /* value = LuaShip */
      lua_rawseti(L,-2,i+1); /* store the value in the table */
   }
 
   array_free(s);
   return 1;
}
 
static int spobL_outfitsSold( lua_State *L )
{
   const Spob *p = luaL_validspob(L,1);
   Outfit **o = tech_getOutfit( p->tech );
 
   /* Push results in a table. */
   lua_newtable(L);
   for (int i=0; i<array_size(o); i++) {
      lua_pushoutfit(L,o[i]); /* value = LuaOutfit */
      lua_rawseti(L,-2,i+1); /* store the value in the table */
   }
 
   array_free(o);
   return 1;
}
 
static int spobL_commoditiesSold( lua_State *L )
{
   /* Get result and tech. */
   Spob *p = luaL_validspob(L,1);
 
   /* Push results in a table. */
   lua_newtable(L);
   for (int i=0; i<array_size(p->commodities); i++) {
      lua_pushcommodity(L,p->commodities[i]); /* value = LuaCommodity */
      lua_rawseti(L,-2,i+1); /* store the value in the table */
   }
 
   return 1;
}
 
static int spobL_isBlackMarket( lua_State *L )
{
   const Spob *p = luaL_validspob(L,1);
   lua_pushboolean(L, spob_hasService(p, SPOB_SERVICE_BLACKMARKET));
   return 1;
}
 
static int spobL_isKnown( lua_State *L )
{
   const Spob *s = luaL_validspob(L,1);
   lua_pushboolean(L, spob_isKnown(s));
   return 1;
}
 
static int spobL_setKnown( lua_State *L )
{
   Spob *p = luaL_validspob(L,1);
   int b = lua_toboolean(L, 2);
 
   int changed = (b != (int)spob_isKnown(p));
 
   if (b)
      spob_setKnown( p );
   else
      spob_rmFlag( p, SPOB_KNOWN );
 
   if (changed) {
      ovr_refresh();
      /* Update outfits image array. */
      outfits_updateEquipmentOutfits();
   }
 
   return 0;
}
 
static int spobL_recordCommodityPriceAtTime( lua_State *L )
{
   const Spob *p = luaL_validspob(L,1);
   ntime_t t = luaL_validtime(L, 2);
   spob_averageSeenPricesAtTime( p, t );
   return 0;
}
 
static int spobL_tags( lua_State *L )
{
   Spob *p = luaL_validspob(L,1);
   lua_newtable(L);
   for (int i=0; i<array_size(p->tags); i++) {
      lua_pushstring(L,p->tags[i]);
      lua_pushboolean(L,1);
      lua_rawset(L,-3);
   }
   return 1;
}