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 "log.h"
#include "ndata.h"
#include "nlua_faction.h"
#include "nlua_spob.h"
#include "nlua_system.h"
#include "nlua_time.h"
#include "nlua_tex.h"
#include "nluadef.h"
#include "rng.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_getSystem( 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_getSystem( 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;
}