nlua_jump.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <lauxlib.h>
 
#include "naev.h"
 
#include "nlua_jump.h"
 
#include "land_outfits.h"
#include "map_overlay.h"
#include "nlua_pilot.h"
#include "nlua_system.h"
#include "nlua_vec2.h"
#include "nluadef.h"
 
RETURNS_NONNULL static JumpPoint *luaL_validjumpSystem( lua_State *L, int ind,
                                                        int *offset );
 
/* Jump metatable methods */
static int jumpL_get( lua_State *L );
static int jumpL_eq( lua_State *L );
static int jumpL_tostring( lua_State *L );
static int jumpL_reverse( lua_State *L );
static int jumpL_radius( lua_State *L );
static int jumpL_position( lua_State *L );
static int jumpL_angle( lua_State *L );
static int jumpL_hide( lua_State *L );
static int jumpL_hidden( lua_State *L );
static int jumpL_exitonly( lua_State *L );
static int jumpL_system( lua_State *L );
static int jumpL_dest( lua_State *L );
static int jumpL_jumpDist( lua_State *L );
static int jumpL_isKnown( lua_State *L );
static int jumpL_setKnown( lua_State *L );
 
static const luaL_Reg jump_methods[] = {
   { "get", jumpL_get },
   { "__eq", jumpL_eq },
   { "__tostring", jumpL_tostring },
   { "reverse", jumpL_reverse },
   { "radius", jumpL_radius },
   { "pos", jumpL_position },
   { "angle", jumpL_angle },
   { "hide", jumpL_hide },
   { "hidden", jumpL_hidden },
   { "exitonly", jumpL_exitonly },
   { "system", jumpL_system },
   { "dest", jumpL_dest },
   { "jumpDist", jumpL_jumpDist },
   { "known", jumpL_isKnown },
   { "setKnown", jumpL_setKnown },
   { 0, 0 } }; 

int nlua_loadJump( nlua_env env )
{
   nlua_register( env, JUMP_METATABLE, jump_methods, 1 );
   return 0; /* No error */
}

LuaJump *lua_tojump( lua_State *L, int ind )
{
   return (LuaJump *)lua_touserdata( L, ind );
}

LuaJump *luaL_checkjump( lua_State *L, int ind )
{
   if ( lua_isjump( L, ind ) )
      return lua_tojump( L, ind );
   luaL_typerror( L, ind, JUMP_METATABLE );
   return NULL;
}

static JumpPoint *luaL_validjumpSystem( lua_State *L, int ind, int *offset )
{
   JumpPoint  *jp;
   StarSystem *a, *b;
 
   /* Defaults. */
   jp = NULL;
   a  = NULL;
   b  = NULL;
 
   if ( lua_isjump( L, ind ) ) {
      const LuaJump *lj = luaL_checkjump( L, ind );
      a                 = system_getIndex( lj->srcid );
      b                 = system_getIndex( lj->destid );
      if ( offset != NULL )
         *offset = 1;
   } else if ( lua_gettop( L ) > 1 ) {
      if ( lua_isstring( L, ind ) )
         a = system_get( lua_tostring( L, ind ) );
      else if ( lua_issystem( L, ind ) )
         a = system_getIndex( lua_tosystem( L, ind ) );
 
      if ( lua_isstring( L, ind + 1 ) )
         b = system_get( lua_tostring( L, ind + 1 ) );
      else if ( lua_issystem( L, ind + 1 ) )
         b = system_getIndex( lua_tosystem( L, ind + 1 ) );
 
      if ( offset != NULL )
         *offset = 2;
   } else {
      luaL_typerror( L, ind, JUMP_METATABLE );
      // noreturn
   }
 
   if ( ( b != NULL ) && ( a != NULL ) )
      jp = jump_getTarget( b, a );
 
   if ( jp == NULL )
      NLUA_ERROR( L, _( "Jump is invalid" ) );
 
   return jp;
}

JumpPoint *luaL_validjump( lua_State *L, int ind )
{
   return luaL_validjumpSystem( L, ind, NULL );
}

LuaJump *lua_pushjump( lua_State *L, LuaJump jump )
{
   LuaJump *j = (LuaJump *)lua_newuserdata( L, sizeof( LuaJump ) );
   *j         = jump;
   luaL_getmetatable( L, JUMP_METATABLE );
   lua_setmetatable( L, -2 );
   return j;
}

int lua_isjump( lua_State *L, int ind )
{
   int ret;
 
   if ( lua_getmetatable( L, ind ) == 0 )
      return 0;
   lua_getfield( L, LUA_REGISTRYINDEX, JUMP_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 jumpL_get( lua_State *L )
{
   const StarSystem *a = luaL_validsystem( L, 1 );
   const StarSystem *b = luaL_validsystem( L, 2 );
 
   if ( ( a == NULL ) || ( b == NULL ) )
      return NLUA_ERROR( L, _( "No matching jump points found." ) );
 
   if ( jump_getTarget( b, a ) != NULL ) {
      LuaJump lj;
      lj.srcid  = a->id;
      lj.destid = b->id;
      lua_pushjump( L, lj );
 
      /* The inverse. If it doesn't exist, there are bigger problems. */
      lj.srcid  = b->id;
      lj.destid = a->id;
      lua_pushjump( L, lj );
      return 2;
   }
 
   return 0;
}

static int jumpL_eq( lua_State *L )
{
   const LuaJump *a = luaL_checkjump( L, 1 );
   const LuaJump *b = luaL_checkjump( L, 2 );
   lua_pushboolean(
      L, ( ( a->srcid == b->srcid ) && ( a->destid == b->destid ) ) );
   return 1;
}

static int jumpL_tostring( lua_State *L )
{
   char              buf[STRMAX_SHORT];
   const LuaJump    *lj  = luaL_checkjump( L, 1 );
   const StarSystem *src = system_getIndex( lj->srcid );
   const StarSystem *dst = system_getIndex( lj->destid );
   snprintf( buf, sizeof( buf ), _( "Jump( %s -> %s )" ), _( src->name ),
             _( dst->name ) );
   lua_pushstring( L, buf );
   return 1;
}

static int jumpL_reverse( lua_State *L )
{
   LuaJump        ret;
   const LuaJump *lj = luaL_checkjump( L, 1 );
   ret.srcid         = lj->destid;
   ret.destid        = lj->srcid;
   lua_pushjump( L, ret );
   return 1;
}

static int jumpL_radius( lua_State *L )
{
   const JumpPoint *jp = luaL_validjump( L, 1 );
   lua_pushnumber( L, jp->radius );
   return 1;
}

static int jumpL_position( lua_State *L )
{
   const JumpPoint *jp = luaL_validjump( L, 1 );
   lua_pushvector( L, jp->pos );
   return 1;
}

static int jumpL_hide( lua_State *L )
{
   const JumpPoint *jp = luaL_validjump( L, 1 );
   lua_pushnumber( L, jp->hide );
   return 1;
}

static int jumpL_angle( lua_State *L )
{
   const JumpPoint *jp = luaL_validjump( L, 1 );
   lua_pushnumber( L, jp->angle );
   return 1;
}

static int jumpL_hidden( lua_State *L )
{
   const JumpPoint *jp = luaL_validjump( L, 1 );
   lua_pushboolean( L, jp_isFlag( jp, JP_HIDDEN ) );
   return 1;
}

static int jumpL_exitonly( lua_State *L )
{
   const JumpPoint *jp = luaL_validjump( L, 1 );
   lua_pushboolean( L, jp_isFlag( jp, JP_EXITONLY ) );
   return 1;
}

static int jumpL_system( lua_State *L )
{
   const JumpPoint *jp = luaL_validjumpSystem( L, 1, NULL );
   lua_pushsystem( L, jp->from->id );
   return 1;
}

static int jumpL_dest( lua_State *L )
{
   const JumpPoint *jp = luaL_validjump( L, 1 );
   lua_pushsystem( L, jp->targetid );
   return 1;
}

static int jumpL_jumpDist( lua_State *L )
{
   const JumpPoint *jp = luaL_validjump( L, 1 );
   const Pilot     *p  = luaL_validpilot( L, 2 );
   lua_pushnumber( L, space_jumpDistance( p, jp ) );
   return 1;
}

static int jumpL_isKnown( lua_State *L )
{
   const JumpPoint *jp = luaL_validjump( L, 1 );
   lua_pushboolean( L, jp_isKnown( jp ) );
   return 1;
}

static int jumpL_setKnown( lua_State *L )
{
   int        b, offset, changed;
   JumpPoint *jp;
 
   offset = 0;
   jp     = luaL_validjumpSystem( L, 1, &offset );
 
   /* True if boolean isn't supplied. */
   if ( lua_gettop( L ) > offset )
      b = lua_toboolean( L, 1 + offset );
   else
      b = 1;
 
   changed = ( ( b != (int)jp_isKnown( jp ) ) ||
               ( b != (int)jp_isKnown( jp->returnJump ) ) );
 
   if ( b ) {
      jp_setFlag( jp, JP_KNOWN );
      jp_setFlag( jp->returnJump, JP_KNOWN );
   } else {
      jp_rmFlag( jp, JP_KNOWN );
      jp_rmFlag( jp->returnJump, JP_KNOWN );
   }
 
   if ( changed ) {
      /* Update overlay. */
      ovr_refresh();
      /* Update outfits image array - in the case it changes map owned status.
       */
      outfits_updateEquipmentOutfits();
   }
 
   return 0;
}