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 "nluadef.h"
#include "nlua_vec2.h"
#include "nlua_pilot.h"
#include "nlua_system.h"
#include "land_outfits.h"
#include "map_overlay.h"
#include "log.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_radius( lua_State *L );
static int jumpL_position( lua_State *L );
static int jumpL_angle( 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 },
   { "radius", jumpL_radius },
   { "pos", jumpL_position },
   { "angle", jumpL_angle },
   { "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 )
{
   StarSystem *a, *b;
 
   a = luaL_validsystem(L,1);
   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 )
{
   LuaJump *a, *b;
   a = luaL_checkjump(L,1);
   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_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_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;
}