nlua_commodity.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <lauxlib.h>
 
#include "naev.h"
 
#include "nlua_commodity.h"
 
#include "array.h"
#include "ndata.h"
#include "nlua_faction.h"
#include "nlua_spob.h"
#include "nlua_system.h"
#include "nlua_tex.h"
#include "nlua_time.h"
#include "nluadef.h"
 
/* Commodity metatable methods. */
static int commodityL_eq( lua_State *L );
static int commodityL_get( lua_State *L );
static int commodityL_getStandard( lua_State *L );
static int commodityL_flags( lua_State *L );
static int commodityL_name( lua_State *L );
static int commodityL_nameRaw( lua_State *L );
static int commodityL_price( lua_State *L );
static int commodityL_priceAt( lua_State *L );
static int commodityL_priceAtTime( lua_State *L );
static int commodityL_canSell( lua_State *L );
static int commodityL_canBuy( lua_State *L );
static int commodityL_icon( lua_State *L );
static int commodityL_description( lua_State *L );
static int commodityL_new( lua_State *L );
static int commodityL_illegalto( lua_State *L );
static int commodityL_illegality( lua_State *L );
 
static const luaL_Reg commodityL_methods[] = {
   { "__tostring", commodityL_name },
   { "__eq", commodityL_eq },
   { "get", commodityL_get },
   { "getStandard", commodityL_getStandard },
   { "flags", commodityL_flags },
   { "name", commodityL_name },
   { "nameRaw", commodityL_nameRaw },
   { "price", commodityL_price },
   { "priceAt", commodityL_priceAt },
   { "priceAtTime", commodityL_priceAtTime },
   { "canSell", commodityL_canSell },
   { "canBuy", commodityL_canBuy },
   { "icon", commodityL_icon },
   { "description", commodityL_description },
   { "new", commodityL_new },
   { "illegalto", commodityL_illegalto },
   { "illegality", commodityL_illegality },
   { 0, 0 } }; 

int nlua_loadCommodity( nlua_env env )
{
   nlua_register( env, COMMODITY_METATABLE, commodityL_methods, 1 );
   return 0;
}

Commodity *lua_tocommodity( lua_State *L, int ind )
{
   return *( (Commodity **)lua_touserdata( L, ind ) );
}

Commodity *luaL_checkcommodity( lua_State *L, int ind )
{
   if ( lua_iscommodity( L, ind ) )
      return lua_tocommodity( L, ind );
   luaL_typerror( L, ind, COMMODITY_METATABLE );
   return NULL;
}

Commodity *luaL_validcommodity( lua_State *L, int ind )
{
   Commodity *o;
 
   if ( lua_iscommodity( L, ind ) )
      o = luaL_checkcommodity( L, ind );
   else if ( lua_isstring( L, ind ) )
      o = commodity_get( lua_tostring( L, ind ) );
   else {
      luaL_typerror( L, ind, COMMODITY_METATABLE );
      return NULL;
   }
 
   if ( o == NULL )
      NLUA_ERROR( L, _( "Commodity is invalid." ) );
 
   return o;
}

Commodity **lua_pushcommodity( lua_State *L, Commodity *commodity )
{
   Commodity **o = (Commodity **)lua_newuserdata( L, sizeof( Commodity * ) );
   *o            = commodity;
   luaL_getmetatable( L, COMMODITY_METATABLE );
   lua_setmetatable( L, -2 );
   return o;
}

int lua_iscommodity( lua_State *L, int ind )
{
   int ret;
 
   if ( lua_getmetatable( L, ind ) == 0 )
      return 0;
   lua_getfield( L, LUA_REGISTRYINDEX, COMMODITY_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 commodityL_eq( lua_State *L )
{
   const Commodity *a, *b;
   a = luaL_checkcommodity( L, 1 );
   b = luaL_checkcommodity( L, 2 );
   if ( a == b )
      lua_pushboolean( L, 1 );
   else
      lua_pushboolean( L, 0 );
   return 1;
}

static int commodityL_get( lua_State *L )
{
   /* Handle parameters. */
   const char *name = luaL_checkstring( L, 1 );
 
   /* Get commodity. */
   Commodity *commodity = commodity_get( name );
   if ( commodity == NULL ) {
      return NLUA_ERROR( L, _( "Commodity '%s' not found!" ), name );
   }
 
   /* Push. */
   lua_pushcommodity( L, commodity );
   return 1;
}

static int commodityL_getStandard( lua_State *L )
{
   /* Get commodity. */
   Commodity **standard = standard_commodities();
   /* Push. */
   lua_newtable( L );
   for ( int i = 0; i < array_size( standard ); i++ ) {
      lua_pushcommodity( L, standard[i] );
      lua_rawseti( L, -2, i + 1 );
   }
   array_free( standard );
   return 1;
}

static int commodityL_flags( lua_State *L )
{
   const Commodity *c = luaL_validcommodity( L, 1 );
   lua_newtable( L );
 
   lua_pushboolean( L, commodity_isFlag( c, COMMODITY_FLAG_STANDARD ) );
   lua_setfield( L, -2, "standard" );
 
   lua_pushboolean( L, commodity_isFlag( c, COMMODITY_FLAG_ALWAYS_CAN_SELL ) );
   lua_setfield( L, -2, "always_can_sell" );
 
   lua_pushboolean( L, commodity_isFlag( c, COMMODITY_FLAG_PRICE_CONSTANT ) );
   lua_setfield( L, -2, "price_constant" );
 
   return 1;
}

static int commodityL_name( lua_State *L )
{
   const Commodity *c = luaL_validcommodity( L, 1 );
   lua_pushstring( L, _( c->name ) );
   return 1;
}

static int commodityL_nameRaw( lua_State *L )
{
   const Commodity *c = luaL_validcommodity( L, 1 );
   lua_pushstring( L, c->name );
   return 1;
}

static int commodityL_price( lua_State *L )
{
   const Commodity *c = luaL_validcommodity( L, 1 );
   lua_pushnumber( L, c->price );
   return 1;
}

static int commodityL_priceAt( lua_State *L )
{
   const Commodity  *c;
   const Spob       *p;
   const StarSystem *sys;
   const char       *sysname;
 
   c       = luaL_validcommodity( L, 1 );
   p       = luaL_validspob( L, 2 );
   sysname = spob_getSystemName( p->name );
   if ( sysname == NULL )
      return NLUA_ERROR( L, _( "Spob '%s' does not belong to a system." ),
                         p->name );
   sys = system_get( sysname );
   if ( sys == NULL )
      return NLUA_ERROR( L, _( "Spob '%s' can not find its system '%s'." ),
                         p->name, sysname );
 
   lua_pushnumber( L, spob_commodityPrice( p, c ) );
   return 1;
}

static int commodityL_priceAtTime( lua_State *L )
{
   const Commodity  *c;
   const Spob       *p;
   const StarSystem *sys;
   const char       *sysname;
   ntime_t           t;
   c       = luaL_validcommodity( L, 1 );
   p       = luaL_validspob( L, 2 );
   t       = luaL_validtime( L, 3 );
   sysname = spob_getSystemName( p->name );
   if ( sysname == NULL )
      return NLUA_ERROR( L, _( "Spob '%s' does not belong to a system." ),
                         p->name );
   sys = system_get( sysname );
   if ( sys == NULL )
      return NLUA_ERROR( L, _( "Spob '%s' can not find its system '%s'." ),
                         p->name, sysname );
 
   lua_pushnumber( L, spob_commodityPriceAtTime( p, c, t ) );
   return 1;
}
 
static int spob_hasCommodity( const Commodity *c, const Spob *s )
{
   for ( int i = 0; i < array_size( s->commodities ); i++ ) {
      const Commodity *sc = s->commodities[i];
      if ( sc == c )
         return 1;
   }
 
   return 0;
}

static int commodityL_canSell( lua_State *L )
{
   const Commodity *c = luaL_validcommodity( L, 1 );
 
   if ( commodity_isFlag( c, COMMODITY_FLAG_ALWAYS_CAN_SELL ) ) {
      lua_pushboolean( L, 1 );
      return 1;
   }
 
   if ( lua_issystem( L, 2 ) ) {
      const StarSystem *s = luaL_validsystem( L, 2 );
      for ( int i = 0; i < array_size( s->spobs ); i++ ) {
         if ( spob_hasCommodity( c, s->spobs[i] ) ) {
            lua_pushboolean( L, 1 );
            return 1;
         }
      }
   } else {
      const Spob *s = luaL_validspob( L, 2 );
      lua_pushboolean( L, spob_hasCommodity( c, s ) );
      return 1;
   }
 
   lua_pushboolean( L, 0 );
   return 1;
}

static int commodityL_canBuy( lua_State *L )
{
   const Commodity *c = luaL_validcommodity( L, 1 );
 
   if ( lua_issystem( L, 2 ) ) {
      const StarSystem *s = luaL_validsystem( L, 2 );
      for ( int i = 0; i < array_size( s->spobs ); i++ ) {
         if ( spob_hasCommodity( c, s->spobs[i] ) ) {
            lua_pushboolean( L, 1 );
            return 1;
         }
      }
   } else {
      const Spob *s = luaL_validspob( L, 2 );
      lua_pushboolean( L, spob_hasCommodity( c, s ) );
      return 1;
   }
 
   lua_pushboolean( L, 0 );
   return 1;
}

static int commodityL_icon( lua_State *L )
{
   const Commodity *c = luaL_validcommodity( L, 1 );
   if ( c->gfx_store == NULL )
      return 0;
   lua_pushtex( L, gl_dupTexture( c->gfx_store ) );
   return 1;
}

static int commodityL_description( lua_State *L )
{
   const Commodity *c = luaL_validcommodity( L, 1 );
   if ( c->description == NULL )
      return 0;
   lua_pushstring( L, c->description );
   return 1;
}

static int commodityL_new( lua_State *L )
{
   const char *cname, *cdesc;
   char        str[STRMAX_SHORT];
   Commodity  *cargo;
 
   /* Parameters. */
   cname = luaL_checkstring( L, 1 );
   cdesc = luaL_checkstring( L, 2 );
 
   cargo = commodity_getW( cname );
   if ( ( cargo != NULL ) && !cargo->istemp )
      return NLUA_ERROR( L,
                         _( "Trying to create new cargo '%s' that would shadow "
                            "existing non-temporary cargo!" ),
                         cname );
 
   if ( cargo == NULL )
      cargo = commodity_newTemp( cname, cdesc );
 
   if ( !lua_isnoneornil( L, 3 ) ) {
      const char *buf;
      lua_getfield( L, 3, "gfx_space" );
      buf = luaL_optstring( L, -1, NULL );
      if ( buf ) {
         gl_freeTexture( cargo->gfx_space );
         snprintf( str, sizeof( str ), COMMODITY_GFX_PATH "space/%s", buf );
         cargo->gfx_space = gl_newImage( str, 0 );
      }
   }
 
   lua_pushcommodity( L, cargo );
   return 1;
}

static int commodityL_illegalto( lua_State *L )
{
   Commodity *c = luaL_validcommodity( L, 1 );
   if ( lua_istable( L, 2 ) ) {
      lua_pushnil( L );                  /* nil */
      while ( lua_next( L, -2 ) != 0 ) { /* k, v */
         int f = luaL_validfaction( L, -1 );
         commodity_tempIllegalto( c, f );
         lua_pop( L, 1 ); /* k */
      }
   } else {
      int f = luaL_validfaction( L, 2 );
      commodity_tempIllegalto( c, f );
   }
   return 0;
}

static int commodityL_illegality( lua_State *L )
{
   const Commodity *c = luaL_validcommodity( L, 1 );
   lua_newtable( L );
   for ( int i = 0; i < array_size( c->illegalto ); i++ ) {
      lua_pushfaction( L, c->illegalto[i] );
      lua_rawseti( L, -2, i + 1 );
   }
   return 1;
}