nlua_asteroid.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <lauxlib.h>
 
#include "naev.h"
#include "nlua_asteroid.h"
 
#include "array.h"
#include "space.h"
#include "nluadef.h"
#include "nlua_vec2.h"
#include "nlua_commodity.h"
#include "nlua_pilot.h"
 
/* Asteroid methods. */
static int asteroidL_eq( lua_State *L );
static int asteroidL_getAll( lua_State *L );
static int asteroidL_get( lua_State *L );
static int asteroidL_exists( lua_State *L );
static int asteroidL_state( lua_State *L );
static int asteroidL_setState( lua_State *L );
static int asteroidL_field( lua_State *L );
static int asteroidL_pos( lua_State *L );
static int asteroidL_vel( lua_State *L );
static int asteroidL_setPos( lua_State *L );
static int asteroidL_setVel( lua_State *L );
static int asteroidL_scanned( lua_State *L );
static int asteroidL_timer( lua_State *L );
static int asteroidL_setTimer( lua_State *L );
static int asteroidL_armour( lua_State *L );
static int asteroidL_setArmour( lua_State *L );
static int asteroidL_alertRange( lua_State *L );
static int asteroidL_materials( lua_State *L );
static const luaL_Reg asteroidL_methods[] = {
   { "__eq", asteroidL_eq },
   { "getAll", asteroidL_getAll },
   { "get", asteroidL_get },
   { "exists", asteroidL_exists },
   { "state", asteroidL_state },
   { "setState", asteroidL_setState },
   { "field", asteroidL_field },
   { "pos", asteroidL_pos },
   { "vel", asteroidL_vel },
   { "setPos", asteroidL_setPos },
   { "setVel", asteroidL_setVel },
   { "scanned", asteroidL_scanned },
   { "timer", asteroidL_timer },
   { "setTimer", asteroidL_setTimer },
   { "armour", asteroidL_armour },
   { "setArmour", asteroidL_setArmour },
   { "alertRange", asteroidL_alertRange },
   { "materials", asteroidL_materials },
   {0,0}
}; 
int nlua_loadAsteroid( nlua_env env )
{
   nlua_register(env, ASTEROID_METATABLE, asteroidL_methods, 1);
   return 0;
}
 
LuaAsteroid_t* lua_toasteroid( lua_State *L, int ind )
{
   return (LuaAsteroid_t*) lua_touserdata(L,ind);
}
LuaAsteroid_t* luaL_checkasteroid( lua_State *L, int ind )
{
   if (lua_isasteroid(L,ind))
      return lua_toasteroid(L,ind);
   luaL_typerror(L, ind, ASTEROID_METATABLE);
   return NULL;
}
Asteroid* luaL_validasteroid( lua_State *L, int ind )
{
   Asteroid *a;
   if (lua_isasteroid(L, ind)) {
      const LuaAsteroid_t *la = luaL_checkasteroid(L, ind);
#if DEBUGGING
      if ((la->parent < 0) || (la->parent >= array_size(cur_system->asteroids))) {
         NLUA_ERROR(L,_("Asteroid field '%d' is out of range!"),la->parent);
         return NULL;
      }
#endif /* DEBUGGING */
      AsteroidAnchor *field = &cur_system->asteroids[ la->parent ];
#if DEBUGGING
      if ((la->id < 0) || (la->id >= field->nb)) {
         NLUA_ERROR(L,_("Asteroid '%d' in field '%d' is out of range!"),la->id,la->parent);
         return NULL;
      }
#endif /* DEBUGGING */
      a = &field->asteroids[ la->id ];
   }
   else {
      luaL_typerror(L, ind, ASTEROID_METATABLE);
      return NULL;
   }
 
   if (a == NULL) {
      NLUA_ERROR(L, _("Asteroid is invalid"));
      return NULL;
   }
 
   return a;
}
LuaAsteroid_t* lua_pushasteroid( lua_State *L, LuaAsteroid_t asteroid )
{
   LuaAsteroid_t *la = (LuaAsteroid_t*) lua_newuserdata(L, sizeof(LuaAsteroid_t));
   *la = asteroid;
   luaL_getmetatable(L, ASTEROID_METATABLE);
   lua_setmetatable(L, -2);
   return la;
}
int lua_isasteroid( lua_State *L, int ind )
{
   int ret;
 
   if (lua_getmetatable(L,ind)==0)
      return 0;
   lua_getfield(L, LUA_REGISTRYINDEX, ASTEROID_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 asteroidL_eq( lua_State *L )
{
   LuaAsteroid_t *a1, *a2;
   a1 = luaL_checkasteroid(L,1);
   a2 = luaL_checkasteroid(L,2);
   lua_pushboolean( L, (memcmp( a1, a2, sizeof(LuaAsteroid_t) )==0) );
   return 1;
}
 
static int asteroidL_getAll( lua_State *L )
{
   int n = 1;
   lua_newtable(L);
   for (int i=0; i<array_size(cur_system->asteroids); i++) {
      const AsteroidAnchor *ast = &cur_system->asteroids[i];
      for (int j=0; j<ast->nb; j++) {
         const Asteroid *a = &ast->asteroids[j];
         LuaAsteroid_t la = {
            .parent = a->parent,
            .id = a->id,
         };
 
         lua_pushasteroid( L, la );
         lua_rawseti( L, -2, n++ );
      }
   }
 
   return 1;
}
 
static int asteroidL_get( lua_State *L )
{
   LuaAsteroid_t la;
   int field = -1;
   const vec2 *pos = NULL;
 
   /* No asteroids, so everything just returns nil. */
   if (array_size(cur_system->asteroids) <= 0)
      return 0;
 
   if (lua_isvector(L,1))
      pos = lua_tovector(L,1);
 
   else if (lua_ispilot(L,1))
      pos = &luaL_validpilot(L,1)->solid.pos;
 
   else if (lua_isnoneornil(L,1)) {
      int max_field = array_size(cur_system->asteroids) - 1;
      field = (max_field < 0 ? max_field : RNG(0, max_field));
   }
   else if (lua_isnumber(L,1)) {
      field = luaL_checkinteger(L,1)-1;
      if ((field < 0) || (field >= array_size(cur_system->asteroids)))
         NLUA_INVALID_PARAMETER(L,1);
   }
   else
      NLUA_INVALID_PARAMETER(L,1);
 
   /* Get random asteroid. */
   if ((pos==NULL) && (field >= 0)) {
      /* Random asteroid. */
      int ast   = RNG(0,cur_system->asteroids[field].nb-1);
      int bad_asteroid = 0;
      Asteroid *a = &cur_system->asteroids[field].asteroids[ast];
 
      if (a->state != ASTEROID_FG) {
         /* Switch to next index until we find a valid one, or until we come full-circle. */
         bad_asteroid = 1;
         for (int i=0; i<cur_system->asteroids[field].nb; i++) {
            ast = (ast+1) % cur_system->asteroids[field].nb;
            a = &cur_system->asteroids[field].asteroids[ast];
            if (a->state == ASTEROID_FG) {
               bad_asteroid = 0;
               break;
            }
         }
      }
 
      if (bad_asteroid)
         return 0;
 
      la.parent = field;
      la.id = ast;
      lua_pushasteroid(L,la);
      return 1;
   }
 
   /* Try to find nearest asteroid. */
   Asteroid *a_closest = NULL;
   double dist2 = HUGE_VAL;
   for (int i=0; i<array_size(cur_system->asteroids); i++) {
      AsteroidAnchor *ast = &cur_system->asteroids[i];
      for (int j=0; j<ast->nb; j++) {
         double d2;
         Asteroid *a = &ast->asteroids[j];
 
         if (a->state != ASTEROID_FG)
            continue;
 
         d2 = vec2_dist2( pos, &a->sol.pos );
         if (d2 > dist2)
            continue;
 
         a_closest = a;
         dist2 = d2;
      }
   }
   if (a_closest==NULL)
      return 0;
 
   /* Got an asteroid, ship it. */
   la.parent = a_closest->parent;
   la.id     = a_closest->id;
   lua_pushasteroid(L,la);
   return 1;
}
 
static int asteroidL_exists( lua_State *L )
{
   if (!lua_isasteroid(L, 1)) {
      lua_pushboolean(L, 0);
      return 1;
   }
 
   const LuaAsteroid_t *la = luaL_checkasteroid(L, 1);
   if ((la->parent < 0) || (la->parent >= array_size(cur_system->asteroids))) {
      lua_pushboolean(L, 0);
      return 1;
   }
 
   AsteroidAnchor *field = &cur_system->asteroids[ la->parent ];
   if ((la->id < 0) || (la->id >= field->nb)) {
      lua_pushboolean(L, 0);
      return 1;
   }
 
   const Asteroid *a = &field->asteroids[ la->id ];
   lua_pushboolean(L, (a->state==ASTEROID_FG));
   return 1;
}
 
static int asteroidL_state( lua_State *L )
{
   const Asteroid *ast = luaL_validasteroid(L,1);
   const char *state = NULL;
   switch (ast->state) {
      case ASTEROID_FG:
         state = "FG";
         break;
      case ASTEROID_XB:
         state = "XB";
         break;
      case ASTEROID_BX:
         state = "BX";
         break;
      case ASTEROID_XX_TO_BG:
         state = "XX_TO_BG";
         break;
      case ASTEROID_FG_TO_BG:
         state = "FG_TO_BG";
         break;
      case ASTEROID_BG_TO_FG:
         state = "BG_TO_FG";
         break;
      case ASTEROID_BG_TO_XX:
         state = "BG_TO_XX";
         break;
      case ASTEROID_XX:
         state = "XX";
         break;
   }
   lua_pushstring( L, state );
   return 1;
}
 
static int asteroidL_setState( lua_State *L )
{
   Asteroid *ast = luaL_validasteroid(L,1);
   const char *state = luaL_checkstring(L,2);
   if (strcmp(state,"FG")==0)
      ast->state = ASTEROID_FG;
   else if (strcmp(state,"XB")==0)
      ast->state = ASTEROID_XB;
   else if (strcmp(state,"BX")==0)
      ast->state = ASTEROID_BX;
   else if (strcmp(state,"XX_TO_BG")==0)
      ast->state = ASTEROID_XX_TO_BG;
   else if (strcmp(state,"FG_TO_BG")==0)
      ast->state = ASTEROID_FG_TO_BG;
   else if (strcmp(state,"BG_TO_FG")==0)
      ast->state = ASTEROID_BG_TO_FG;
   else if (strcmp(state,"BG_TO_XX")==0)
      ast->state = ASTEROID_BG_TO_XX;
   else if (strcmp(state,"XX")==0)
      ast->state = ASTEROID_XX;
   else
      NLUA_INVALID_PARAMETER(L,2);
   return 0;
}
 
static int asteroidL_field( lua_State *L )
{
   const LuaAsteroid_t *la = luaL_checkasteroid(L,1);
   lua_pushinteger(L,la->parent+1);
   return 1;
}
 
static int asteroidL_pos( lua_State *L )
{
   const Asteroid *a = luaL_validasteroid(L,1);
   lua_pushvector(L,a->sol.pos);
   return 1;
}
 
static int asteroidL_vel( lua_State *L )
{
   const Asteroid *a = luaL_validasteroid(L,1);
   lua_pushvector(L,a->sol.vel);
   return 1;
}
 
static int asteroidL_setPos( lua_State *L )
{
   Asteroid *a = luaL_validasteroid(L,1);
   const vec2 *v = luaL_checkvector(L,2);
   a->sol.pos = *v;
   return 0;
}
 
static int asteroidL_setVel( lua_State *L )
{
   Asteroid *a = luaL_validasteroid(L,1);
   const vec2 *v = luaL_checkvector(L,2);
   a->sol.vel = *v;
   return 0;
}
 
static int asteroidL_scanned( lua_State *L )
{
   const Asteroid *a = luaL_validasteroid(L,1);
   lua_pushboolean(L,a->scanned);
   return 1;
}
 
static int asteroidL_timer( lua_State *L )
{
   const Asteroid *a = luaL_validasteroid(L,1);
   lua_pushnumber(L,a->timer);
   lua_pushnumber(L,a->timer_max);
   return 2;
}
 
static int asteroidL_setTimer( lua_State *L )
{
   Asteroid *a = luaL_validasteroid(L,1);
   a->timer = luaL_checknumber(L,2);
   a->timer_max = MAX( a->timer_max, a->timer );
   return 0;
}
 
static int asteroidL_armour( lua_State *L )
{
   const Asteroid *a = luaL_validasteroid(L,1);
   lua_pushnumber(L,a->armour);
   return 1;
}
 
static int asteroidL_setArmour( lua_State *L )
{
   Asteroid *a = luaL_validasteroid(L,1);
   a->armour = luaL_checknumber(L,2);
   if (a->armour <= 0.)
      asteroid_explode( a, -1, 0. );
   return 0;
}
 
static int asteroidL_alertRange( lua_State *L )
{
   Asteroid *a = luaL_validasteroid(L,1);
   lua_pushnumber(L,a->type->alert_range);
   return 1;
}
 
static int asteroidL_materials( lua_State *L )
{
   Asteroid *a = luaL_validasteroid(L,1);
   const AsteroidType *at = a->type;
 
   lua_newtable(L);
   for (int i=0; i<array_size(at->material); i++) {
      const AsteroidReward *mat = &at->material[i];
      lua_newtable(L);
 
      lua_pushcommodity( L, mat->material );
      lua_setfield(L,-2,"commodity");
 
      lua_pushnumber( L, mat->quantity );
      lua_setfield(L,-2,"quantity");
 
      lua_pushnumber( L, mat->rarity );
      lua_setfield(L,-2,"rarity");
 
      lua_rawseti( L, -2, i+1 );
   }
 
   return 1;
}