nlua_pilotoutfit.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <lauxlib.h>
 
#include "naev.h"
 
#include "nlua_pilotoutfit.h"
 
#include "array.h"
#include "nlua_asteroid.h"
#include "nlua_munition.h"
#include "nlua_outfit.h"
#include "nlua_pilot.h"
#include "nlua_vec2.h"
#include "nluadef.h"
#include "slots.h"
#include "weapon.h"
 
int pilotoutfit_modified = 0;
 
/* Pilot outfit metatable methods. */
static int poL_slot( lua_State *L );
static int poL_outfit( lua_State *L );
static int poL_state( lua_State *L );
static int poL_progress( lua_State *L );
static int poL_set( lua_State *L );
static int poL_clear( lua_State *L );
static int poL_munition( lua_State *L );
static int poL_shoot( lua_State *L );
static int poL_heat( lua_State *L );
static int poL_heatup( lua_State *L );
 
static const luaL_Reg poL_methods[] = {
   { "slot", poL_slot },
   { "outfit", poL_outfit },
   { "state", poL_state },
   { "progress", poL_progress },
   { "set", poL_set },
   { "clear", poL_clear },
   { "munition", poL_munition },
   { "shoot", poL_shoot },
   { "heat", poL_heat },
   { "heatup", poL_heatup },
   { 0, 0 } }; 

int nlua_loadPilotOutfit( nlua_env env )
{
   nlua_register( env, PILOTOUTFIT_METATABLE, poL_methods, 1 );
   return 0;
}

PilotOutfitSlot *lua_topilotoutfit( lua_State *L, int ind )
{
   return *( (PilotOutfitSlot **)lua_touserdata( L, ind ) );
}

PilotOutfitSlot *luaL_checkpilotoutfit( lua_State *L, int ind )
{
   if ( lua_ispilotoutfit( L, ind ) )
      return lua_topilotoutfit( L, ind );
   luaL_typerror( L, ind, PILOTOUTFIT_METATABLE );
   return NULL;
}

PilotOutfitSlot *luaL_validpilotoutfit( lua_State *L, int ind )
{
   PilotOutfitSlot *o;
 
   if ( lua_ispilotoutfit( L, ind ) )
      o = luaL_checkpilotoutfit( L, ind );
   else {
      luaL_typerror( L, ind, PILOTOUTFIT_METATABLE );
      return NULL;
   }
 
   if ( o == NULL )
      NLUA_ERROR( L, _( "Pilot Outfit is invalid." ) );
 
   return o;
}

PilotOutfitSlot **lua_pushpilotoutfit( lua_State *L, PilotOutfitSlot *po )
{
   PilotOutfitSlot **lpo =
      (PilotOutfitSlot **)lua_newuserdata( L, sizeof( PilotOutfitSlot * ) );
   *lpo = po;
   luaL_getmetatable( L, PILOTOUTFIT_METATABLE );
   lua_setmetatable( L, -2 );
   return lpo;
}

int lua_ispilotoutfit( lua_State *L, int ind )
{
   int ret;
 
   if ( lua_getmetatable( L, ind ) == 0 )
      return 0;
   lua_getfield( L, LUA_REGISTRYINDEX, PILOTOUTFIT_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 poL_slot( lua_State *L )
{
   PilotOutfitSlot      *po    = luaL_validpilotoutfit( L, 1 );
   const ShipOutfitSlot *sslot = po->sslot;
   const OutfitSlot     *slot  = &sslot->slot;
 
   /* make the slot table and put it in */
   lua_newtable( L );
 
   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 */
 
   return 1;
}

static int poL_outfit( lua_State *L )
{
   const PilotOutfitSlot *po = luaL_validpilotoutfit( L, 1 );
   lua_pushoutfit( L, po->outfit );
   return 1;
}

static int poL_state( lua_State *L )
{
   PilotOutfitSlot *po    = luaL_validpilotoutfit( L, 1 );
   const char      *state = luaL_optstring( L, 2, NULL );
   PilotOutfitState pos   = po->state;
 
   if ( !outfit_isMod( po->outfit ) ) {
      if ( outfit_isWeapon( po->outfit ) ) {
         if ( state == NULL || strcmp( state, "off" ) == 0 ) {
            po->flags &= ~( PILOTOUTFIT_DYNAMIC_FLAGS |
                            PILOTOUTFIT_ISON ); /* Clear toggles. */
         } else if ( strcmp( state, "on" ) == 0 ) {
            po->state = PILOT_OUTFIT_ON;
            po->flags |=
               PILOTOUTFIT_ISON |
               PILOTOUTFIT_ISON_TOGGLE; /* Gets disabled if ontoggle is set. */
         } else
            return NLUA_ERROR( L,
                               _( "'pilotoutfit.%s' only works with \"on\" and "
                                  "\"off\" for weapon outfits!" ),
                               "state" );
      } else
         return NLUA_ERROR(
            L,
            _( "'pilotoutfit.%s' only works with modifier or weapon outfits!" ),
            "state" );
   }
 
   if ( state == NULL || strcmp( state, "off" ) == 0 ) {
      po->state = PILOT_OUTFIT_OFF;
      po->flags &=
         ~( PILOTOUTFIT_DYNAMIC_FLAGS | PILOTOUTFIT_ISON ); /* Clear toggles. */
   } else if ( strcmp( state, "warmup" ) == 0 ) {
      po->state = PILOT_OUTFIT_WARMUP;
   } else if ( strcmp( state, "on" ) == 0 ) {
      if ( po->state != PILOT_OUTFIT_ON )
         po->flags |= PILOTOUTFIT_ISON | PILOTOUTFIT_ISON_TOGGLE;
      po->state = PILOT_OUTFIT_ON;
   } else if ( strcmp( state, "cooldown" ) == 0 ) {
      po->state = PILOT_OUTFIT_COOLDOWN;
      po->flags &=
         ~( PILOTOUTFIT_DYNAMIC_FLAGS | PILOTOUTFIT_ISON ); /* Clear toggles. */
   } else
      return NLUA_ERROR( L, _( "Unknown PilotOutfit state '%s'!" ), state );
 
   /* Mark as modified if state changed. */
   if ( pos != po->state )
      pilotoutfit_modified = 1;
 
   return 0;
}

static int poL_progress( lua_State *L )
{
   PilotOutfitSlot *po = luaL_validpilotoutfit( L, 1 );
 
   if ( !outfit_isMod( po->outfit ) )
      return NLUA_ERROR(
         L, _( "'pilotoutfit.%s' only works with modifier outfits!" ),
         "progress" );
 
   po->progress = CLAMP( 0., 1., luaL_checknumber( L, 2 ) );
   return 0;
}

static int poL_set( lua_State *L )
{
   PilotOutfitSlot *po    = luaL_validpilotoutfit( L, 1 );
   const char      *name  = luaL_checkstring( L, 2 );
   double           value = luaL_checknumber( L, 3 );
   po->lua_stats =
      ss_statsSetList( po->lua_stats, ss_typeFromName( name ), value, 1, 0 );
   pilotoutfit_modified = 1;
   return 0;
}

static int poL_clear( lua_State *L )
{
   PilotOutfitSlot *po = luaL_validpilotoutfit( L, 1 );
   ss_free( po->lua_stats );
   po->lua_stats        = NULL;
   pilotoutfit_modified = 1;
   return 0;
}
 
static Target lua_totarget( lua_State *L, int idx )
{
   Target t;
   /* Handle target. */
   if ( lua_isnoneornil( L, idx ) )
      t.type = TARGET_NONE;
   else if ( lua_ispilot( L, idx ) ) {
      t.type = TARGET_PILOT;
      t.u.id = lua_topilot( L, idx );
   } else if ( lua_isasteroid( L, idx ) ) {
      const LuaAsteroid_t *ast = lua_toasteroid( L, idx );
      t.type                   = TARGET_ASTEROID;
      t.u.ast.anchor           = ast->parent;
      t.u.ast.asteroid         = ast->id;
   } else if ( lua_ismunition( L, idx ) ) {
      const LuaMunition *lm = lua_tomunition( L, idx );
      t.type                = TARGET_WEAPON;
      t.u.id                = lm->id;
   } else {
      NLUA_INVALID_PARAMETER_NORET( L, idx );
      t.type = TARGET_NONE;
   }
   return t;
}

static int poL_munition( lua_State *L )
{
   PilotOutfitSlot *po    = luaL_validpilotoutfit( L, 1 );
   Pilot           *p     = luaL_validpilot( L, 2 );
   const Outfit    *o     = luaL_optoutfit( L, 3, po->outfit );
   Target           t     = lua_totarget( L, 4 );
   double           dir   = luaL_optnumber( L, 5, p->solid.dir );
   const vec2      *vp    = luaL_optvector( L, 6, &p->solid.pos );
   const vec2      *vv    = luaL_optvector( L, 7, &p->solid.vel );
   int              noaim = lua_toboolean( L, 8 );
   const Weapon    *w     = weapon_add( po, o, dir, vp, vv, p, &t, 0., !noaim );
   lua_pushmunition( L, w );
   return 1;
}

static int poL_shoot( lua_State *L )
{
   PilotOutfitSlot *po      = luaL_validpilotoutfit( L, 1 );
   Pilot           *p       = luaL_validpilot( L, 2 );
   Target           t       = lua_totarget( L, 3 );
   int              stagger = lua_toboolean( L, 4 );
   double           time;
   int              ret;
   int              has_ammo;
 
   /* The particular weapon can't fire, so ignore. */
   if ( po->timer > 0. ) {
      lua_pushboolean( L, 0 );
      return 1;
   }
 
   /* Out of ammo. */
   has_ammo =
      outfit_isLauncher( po->outfit ) || outfit_isFighterBay( po->outfit );
   if ( has_ammo && ( po->u.ammo.quantity <= 0 ) ) {
      lua_pushboolean( L, 0 );
      return 1;
   }
 
   /* See if we should stagger the outfits. */
   if ( stagger ) {
      double q, maxt, rate_mod, energy_mod;
      int    maxp, minh;
 
      /* Calculate rate modifier. */
      pilot_getRateMod( &rate_mod, &energy_mod, p, po->outfit );
 
      /* Find optimal outfit, coolest that can fire. */
      minh = -1;
      maxt = 0.;
      maxp = -1;
      q    = 0.;
      for ( int i = 0; i < array_size( p->outfits ); i++ ) {
         PilotOutfitSlot *pos = p->outfits[i];
         if ( pos->outfit != po->outfit )
            continue;
         /* Launcher only counts with ammo. */
         if ( has_ammo && ( pos->u.ammo.quantity <= 0 ) )
            continue;
         /* Get coolest that can fire. */
         if ( pos->timer <= 0. ) {
            if ( has_ammo ) {
               if ( ( minh < 0 ) || ( p->outfits[minh]->u.ammo.quantity <
                                      pos->u.ammo.quantity ) )
                  minh = i;
            } else {
               if ( ( minh < 0 ) || ( p->outfits[minh]->heat_T > pos->heat_T ) )
                  minh = i;
            }
         }
 
         /* Save some stuff. */
         if ( ( maxp < 0 ) || ( pos->timer > maxt ) ) {
            maxp = i;
            maxt = pos->timer;
         }
         q += 1.;
      }
 
      /* Only fire if the last weapon to fire fired more than (q-1)/q ago. */
      if ( ( minh < 0 ) || ( maxt > rate_mod * outfit_delay( po->outfit ) *
                                       ( ( q - 1. ) / q ) ) ) {
         lua_pushboolean( L, 0 );
         return 1;
      }
   }
 
   time = weapon_targetFlyTime( po->outfit, p, &t );
   ret  = pilot_shootWeapon( p, po, &t, time, -1 );
 
   lua_pushboolean( L, ret );
   return 1;
}

static int poL_heat( lua_State *L )
{
   PilotOutfitSlot *po = luaL_validpilotoutfit( L, 1 );
   if ( lua_isboolean( L, 2 ) )
      lua_pushnumber( L, po->heat_T );
   else
      lua_pushnumber( L, pilot_heatEfficiencyMod( po->heat_T,
                                                  po->outfit->overheat_min,
                                                  po->outfit->overheat_max ) );
   return 1;
}

static int poL_heatup( lua_State *L )
{
   PilotOutfitSlot *po   = luaL_validpilotoutfit( L, 1 );
   double           heat = luaL_checknumber( L, 2 );
   po->heat_T += heat / po->heat_C;
   /* Enforce a minimum value as a safety measure. */
   po->heat_T = MAX( po->heat_T, CONST_SPACE_STAR_TEMP );
   return 0;
}