nlua_outfit.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <lauxlib.h>
 
#include "naev.h"
#include "nlua_outfit.h"
 
#include "array.h"
#include "log.h"
#include "damagetype.h"
#include "nlua_faction.h"
#include "nlua_pilot.h"
#include "nlua_ship.h"
#include "nlua_tex.h"
#include "nluadef.h"
#include "player.h"
#include "rng.h"
#include "slots.h"
 
/* Outfit metatable methods. */
static int outfitL_eq( lua_State *L );
static int outfitL_get( lua_State *L );
static int outfitL_getAll( lua_State *L );
static int outfitL_name( lua_State *L );
static int outfitL_nameRaw( lua_State *L );
static int outfitL_shortname( lua_State *L );
static int outfitL_type( lua_State *L );
static int outfitL_typeBroad( lua_State *L );
static int outfitL_cpu( lua_State *L );
static int outfitL_mass( lua_State *L );
static int outfitL_heatFor( lua_State *L );
static int outfitL_slot( lua_State *L );
static int outfitL_limit( lua_State *L );
static int outfitL_icon( lua_State *L );
static int outfitL_price( lua_State *L );
static int outfitL_description( lua_State *L );
static int outfitL_summary( lua_State *L );
static int outfitL_unique( lua_State *L );
static int outfitL_friendlyfire( lua_State *L );
static int outfitL_pointdefense( lua_State *L );
static int outfitL_miss_ships( lua_State *L );
static int outfitL_miss_asteroids( lua_State *L );
static int outfitL_toggleable( lua_State *L );
static int outfitL_getShipStat( lua_State *L );
static int outfitL_weapStats( lua_State *L );
static int outfitL_specificStats( lua_State *L );
static int outfitL_illegality( lua_State *L );
static int outfitL_tags( lua_State *L );
static const luaL_Reg outfitL_methods[] = {
   { "__tostring", outfitL_name },
   { "__eq", outfitL_eq },
   { "get", outfitL_get },
   { "getAll", outfitL_getAll },
   { "name", outfitL_name },
   { "nameRaw", outfitL_nameRaw },
   { "shortname", outfitL_shortname },
   { "type", outfitL_type },
   { "typeBroad", outfitL_typeBroad },
   { "cpu", outfitL_cpu },
   { "mass", outfitL_mass },
   { "heatFor", outfitL_heatFor },
   { "slot", outfitL_slot },
   { "limit", outfitL_limit },
   { "icon", outfitL_icon },
   { "price", outfitL_price },
   { "description", outfitL_description },
   { "summary", outfitL_summary },
   { "unique", outfitL_unique },
   { "friendlyfire", outfitL_friendlyfire },
   { "pointdefense", outfitL_pointdefense },
   { "missShips", outfitL_miss_ships },
   { "missAsteroids", outfitL_miss_asteroids },
   { "toggleable", outfitL_toggleable },
   { "shipstat", outfitL_getShipStat },
   { "weapstats", outfitL_weapStats },
   { "specificstats", outfitL_specificStats },
   { "illegality", outfitL_illegality },
   { "tags", outfitL_tags },
   {0,0}
}; 
int nlua_loadOutfit( nlua_env env )
{
   nlua_register(env, OUTFIT_METATABLE, outfitL_methods, 1);
   return 0;
}
 
const Outfit* lua_tooutfit( lua_State *L, int ind )
{
   return *((const Outfit**) lua_touserdata(L,ind));
}
const Outfit* luaL_checkoutfit( lua_State *L, int ind )
{
   if (lua_isoutfit(L,ind))
      return lua_tooutfit(L,ind);
   luaL_typerror(L, ind, OUTFIT_METATABLE);
   return NULL;
}
const Outfit* luaL_validoutfit( lua_State *L, int ind )
{
   const Outfit *o;
 
   if (lua_isoutfit(L, ind))
      o  = luaL_checkoutfit(L,ind);
   else if (lua_isstring(L, ind))
      o = outfit_get( lua_tostring(L, ind) );
   else {
      luaL_typerror(L, ind, OUTFIT_METATABLE);
      return NULL;
   }
 
   if (o == NULL)
      NLUA_ERROR(L, _("Outfit is invalid."));
 
   return o;
}
const Outfit** lua_pushoutfit( lua_State *L, const Outfit *outfit )
{
   const Outfit **o = (const Outfit**) lua_newuserdata(L, sizeof(Outfit*));
   *o = outfit;
   luaL_getmetatable(L, OUTFIT_METATABLE);
   lua_setmetatable(L, -2);
   return o;
}
int lua_isoutfit( lua_State *L, int ind )
{
   int ret;
 
   if (lua_getmetatable(L,ind)==0)
      return 0;
   lua_getfield(L, LUA_REGISTRYINDEX, OUTFIT_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 outfitL_eq( lua_State *L )
{
   const Outfit *a, *b;
   a = luaL_checkoutfit(L,1);
   b = luaL_checkoutfit(L,2);
   if (a == b)
      lua_pushboolean(L,1);
   else
      lua_pushboolean(L,0);
   return 1;
}
 
static int outfitL_get( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   lua_pushoutfit(L, o);
   return 1;
}
 
static int outfitL_getAll( lua_State *L )
{
   const Outfit *outfits = outfit_getAll();
   lua_newtable(L); /* t */
   for (int i=0; i<array_size(outfits); i++) {
      lua_pushoutfit( L, (Outfit*) &outfits[i] );
      lua_rawseti( L, -2, i+1 );
   }
   return 1;
}
 
static int outfitL_name( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   lua_pushstring(L, _(o->name));
   return 1;
}
 
static int outfitL_nameRaw( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   lua_pushstring(L, o->name);
   return 1;
}
 
static int outfitL_shortname( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   lua_pushstring(L, (o->shortname!=NULL) ? _(o->shortname) : _(o->name));
   return 1;
}
 
static int outfitL_type( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   lua_pushstring(L, outfit_getType(o));
   return 1;
}
 
static int outfitL_typeBroad( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   lua_pushstring(L, outfit_getTypeBroad(o));
   return 1;
}
 
static int outfitL_cpu( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   lua_pushnumber(L, outfit_cpu(o));
   return 1;
}
 
static int outfitL_mass( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   lua_pushnumber(L, o->mass);
   return 1;
}
 
static int outfitL_heatFor( lua_State *L )
{
   const Outfit *o = luaL_validoutfit( L, 1 );
   double heatup = luaL_checknumber( L, 2 );
   double C = pilot_heatCalcOutfitC( o );
   double area = pilot_heatCalcOutfitArea( o );
   double heat = ((800.-CONST_SPACE_STAR_TEMP)*C +
            STEEL_HEAT_CONDUCTIVITY * ((800.-CONST_SPACE_STAR_TEMP) * area)) /
         heatup;
   lua_pushnumber( L, heat );
   return 1;
}
 
static int outfitL_slot( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   lua_pushstring(L, outfit_slotName(o));
   lua_pushstring(L, outfit_slotSize(o));
   lua_pushstring(L, sp_display( o->slot.spid ));
   lua_pushboolean(L, sp_required( o->slot.spid ));
   lua_pushboolean(L, sp_exclusive( o->slot.spid ));
   return 5;
}
 
static int outfitL_limit( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   if (o->limit) {
      lua_pushstring(L,o->limit);
      return 1;
   }
   return 0;
}
 
static int outfitL_icon( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   lua_pushtex( L, gl_dupTexture( o->gfx_store ) );
   return 1;
}
 
static int outfitL_price( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   lua_pushnumber(L, o->price);
   return 1;
}
 
static int outfitL_description( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   if (lua_ispilot(L,2))
      lua_pushstring(L, pilot_outfitDescription( luaL_validpilot(L,2), o ) );
   else
      lua_pushstring(L, pilot_outfitDescription( player.p, o ) );
   return 1;
}
 
static int outfitL_summary( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   int noname = lua_toboolean(L,3);
   if (lua_ispilot(L,2))
      lua_pushstring(L, pilot_outfitSummary( luaL_validpilot(L,2), o, !noname ) );
   else
      lua_pushstring(L, pilot_outfitSummary( player.p, o, !noname ) );
   return 1;
}
 
static int getprop( lua_State *L, int prop )
{
   const Outfit *o = luaL_validoutfit(L,1);
   lua_pushboolean(L, outfit_isProp(o, prop));
   return 1;
}
 
static int outfitL_unique( lua_State *L )
{
   return getprop( L, OUTFIT_PROP_UNIQUE );
}
 
static int outfitL_friendlyfire( lua_State *L )
{
   return getprop( L, OUTFIT_PROP_WEAP_FRIENDLYFIRE );
}
 
static int outfitL_pointdefense( lua_State *L )
{
   return getprop( L, OUTFIT_PROP_WEAP_POINTDEFENSE );
}
 
static int outfitL_miss_ships( lua_State *L )
{
   return getprop( L, OUTFIT_PROP_WEAP_MISS_SHIPS );
}
 
static int outfitL_miss_asteroids( lua_State *L )
{
   return getprop( L, OUTFIT_PROP_WEAP_MISS_ASTEROIDS );
}
 
static int outfitL_toggleable( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   lua_pushboolean( L, outfit_isToggleable(o) );
   return 1;
}
 
static int outfitL_getShipStat( lua_State *L )
{
   ShipStats ss;
   const Outfit *o = luaL_validoutfit(L,1);
   ss_statsInit( &ss );
   ss_statsMergeFromList( &ss, o->stats );
   const char *str   = luaL_optstring(L,2,NULL);
   int internal      = lua_toboolean(L,3);
   ss_statsGetLua( L, &ss, str, internal );
   return 1;
}
 
static int outfitL_weapStats( lua_State *L )
{
   double eps, dps, disable, shots;
   double mod_energy, mod_damage, mod_shots;
   double sdmg, admg;
   const Damage *dmg;
   const Outfit *o   = luaL_validoutfit( L, 1 );
   Pilot *p    = (lua_ispilot(L,2)) ? luaL_validpilot(L,2) : NULL;
 
   /* Just return 0 for non-wapons. */
   if (o->slot.type != OUTFIT_SLOT_WEAPON)
      return 0;
 
   /* Special case beam weapons .*/
   if (outfit_isBeam(o)) {
      if (p) {
         /* Special case due to continuous fire. */
         if (o->type == OUTFIT_TYPE_BEAM) {
            mod_energy = p->stats.fwd_energy;
            mod_damage = p->stats.fwd_damage;
            mod_shots  = 1. / p->stats.fwd_firerate;
         }
         else {
            mod_energy = p->stats.tur_energy;
            mod_damage = p->stats.tur_damage;
            mod_shots  = 1. / p->stats.tur_firerate;
         }
      }
      else {
         mod_energy = 1.;
         mod_damage = 1.;
         mod_shots = 1.;
      }
      shots = outfit_duration(o);
      mod_shots = shots / (shots + mod_shots * outfit_delay(o));
      dmg = outfit_damage(o);
      /* Modulate the damage by average of damage types. */
      if (dtype_raw( dmg->type, &sdmg, &admg, NULL ) != 0)
         return NLUA_ERROR(L, _("Outfit has invalid damage type."));
      mod_damage *= 0.5*(sdmg+admg);
      /* Calculate good damage estimates. */
      dps = mod_shots * mod_damage * dmg->damage;
      disable = mod_shots * mod_damage * dmg->disable;
      eps = mod_shots * mod_energy * outfit_energy(o);
      lua_pushnumber( L, dps );
      lua_pushnumber( L, disable );
      lua_pushnumber( L, eps );
      lua_pushnumber( L, outfit_range(o) );
      return 4;
   }
 
   if (p) {
      switch (o->type) {
         case OUTFIT_TYPE_BOLT:
            mod_energy = p->stats.fwd_energy;
            mod_damage = p->stats.fwd_damage;
            mod_shots  = 1. / p->stats.fwd_firerate;
            break;
         case OUTFIT_TYPE_TURRET_BOLT:
            mod_energy = p->stats.tur_energy;
            mod_damage = p->stats.tur_damage;
            mod_shots  = 1. / p->stats.tur_firerate;
            break;
         case OUTFIT_TYPE_LAUNCHER:
         case OUTFIT_TYPE_TURRET_LAUNCHER:
            mod_energy = 1.;
            mod_damage = p->stats.launch_damage;
            mod_shots  = 1. / p->stats.launch_rate;
            break;
         case OUTFIT_TYPE_BEAM:
         case OUTFIT_TYPE_TURRET_BEAM:
         default:
            return 0;
      }
   }
   else {
      mod_energy = 1.;
      mod_damage = 1.;
      mod_shots = 1.;
   }
 
   shots = 1. / (mod_shots * outfit_delay(o));
   /* Special case: Ammo-based weapons. */
   dmg = outfit_damage(o);
   if (dmg==NULL)
      return 0;
   /* Modulate the damage by average of damage types. */
   dtype_raw( dmg->type, &sdmg, &admg, NULL );
   mod_damage *= 0.5*(sdmg+admg);
   /* Calculate good damage estimates. */
   dps = shots * mod_damage * dmg->damage;
   disable = shots * mod_damage * dmg->disable;
   eps = shots * mod_energy * MAX( outfit_energy(o), 0. );
 
   lua_pushnumber( L, dps );
   lua_pushnumber( L, disable );
   lua_pushnumber( L, eps );
   lua_pushnumber( L, outfit_range(o) );
   lua_pushnumber( L, outfit_trackmin(o) );
   lua_pushnumber( L, outfit_trackmax(o) );
   if (outfit_isLauncher(o)) {
      lua_pushnumber( L, o->u.lau.lockon );
      lua_pushnumber( L, o->u.lau.iflockon );
      lua_pushboolean( L, o->u.lau.ai!=AMMO_AI_UNGUIDED );
      return 9;
   }
   return 6;
}
 
#define SETFIELD( name, value )  \
   lua_pushnumber( L, value ); \
   lua_setfield( L, -2, name )
#define SETFIELDI( name, value )  \
   lua_pushinteger( L, value ); \
   lua_setfield( L, -2, name )
#define SETFIELDB( name, value )  \
   lua_pushboolean( L, value ); \
   lua_setfield( L, -2, name )
static int outfitL_specificStats( lua_State *L )
{
   const Outfit *o = luaL_validoutfit( L, 1 );
   lua_newtable(L);
   switch (o->type) {
      case OUTFIT_TYPE_AFTERBURNER:
         SETFIELD( "accel",      o->u.afb.accel );
         SETFIELD( "speed",      o->u.afb.speed );
         SETFIELD( "energy",     o->u.afb.energy );
         SETFIELD( "mass_limit", o->u.afb.mass_limit );
         SETFIELD( "heatup",     o->u.afb.heatup );
         SETFIELD( "heat",       o->u.afb.heat );
         SETFIELD( "overheat_min",o->overheat_min );
         SETFIELD( "overheat_max",o->overheat_max );
         break;
 
      case OUTFIT_TYPE_FIGHTER_BAY:
         lua_pushship( L, o->u.bay.ship );
         lua_setfield( L, -2, "ship" );
         SETFIELD( "delay",      o->u.bay.delay );
         SETFIELDI("amount",     o->u.bay.amount );
         SETFIELD( "reload_time",o->u.bay.reload_time );
         break;
 
      case OUTFIT_TYPE_TURRET_BOLT:
         SETFIELDB("isturret",   1 );
         FALLTHROUGH;
      case OUTFIT_TYPE_BOLT:
         SETFIELD( "delay",      o->u.blt.delay );
         SETFIELD( "speed",      o->u.blt.speed );
         SETFIELD( "range",      o->u.blt.range );
         SETFIELD( "falloff",    o->u.blt.falloff );
         SETFIELD( "energy",     o->u.blt.energy );
         SETFIELD( "heatup",     o->u.blt.heatup );
         SETFIELD( "heat",       o->u.blt.heat );
         SETFIELD( "trackmin",   o->u.blt.trackmin );
         SETFIELD( "trackmax",   o->u.blt.trackmax );
         SETFIELD( "swivel",     o->u.blt.swivel );
         /* Damage stuff. */
         SETFIELD( "penetration",o->u.blt.dmg.penetration );
         SETFIELD( "damage",     o->u.blt.dmg.damage );
         SETFIELD( "disable",    o->u.blt.dmg.disable );
         break;
 
      case OUTFIT_TYPE_TURRET_BEAM:
         SETFIELDB("isturret",   1 );
         FALLTHROUGH;
      case OUTFIT_TYPE_BEAM:
         SETFIELD( "delay",      o->u.bem.delay );
         SETFIELD( "warmup",     o->u.bem.warmup );
         SETFIELD( "duration",   o->u.bem.duration );
         SETFIELD( "min_duration",o->u.bem.min_duration );
         SETFIELD( "range",      o->u.bem.range );
         SETFIELD( "turn",       o->u.bem.turn );
         SETFIELD( "energy",     o->u.bem.energy );
         SETFIELD( "heatup",     o->u.bem.heatup );
         SETFIELD( "heat",       o->u.bem.heat );
         /* Damage stuff. */
         SETFIELD( "penetration",o->u.bem.dmg.penetration );
         SETFIELD( "damage",     o->u.bem.dmg.damage );
         SETFIELD( "disable",    o->u.bem.dmg.disable );
         break;
 
      case OUTFIT_TYPE_TURRET_LAUNCHER:
         SETFIELDB("isturret",   1 );
         FALLTHROUGH;
      case OUTFIT_TYPE_LAUNCHER:
         SETFIELD( "delay",      o->u.lau.delay );
         SETFIELDI("amount",     o->u.lau.amount );
         SETFIELD( "reload_time",o->u.lau.reload_time );
         SETFIELD( "lockon",     o->u.lau.lockon );
         SETFIELD( "iflockon",   o->u.lau.iflockon );
         SETFIELD( "trackmin",   o->u.lau.trackmin );
         SETFIELD( "trackmax",   o->u.lau.trackmax );
         SETFIELD( "arc",        o->u.lau.arc );
         SETFIELD( "swivel",     o->u.lau.swivel );
         /* Ammo stuff. */
         SETFIELD( "duration",   o->u.lau.duration );
         SETFIELD( "speed",      o->u.lau.speed );
         SETFIELD( "speed_max",  o->u.lau.speed_max );
         SETFIELD( "turn",       o->u.lau.turn );
         SETFIELD( "accel",      o->u.lau.accel );
         SETFIELD( "energy",     o->u.lau.energy );
         SETFIELDB("seek",       o->u.lau.ai!=AMMO_AI_UNGUIDED );
         SETFIELDB("smart",      o->u.lau.ai==AMMO_AI_SMART );
         /* Damage stuff. */
         SETFIELD( "penetration",o->u.lau.dmg.penetration );
         SETFIELD( "damage",     o->u.lau.dmg.damage );
         SETFIELD( "disable",    o->u.lau.dmg.disable );
         break;
 
      default:
         break;
   }
   return 1;
}
#undef SETFIELD
#undef SETFIELDI
#undef SETFIELDB
 
static int outfitL_illegality( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   lua_newtable(L);
   for (int i=0; i<array_size(o->illegalto); i++) {
      lua_pushfaction( L, o->illegalto[i] );
      lua_rawseti( L, -2, i+1 );
   }
   return 1;
}
 
static int outfitL_tags( lua_State *L )
{
   const Outfit *o = luaL_validoutfit(L,1);
   lua_newtable(L);
   for (int i=0; i<array_size(o->tags); i++) {
      lua_pushstring(L,o->tags[i]);
      lua_pushboolean(L,1);
      lua_rawset(L,-3);
   }
   return 1;
}