nlua_evt.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <stdio.h>
#include <stdlib.h>
 
#include "nlua_evt.h"
 
#include "event.h"
#include "land.h"
#include "log.h"
#include "ndata.h"
#include "nlua.h"
#include "nlua_system.h"
#include "nlua_tex.h"
#include "nluadef.h"
#include "npc.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;
   const 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;
   int      evt_delete;
   Event_t *ev = event_get( eventid );
   if ( ev == NULL )
      return 0;
 
   ret = nlua_pcall( ev->env, nargs, 0 );
   if ( ret != 0 ) { /* error has occurred */
      const char *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. */
   if ( ev == NULL ) {
      WARN( _( "Event deleted in middle of hook call! Likely caused by another "
               "hook finishing the event triggered by this hook (\"%s\")." ),
            func );
      return -1;
   }
   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 )
      return NLUA_ERROR( L, _( "Invalid NPC ID!" ) );
   return 0;
}

static int evtL_finish( lua_State *L )
{
   const 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      inclusive;
 
   /* Get current event. */
   cur_event = event_getFromLua( L );
 
   inclusive = lua_toboolean( L, 2 );
 
   /* Check to see if already claimed. */
   if ( !claim_isNull( cur_event->claims ) )
      return NLUA_ERROR( L, _( "Event trying to claim but already has." ) );
 
   /* 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, 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;
}