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 "log.h"
#include "nlua_outfit.h"
#include "nlua_tex.h"
#include "nluadef.h"
#include "rng.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_class( lua_State *L );
static int shipL_classDisplay( lua_State *L );
static int shipL_getPoints( 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_gfxComm( lua_State *L );
static int shipL_gfxTarget( lua_State *L );
static int shipL_gfx( lua_State *L );
static int shipL_dims( 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_tags( 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 },
   { "class", shipL_class },
   { "classDisplay", shipL_classDisplay },
   { "points", shipL_getPoints },
   { "slots", shipL_slots },
   { "getSlots", shipL_getSlots },
   { "fitsSlot", shipL_fitsSlot },
   { "cpu", shipL_CPU },
   { "price", shipL_price },
   { "time_mod", shipL_time_mod },
   { "size", shipL_getSize },
   { "gfxComm", shipL_gfxComm },
   { "gfxTarget", shipL_gfxTarget },
   { "gfx", shipL_gfx },
   { "dims", shipL_dims },
   { "description", shipL_description },
   { "shipstat", shipL_getShipStat },
   { "shipstatDesc", shipL_getShipStatDesc },
   { "tags", shipL_tags },
   {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_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_getPoints( 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 */
 
         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_gfxComm( lua_State *L )
{
   const Ship *s  = luaL_validship(L,1);
   glTexture *tex = ship_loadCommGFX( s );
   if (tex == NULL) {
      WARN(_("Unable to get ship comm graphic for '%s'."), s->name);
      return 0;
   }
   lua_pushtex( L, tex );
   return 1;
}
 
static int shipL_gfxTarget( lua_State *L )
{
   const Ship *s  = luaL_validship(L,1);
   glTexture *tex = gl_dupTexture( s->gfx_target );
   if (tex == NULL) {
      WARN(_("Unable to get ship target 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);
   glTexture *tex = gl_dupTexture( s->gfx_space );
   if (tex == NULL) {
      WARN(_("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->gfx_space->sw );
   lua_pushnumber( L, s->gfx_space->sh );
   return 2;
}
 
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_tags( lua_State *L )
{
   const Ship *s = luaL_validship(L,1);
   lua_newtable(L);
   for (int i=0; i<array_size(s->tags); i++) {
      lua_pushstring(L,s->tags[i]);
      lua_pushboolean(L,1);
      lua_rawset(L,-3);
   }
   return 1;
}