nlua_evt.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
 
#include "naev.h"
#include "nlua_evt.h"
 
#include "event.h"
#include "land.h"
#include "log.h"
#include "mission.h"
#include "ndata.h"
#include "nlua.h"
#include "nlua_hook.h"
#include "nlua_system.h"
#include "nlua_tex.h"
#include "nluadef.h"
#include "npc.h"
#include "nstring.h"
#include "player.h"
 
/*
 * libraries
 */
/* evt */
static int evtL_npcAdd( lua_State *L );
static int evtL_npcRm( lua_State *L );
static int evtL_finish( lua_State *L );
static int evtL_save( lua_State *L );
static int evtL_claim( lua_State *L );
static const luaL_Reg evtL_methods[] = {
   { "npcAdd", evtL_npcAdd },
   { "npcRm", evtL_npcRm },
   { "save", evtL_save },
   { "finish", evtL_finish },
   { "claim", evtL_claim },
   {0,0}
}; 
/*
 * individual library loading
 */
int nlua_loadEvt( nlua_env env )
{
   nlua_register(env, "evt", evtL_methods, 0);
   return 0;
}
 
void event_runStart( unsigned int eventid, const char *func )
{
   uintptr_t *evptr;
   Event_t *ev = event_get( eventid );
   if (ev == NULL)
      return;
 
   /* Set up event pointer. */
   evptr = lua_newuserdata( naevL, sizeof(Event_t*) );
   *evptr = ev->id;
   nlua_setenv( naevL, ev->env, "__evt" );
 
   /* Get function. */
   nlua_getenv( naevL, ev->env, func );
}
 
int event_run( unsigned int eventid, const char *func )
{
   int ret;
   event_runStart( eventid, func );
   ret = event_runFunc( eventid, func, 0 );
   return ret;
}
 
Event_t *event_getFromLua( lua_State *L )
{
   Event_t *ev;
   uintptr_t *evptr;
   nlua_getenv( L, __NLUA_CURENV, "__evt" );
   evptr = lua_touserdata( L, -1 );
   ev = evptr ? event_get( *evptr ) : NULL;
   lua_pop( L, 1 );
   return ev;
}
 
int event_runFunc( unsigned int eventid, const char *func, int nargs )
{
   int ret;
   const char* err;
   int evt_delete;
   Event_t *ev;
 
   ev = event_get( eventid );
   if (ev == NULL)
      return 0;
 
   ret = nlua_pcall(ev->env, nargs, 0);
   if (ret != 0) { /* error has occurred */
      err = (lua_isstring(naevL,-1)) ? lua_tostring(naevL,-1) : NULL;
      if ((err==NULL) || (strcmp(err,NLUA_DONE)!=0)) {
         WARN(_("Event '%s' -> '%s': %s"),
               event_getData(ev->id), func, (err) ? err : _("unknown error"));
         ret = -1;
      }
      else
         ret = 1;
      lua_pop(naevL, 1);
   }
 
   /* Time to remove the event. */
   ev = event_get( eventid );  /* The Lua call may have invalidated the pointer. */
   nlua_getenv(naevL, ev->env, "__evt_delete");
   evt_delete = lua_toboolean(naevL,-1);
   lua_pop(naevL,1);
   if (evt_delete) {
      ret = 2;
      event_remove( ev->id );
   }
 
   return ret;
}
 
static int evtL_npcAdd( lua_State *L )
{
   unsigned int id;
   int priority;
   const char *func, *name, *desc;
   glTexture *portrait, *bg;
   Event_t *cur_event;
 
   /* Handle parameters. */
   func = luaL_checkstring(L, 1);
   name = luaL_checkstring(L, 2);
   portrait = luaL_validtex(L, 3, GFX_PATH"portraits/");
   desc = luaL_checkstring(L, 4);
 
   /* Optional parameters. */
   priority = luaL_optinteger(L,5,5);
   if (!lua_isnoneornil(L,6))
      bg = luaL_validtex(L,6,GFX_PATH"portraits/");
   else
      bg = NULL;
 
   cur_event = event_getFromLua(L);
 
   /* Add npc. */
   id = npc_add_event( cur_event->id, func, name, priority, portrait, desc, bg );
 
   bar_regen();
 
   /* Return ID. */
   if (id > 0) {
      lua_pushnumber( L, id );
      return 1;
   }
   return 0;
}
 
static int evtL_npcRm( lua_State *L )
{
   unsigned int id;
   int ret;
   Event_t *cur_event;
 
   id = luaL_checklong(L, 1);
 
   cur_event = event_getFromLua(L);
   ret = npc_rm_event( id, cur_event->id );
 
   bar_regen();
 
   if (ret != 0)
      NLUA_ERROR(L, _("Invalid NPC ID!"));
   return 0;
}
 
static int evtL_finish( lua_State *L )
{
   Event_t *cur_event = event_getFromLua(L);
   int b = lua_toboolean(L,1);
   lua_pushboolean( L, 1 );
   nlua_setenv( L, cur_event->env, "__evt_delete" );
 
   if (b && event_isUnique(cur_event->id))
      player_eventFinished( cur_event->data );
 
   lua_pushstring(L, NLUA_DONE);
   lua_error(L); /* shouldn't return */
 
   return 0;
}
 
static int evtL_save( lua_State *L )
{
   int b;
   Event_t *cur_event = event_getFromLua(L);
   if (lua_gettop(L)==0)
      b = 1;
   else
      b = lua_toboolean(L,1);
   cur_event->save = b;
   return 0;
}
 
static int evtL_claim( lua_State *L )
{
   Claim_t *claim;
   Event_t *cur_event;
   int onlytest, inclusive;
 
   /* Get current event. */
   cur_event = event_getFromLua(L);
 
   onlytest = lua_toboolean(L,2);
   inclusive = lua_toboolean(L,3);
 
   /* Check to see if already claimed. */
   if (!onlytest && (cur_event->claims != NULL)) {
      NLUA_ERROR(L, _("Event trying to claim but already has."));
      return 0;
   }
 
   /* Create the claim. */
   claim = claim_create( !inclusive );
 
   /* Handle parameters. */
   if (lua_istable(L,1)) {
      /* Iterate over table. */
      lua_pushnil(L);
      while (lua_next(L, 1) != 0) {
         if (lua_issystem(L,-1))
            claim_addSys( claim, lua_tosystem( L, -1 ) );
         else if (lua_isstring(L,-1))
            claim_addStr( claim, lua_tostring( L, -1 ) );
         lua_pop(L,1);
      }
   }
   else if (lua_issystem(L, 1))
      claim_addSys( claim, lua_tosystem( L, 1 ) );
   else if (lua_isstring(L, 1))
      claim_addStr( claim, lua_tostring( L, 1 ) );
   else
      NLUA_INVALID_PARAMETER(L);
 
   /* Only test, but don't apply case. */
   if (onlytest) {
      lua_pushboolean( L, !claim_test( claim ) );
      claim_destroy( claim );
      return 1;
   }
 
   /* Test claim. */
   if (claim_test( claim )) {
      claim_destroy( claim );
      lua_pushboolean(L,0);
      return 1;
   }
 
   /* Set the claim. */
   cur_event->claims = claim;
   claim_activate( claim );
   lua_pushboolean(L,1);
   return 1;
}