nlua_spob.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include "naev.h"
 
#include <ctype.h>
#include <lauxlib.h>
 
#include "nlua_spob.h"
 
#include "array.h"
#include "land.h"
#include "land_outfits.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"
 
/* 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_reputation( 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_isHostile( lua_State *L );
static int spobL_setHostile( 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 },
   { "reputation", spobL_reputation },
   { "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 },
   { "hostile", spobL_isHostile },
   { "setHostile", spobL_setHostile },
   { "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_getSystemName( 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_getSystemName( 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_getSystemName( 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 )
{
   const Spob *p = luaL_validspob( L, 1 );
   if (p->presence.faction < 0)
      return 0;
   lua_pushfaction( L, p->presence.faction );
   return 1;
}

static int spobL_reputation( lua_State *L )
{
   const Spob       *spb = luaL_validspob( L, 1 );
   const StarSystem *sys = spob_getSystem( spb );
   lua_pushnumber( L,
                   system_getReputationOrGlobal( sys, spb->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_isHostile( lua_State *L )
{
   const Spob *p = luaL_validspob( L, 1 );
   lua_pushboolean( L, spob_isFlag( p, SPOB_HOSTILE ) );
   return 1;
}

static int spobL_setHostile( lua_State *L )
{
   Spob *p = luaL_validspob( L, 1 );
   if (lua_toboolean( L, 2 ))
      spob_setFlag( p, SPOB_HOSTILE );
   else
      spob_rmFlag( p, SPOB_HOSTILE );
   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 )
{
   const Spob *p = luaL_validspob( L, 1 );
   return nlua_helperTags( L, 2, p->tags );
}