nlua_ship.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <lauxlib.h>
 
#include "naev.h"
 
#include "nlua_ship.h"
 
#include "array.h"
#include "nlua_canvas.h"
#include "nlua_faction.h"
#include "nlua_outfit.h"
#include "nlua_tex.h"
#include "nluadef.h"
#include "player.h"
#include "slots.h"
 
/*
 * Prototypes.
 */
static const ShipOutfitSlot *ship_outfitSlotFromID( const Ship *s, int id );
 
/* Ship metatable methods. */
static int shipL_eq( lua_State *L );
static int shipL_get( lua_State *L );
static int shipL_getAll( lua_State *L );
static int shipL_name( lua_State *L );
static int shipL_nameRaw( lua_State *L );
static int shipL_baseType( lua_State *L );
static int shipL_inherits( lua_State *L );
static int shipL_class( lua_State *L );
static int shipL_classDisplay( lua_State *L );
static int shipL_faction( lua_State *L );
static int shipL_fabricator( lua_State *L );
static int shipL_crew( lua_State *L );
static int shipL_mass( lua_State *L );
static int shipL_armour( lua_State *L );
static int shipL_cargo( lua_State *L );
static int shipL_fuelConsumption( lua_State *L );
static int shipL_license( lua_State *L );
static int shipL_points( lua_State *L );
static int shipL_slots( lua_State *L );
static int shipL_getSlots( lua_State *L );
static int shipL_fitsSlot( lua_State *L );
static int shipL_CPU( lua_State *L );
static int shipL_gfxPath( lua_State *L );
static int shipL_gfxComm( lua_State *L );
static int shipL_gfxStore( lua_State *L );
static int shipL_gfx( lua_State *L );
static int shipL_dims( lua_State *L );
static int shipL_screenSize( lua_State *L );
static int shipL_price( lua_State *L );
static int shipL_time_mod( lua_State *L );
static int shipL_getSize( lua_State *L );
static int shipL_description( lua_State *L );
static int shipL_getShipStat( lua_State *L );
static int shipL_getShipStatDesc( lua_State *L );
static int shipL_known( lua_State *L );
static int shipL_tags( lua_State *L );
static int shipL_render( lua_State *L );
 
static const luaL_Reg shipL_methods[] = {
   { "__tostring", shipL_name },
   { "__eq", shipL_eq },
   { "get", shipL_get },
   { "getAll", shipL_getAll },
   { "name", shipL_name },
   { "nameRaw", shipL_nameRaw },
   { "baseType", shipL_baseType },
   { "inherits", shipL_inherits },
   { "class", shipL_class },
   { "classDisplay", shipL_classDisplay },
   { "faction", shipL_faction },
   { "fabricator", shipL_fabricator },
   { "crew", shipL_crew },
   { "mass", shipL_mass },
   { "armour", shipL_armour },
   { "cargo", shipL_cargo },
   { "fuelConsumption", shipL_fuelConsumption },
   { "license", shipL_license },
   { "points", shipL_points },
   { "slots", shipL_slots },
   { "getSlots", shipL_getSlots },
   { "fitsSlot", shipL_fitsSlot },
   { "cpu", shipL_CPU },
   { "price", shipL_price },
   { "time_mod", shipL_time_mod },
   { "size", shipL_getSize },
   { "gfxPath", shipL_gfxPath },
   { "gfxComm", shipL_gfxComm },
   { "gfxStore", shipL_gfxStore },
   { "gfx", shipL_gfx },
   { "dims", shipL_dims },
   { "screenSize", shipL_screenSize },
   { "description", shipL_description },
   { "shipstat", shipL_getShipStat },
   { "shipstatDesc", shipL_getShipStatDesc },
   { "known", shipL_known },
   { "tags", shipL_tags },
   { "render", shipL_render },
   { 0, 0 } }; 

int nlua_loadShip( nlua_env env )
{
   nlua_register( env, SHIP_METATABLE, shipL_methods, 1 );
   return 0;
}

const Ship *lua_toship( lua_State *L, int ind )
{
   return *( (Ship **)lua_touserdata( L, ind ) );
}

const Ship *luaL_checkship( lua_State *L, int ind )
{
   if ( lua_isship( L, ind ) )
      return lua_toship( L, ind );
   luaL_typerror( L, ind, SHIP_METATABLE );
   return NULL;
}

const Ship *luaL_validship( lua_State *L, int ind )
{
   const Ship *s;
 
   if ( lua_isship( L, ind ) )
      s = luaL_checkship( L, ind );
   else if ( lua_isstring( L, ind ) )
      s = ship_get( lua_tostring( L, ind ) );
   else {
      luaL_typerror( L, ind, SHIP_METATABLE );
      return NULL;
   }
 
   if ( s == NULL )
      NLUA_ERROR( L, _( "Ship is invalid." ) );
 
   return s;
}

const Ship **lua_pushship( lua_State *L, const Ship *ship )
{
   const Ship **p;
   p  = (const Ship **)lua_newuserdata( L, sizeof( Ship  *) );
   *p = ship;
   luaL_getmetatable( L, SHIP_METATABLE );
   lua_setmetatable( L, -2 );
   return p;
}

int lua_isship( lua_State *L, int ind )
{
   int ret;
 
   if ( lua_getmetatable( L, ind ) == 0 )
      return 0;
   lua_getfield( L, LUA_REGISTRYINDEX, SHIP_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 shipL_eq( lua_State *L )
{
   const Ship *a, *b;
   a = luaL_checkship( L, 1 );
   b = luaL_checkship( L, 2 );
   if ( a == b )
      lua_pushboolean( L, 1 );
   else
      lua_pushboolean( L, 0 );
   return 1;
}

static int shipL_get( lua_State *L )
{
   const Ship *ship = luaL_validship( L, 1 );
   lua_pushship( L, ship );
   return 1;
}

static int shipL_getAll( lua_State *L )
{
   const Ship *ships = ship_getAll();
   lua_newtable( L ); /* t */
   for ( int i = 0; i < array_size( ships ); i++ ) {
      lua_pushship( L, &ships[i] );
      lua_rawseti( L, -2, i + 1 );
   }
   return 1;
}

static int shipL_name( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushstring( L, _( s->name ) );
   return 1;
}

static int shipL_nameRaw( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushstring( L, s->name );
   return 1;
}

static int shipL_baseType( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushstring( L, s->base_type );
   return 1;
}

static int shipL_inherits( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   if ( s->inherits == NULL )
      return 0;
   lua_pushship( L, ship_get( s->inherits ) );
   return 1;
}

static int shipL_class( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushstring( L, ship_class( s ) );
   return 1;
}

static int shipL_classDisplay( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushstring( L, ship_classDisplay( s ) );
   return 1;
}

static int shipL_faction( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   if ( faction_isFaction( s->faction ) ) {
      lua_pushfaction( L, s->faction );
      return 1;
   }
   return 0;
}

static int shipL_fabricator( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushstring( L, s->fabricator );
   return 1;
}

static int shipL_crew( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushinteger( L, s->crew );
   return 1;
}

static int shipL_mass( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushnumber( L, s->mass );
   return 1;
}

static int shipL_armour( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushnumber( L, s->armour );
   return 1;
}

static int shipL_cargo( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushnumber( L, s->cap_cargo );
   return 1;
}

static int shipL_fuelConsumption( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushnumber( L, s->fuel_consumption );
   return 1;
}

static int shipL_license( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   if ( s->license == NULL )
      return 0;
   lua_pushstring( L, s->license );
   return 1;
}

static int shipL_points( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushinteger( L, s->points );
   return 1;
}

static int shipL_slots( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   /* Push slot numbers. */
   lua_pushnumber( L, array_size( s->outfit_weapon ) );
   lua_pushnumber( L, array_size( s->outfit_utility ) );
   lua_pushnumber( L, array_size( s->outfit_structure ) );
   return 3;
}

static int shipL_getSlots( lua_State *L )
{
   int                   k;
   const Ship           *s               = luaL_validship( L, 1 );
   int                   ignore_locked   = lua_toboolean( L, 2 );
   const ShipOutfitSlot *outfit_arrays[] = {
      s->outfit_structure, s->outfit_utility, s->outfit_weapon };
 
   lua_newtable( L );
   k = 1;
   for ( int i = 0; i < 3; i++ ) {
      for ( int j = 0; j < array_size( outfit_arrays[i] ); j++ ) {
         const OutfitSlot     *slot  = &outfit_arrays[i][j].slot;
         const ShipOutfitSlot *sslot = &outfit_arrays[i][j];
 
         /* Skip locked if necessary. */
         if ( ignore_locked && sslot->locked )
            continue;
 
         /* make the slot table and put it in */
         lua_newtable( L );
 
         /* Index can be used as an ID (at least for now...) */
#if 0
         lua_pushstring(L, "id" ); /* key */
         lua_pushinteger(L, k); /* value */
         lua_rawset(L, -3); /* table[key] = value*/
#endif
 
         lua_pushstring( L, "type" );                 /* key */
         lua_pushstring( L, slotName( slot->type ) ); /* value */
         lua_rawset( L, -3 );                         /* table[key] = value*/
 
         lua_pushstring( L, "size" ); /* key */
         lua_pushstring( L, slotSize( slot->size ) );
         lua_rawset( L, -3 ); /* table[key] = value */
 
         lua_pushstring( L, "property" );               /* key */
         lua_pushstring( L, sp_display( slot->spid ) ); /* value */
         lua_rawset( L, -3 );                           /* table[key] = value */
 
         lua_pushstring( L, "required" );       /* key */
         lua_pushboolean( L, sslot->required ); /* value */
         lua_rawset( L, -3 );                   /* table[key] = value */
 
         lua_pushstring( L, "exclusive" );       /* key */
         lua_pushboolean( L, sslot->exclusive ); /* value */
         lua_rawset( L, -3 );                    /* table[key] = value */
 
         lua_pushstring( L, "locked" );       /* key */
         lua_pushboolean( L, sslot->locked ); /* value */
         lua_rawset( L, -3 );                 /* table[key] = value */
 
         lua_pushstring( L, "visible" );       /* key */
         lua_pushboolean( L, sslot->visible ); /* value */
         lua_rawset( L, -3 );                  /* table[key] = value */
 
         if ( sslot->data != NULL ) {
            lua_pushstring( L, "outfit" );    /* key */
            lua_pushoutfit( L, sslot->data ); /* value*/
            lua_rawset( L, -3 );              /* table[key] = value */
         }
 
         lua_rawseti( L, -2, k++ ); /* put the slot table in */
      }
   }
 
   return 1;
}

static const ShipOutfitSlot *ship_outfitSlotFromID( const Ship *s, int id )
{
   const ShipOutfitSlot *outfit_arrays[] = {
      s->outfit_structure, s->outfit_utility, s->outfit_weapon };
 
   for ( int i = 0; i < 3; i++ ) {
      int n = array_size( outfit_arrays[i] );
      if ( id <= n )
         return &outfit_arrays[i][id - 1];
      id -= n;
   }
   return NULL;
}

static int shipL_fitsSlot( lua_State *L )
{
   const Ship           *s  = luaL_validship( L, 1 );
   int                   id = luaL_checkinteger( L, 2 );
   const Outfit         *o  = luaL_validoutfit( L, 3 );
   const ShipOutfitSlot *ss = ship_outfitSlotFromID( s, id );
   if ( ss->locked ) {
      lua_pushboolean( L, 0 );
      return 1;
   }
   lua_pushboolean( L, outfit_fitsSlot( o, &ss->slot ) );
   return 1;
}

static int shipL_CPU( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushnumber( L, s->cpu );
   return 1;
}

static int shipL_price( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushnumber( L, ship_buyPrice( s ) );
   lua_pushnumber( L, ship_basePrice( s ) );
   return 2;
}

static int shipL_time_mod( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushnumber( L, s->dt_default );
   return 1;
}

static int shipL_getSize( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushinteger( L, ship_size( s ) );
   return 1;
}

static int shipL_gfxPath( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushstring( L, s->gfx_path );
   return 1;
}

static int shipL_gfxComm( lua_State *L )
{
   const Ship *s    = luaL_validship( L, 1 );
   int         size = luaL_optinteger( L, 2, 512 );
   glTexture  *tex  = ship_gfxComm( s, size, 0., 0., &L_store_const );
   if ( tex == NULL ) {
      NLUA_WARN( L, _( "Unable to get ship comm graphic for '%s'." ), s->name );
      return 0;
   }
   lua_pushtex( L, tex );
   return 1;
}

static int shipL_gfxStore( lua_State *L )
{
   const Ship *s   = luaL_validship( L, 1 );
   glTexture  *tex = ship_gfxStore( s, 256, 0., 0., 0. );
   if ( tex == NULL ) {
      NLUA_WARN( L, _( "Unable to get ship store graphic for '%s'." ),
                 s->name );
      return 0;
   }
   lua_pushtex( L, tex );
   return 1;
}

static int shipL_gfx( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   ship_gfxLoad( (Ship *)s );
   glTexture *tex = gl_dupTexture( s->gfx_space );
   if ( tex == NULL ) {
      NLUA_WARN( L, _( "Unable to get ship graphic for '%s'." ), s->name );
      return 0;
   }
   lua_pushtex( L, tex );
   return 1;
}

static int shipL_dims( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushnumber( L, s->size );
   lua_pushnumber( L, s->size );
   return 2;
}

static int shipL_screenSize( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushnumber( L, s->size );
   return 1;
}

static int shipL_description( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   lua_pushstring( L, _( s->description ) );
   return 1;
}

static int shipL_getShipStat( lua_State *L )
{
   const Ship *s        = luaL_validship( L, 1 );
   const char *str      = luaL_optstring( L, 2, NULL );
   int         internal = lua_toboolean( L, 3 );
   ss_statsGetLua( L, &s->stats_array, str, internal );
   return 1;
}

static int shipL_getShipStatDesc( lua_State *L )
{
   char        buf[STRMAX];
   const Ship *s = luaL_validship( L, 1 );
   ss_statsDesc( &s->stats_array, buf, sizeof( buf ), 0 );
   lua_pushstring( L, buf );
   return 1;
}

static int shipL_known( lua_State *L )
{
   /* TODO cache this and mark as dirty instead of recomputing for each outfit.
    */
   const Ship         *s  = luaL_validship( L, 1 );
   const PlayerShip_t *ps = player_getShipStack();
   for ( int i = 0; i < array_size( ps ); i++ ) {
      if ( ps[i].p->ship == s ) {
         lua_pushboolean( L, 1 );
         return 1;
      }
   }
   const Spob *ss = spob_getAll();
   for ( int i = 0; i < array_size( ss ); i++ ) {
      const Spob *spb = &ss[i];
      if ( !spob_hasService( spb, SPOB_SERVICE_SHIPYARD ) )
         continue;
      if ( !spob_isKnown( spb ) )
         continue;
      if ( tech_hasShip( spb->tech, s ) ) {
         lua_pushboolean( L, 1 );
         return 1;
      }
   }
   lua_pushboolean( L, 0 );
   return 1;
}

static int shipL_tags( lua_State *L )
{
   const Ship *s = luaL_validship( L, 1 );
   return nlua_helperTags( L, 2, s->tags );
}

static int shipL_render( lua_State *L )
{
   LuaCanvas_t lc;
   int         w, h, sx, sy;
   const Ship *s    = luaL_validship( L, 1 );
   double      dir  = luaL_checknumber( L, 2 );
   double      eg   = luaL_optnumber( L, 3, 0. );
   double      tilt = luaL_optnumber( L, 4, 0. );
 
   ship_gfxLoad( (Ship *)s );
 
   gl_getSpriteFromDir( &sx, &sy, s->sx, s->sy, dir );
 
   w = s->size;
   h = s->size;
   if ( canvas_new( &lc, w, h ) )
      return NLUA_ERROR( L, _( "Error setting up framebuffer!" ) );
 
   /* The code path below is really buggy.
    * 1. engine_glow seems to scale 3D models improperly when interpolating, so
    * it's disabled.
    * 2. for some reason, have to pass real dimensions and not fbo dimensions.
    * TODO fix this shit. */
   ship_renderFramebuffer( s, lc.fbo, gl_screen.rw, gl_screen.rh, dir, eg, tilt,
                           0., sx, sy, NULL, NULL );
 
   lua_pushcanvas( L, lc );
   return 1;
}