hook.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <stdlib.h>
 
#include "naev.h"
 
#include "hook.h"
 
#include "array.h"
#include "claim.h"
#include "event.h"
#include "log.h"
#include "menu.h"
#include "mission.h"
#include "nlua_commodity.h"
#include "nlua_evt.h"
#include "nlua_hook.h"
#include "nlua_outfit.h"
#include "nlua_pilot.h"
#include "nlua_ship.h"
#include "player.h"
#include "space.h"

typedef struct HookQueue_s {
   struct HookQueue_s *next;                   
   char               *stack;                  
   unsigned int        id;                     
   HookParam           hparam[HOOK_MAX_PARAM]; 
} HookQueue_t;
static HookQueue_t *hook_queue = NULL; 
static int     hook_atomic = 0; 
static ntime_t hook_time_accum = 0; 

typedef enum HookType_e {
   HOOK_TYPE_NULL,  
   HOOK_TYPE_MISN,  
   HOOK_TYPE_EVENT, 
   HOOK_TYPE_FUNC   
} HookType_t;

typedef struct Hook_ {
   struct Hook_ *next; 
 
   unsigned int id;      
   char        *stack;   
   int          created; 
   int delete;           
   int ran_once; 
   int once;     
 
   /* Timer information. */
   int    is_timer; 
   double ms;       
 
   /* Date information. */
   int     is_date; 
   ntime_t res;     
   ntime_t acc;     
 
   HookType_t type; 
   union {
      struct {
         unsigned int parent; 
         char        *func;   
      } misn;                 
      struct {
         unsigned int parent; 
         char        *func;   
      } event;                
      struct {
         int ( *func )( void * );
         void *data;
      } func;
   } u; 
} Hook;
 
/*
 * the stack
 */
static unsigned int hook_id           = 0;    
static Hook        *hook_list         = NULL; 
static int          hook_runningstack = 0;    
static int hook_loadingstack = 0; 
 
/*
 * prototypes
 */
/* Execution. */
static int  hooks_executeParam( const char *stack, const HookParam *param );
static void hooks_updateDateExecute( ntime_t change );
/* intern */
static void         hook_rmRaw( Hook *h );
static void         hooks_purgeList( void );
static Hook        *hook_get( unsigned int id );
static unsigned int hook_genID( void );
static Hook        *hook_new( HookType_t type, const char *stack );
static int          hook_parseParam( const HookParam *param );
static int  hook_runMisn( Hook *hook, const HookParam *param, int claims );
static int  hook_runEvent( Hook *hook, const HookParam *param, int claims );
static int  hook_run( Hook *hook, const HookParam *param, int claims );
static void hook_free( Hook *h );
static int  hook_needSave( Hook *h );
static int  hook_parse( xmlNodePtr base );
/* externed */
int hook_save( xmlTextWriterPtr writer );
int hook_load( xmlNodePtr parent );
/* Misc. */
static Mission *hook_getMission( Hook *hook );

static int hq_add( HookQueue_t *hq )
{
   HookQueue_t *c;
 
   /* Set as head. */
   if ( hook_queue == NULL ) {
      hook_queue = hq;
      return 0;
   }
 
   /* Find tail. */
   for ( c = hook_queue; c->next != NULL; c = c->next )
      ;
   c->next = hq;
   return 0;
}

static void hq_free( HookQueue_t *hq )
{
   free( hq->stack );
   free( hq );
}

static void hq_clear( void )
{
   HookQueue_t *hq;
   while ( hook_queue != NULL ) {
      hq         = hook_queue;
      hook_queue = hq->next;
      hq_free( hq );
   }
}

void hook_exclusionStart( void )
{
   hook_atomic = 1;
}

void hook_exclusionEnd( double dt )
{
   HookQueue_t *hq;
   ntime_t      temp;
   hook_atomic = 0;
 
   /* Handle hook queue. */
   while ( hook_queue != NULL ) {
      /* Move hook down. */
      hq         = hook_queue;
      hook_queue = hq->next;
 
      /* Execute. */
      hooks_executeParam( hq->stack, hq->hparam );
 
      /* Clean up. */
      hq_free( hq );
   }
 
   /* Update timer hooks. */
   hooks_update( dt );
 
   /* Run assorted hooks. */
   if ( player.p !=
        NULL ) /* All these hooks rely on player actually existing. */
      player_runHooks();
 
   /* Time hooks. */
   temp            = hook_time_accum;
   hook_time_accum = 0;
   hooks_updateDateExecute( temp );
 
   /* Purge the dead. */
   hooks_purgeList();
}

static int hook_parseParam( const HookParam *param )
{
   int n;
 
   if ( param == NULL )
      return 0;
 
   n = 0;
   while ( param[n].type != HOOK_PARAM_SENTINEL ) {
      switch ( param[n].type ) {
      case HOOK_PARAM_NIL:
         lua_pushnil( naevL );
         break;
      case HOOK_PARAM_NUMBER:
         lua_pushnumber( naevL, param[n].u.num );
         break;
      case HOOK_PARAM_STRING:
         lua_pushstring( naevL, param[n].u.str );
         break;
      case HOOK_PARAM_BOOL:
         lua_pushboolean( naevL, param[n].u.b );
         break;
      case HOOK_PARAM_PILOT:
         lua_pushpilot( naevL, param[n].u.lp );
         break;
      case HOOK_PARAM_SHIP:
         lua_pushship( naevL, param[n].u.ship );
         break;
      case HOOK_PARAM_OUTFIT:
         lua_pushoutfit( naevL, param[n].u.outfit );
         break;
      case HOOK_PARAM_COMMODITY:
         lua_pushcommodity( naevL, param[n].u.commodity );
         break;
      case HOOK_PARAM_FACTION:
         lua_pushfaction( naevL, param[n].u.lf );
         break;
      case HOOK_PARAM_SSYS:
         lua_pushsystem( naevL, param[n].u.ls );
         break;
      case HOOK_PARAM_SPOB:
         lua_pushspob( naevL, param[n].u.la );
         break;
      case HOOK_PARAM_JUMP:
         lua_pushjump( naevL, param[n].u.lj );
         break;
      case HOOK_PARAM_REF:
         lua_rawgeti( naevL, LUA_REGISTRYINDEX, param[n].u.ref );
         break;
 
      default:
         WARN( _( "Unknown Lua parameter type." ) );
         lua_pushnil( naevL );
         break;
      }
      n++;
   }
 
   return n;
}

static int hook_runMisn( Hook *hook, const HookParam *param, int claims )
{
   unsigned int id;
   Mission     *misn;
   int          n;
 
   /* Simplicity. */
   id = hook->id;
 
   /* Make sure it's valid. */
   if ( hook->u.misn.parent == 0 ) {
      WARN( _( "Trying to run hook with nonexistent parent: deleting" ) );
      hook->delete = 1; /* so we delete it */
      return -1;
   }
 
   /* Locate the mission */
   misn = hook_getMission( hook );
   if ( misn == NULL ) {
      WARN( _( "Trying to run hook with parent not in player mission stack: "
               "deleting" ) );
      hook->delete = 1; /* so we delete it. */
      return -1;
   }
 
   /* Make sure it's claimed. */
   if ( ( claims > 0 ) &&
        ( claim_testSys( misn->claims, cur_system->id ) != claims ) )
      return 1;
 
   /* Delete if only supposed to run once. */
   if ( hook->once )
      hook_rmRaw( hook );
 
   /* Set up hook parameters. */
   misn_runStart( misn, hook->u.misn.func );
   n = hook_parseParam( param );
 
   /* Add hook parameters. */
   n += hookL_getarg( id );
 
   /* Run mission code. */
   hook->ran_once = 1;
   if ( misn_runFunc( misn, hook->u.misn.func, n ) <
        0 ) { /* error has occurred */
      WARN( _( "Hook [%s] '%d' -> '%s' failed" ), hook->stack, hook->id,
            hook->u.misn.func );
      /* Don't remove hooks on failure, or it can lead to stuck missions (like
       * rehab). */
      // hook_rmRaw( hook );
      return -1;
   }
   return 0;
}

static int hook_runEvent( Hook *hook, const HookParam *param, int claims )
{
   int ret, n, id;
 
   /* Simplicity. */
   id = hook->id;
 
   /* Must match claims. */
   if ( ( claims > 0 ) &&
        ( event_testClaims( hook->u.event.parent, cur_system->id ) != claims ) )
      return 1;
 
   /* Delete if only supposed to run once. */
   if ( hook->once )
      hook_rmRaw( hook );
 
   /* Set up hook parameters. */
   if ( event_get( hook->u.event.parent ) == NULL ) {
      WARN( _( "Hook [%s] '%d' -> '%s' failed, event does not exist. Deleting "
               "hook." ),
            hook->stack, id, hook->u.event.func );
      hook->delete = 1; /* Set for deletion. */
      return -1;
   }
 
   event_runStart( hook->u.event.parent, hook->u.event.func );
   n = hook_parseParam( param );
 
   /* Add hook parameters. */
   n += hookL_getarg( id );
 
   /* Run the hook. */
   ret = event_runFunc( hook->u.event.parent, hook->u.event.func, n );
   hook->ran_once = 1;
   if ( ret < 0 ) {
      WARN( _( "Hook [%s] '%d' -> '%s' failed" ), hook->stack, hook->id,
            hook->u.event.func );
      /* Don't remove hooks on failure, or it can lead to stuck missions (like
       * rehab). */
      // hook_rmRaw( hook );
      return -1;
   }
   return 0;
}

static int hook_run( Hook *hook, const HookParam *param, int claims )
{
   int ret;
 
   /* Do not run if pending deletion. */
   if ( hook->delete )
      return 0;
 
   /* Don't run anything when main menu is open. */
   if ( menu_isOpen( MENU_MAIN ) )
      return 0;
 
   switch ( hook->type ) {
   case HOOK_TYPE_MISN:
      ret = hook_runMisn( hook, param, claims );
      break;
 
   case HOOK_TYPE_EVENT:
      ret = hook_runEvent( hook, param, claims );
      break;
 
   case HOOK_TYPE_FUNC:
      /* We have to remove the hook first, so it doesn't get run again.
       * Note that the function will not do any checks nor has arguments, since
       * it is C-side. */
      if ( hook->once )
         hook->delete = 1;
      ret = hook->u.func.func( hook->u.func.data );
      break;
 
   default:
      WARN( _( "Invalid hook type '%d', deleting." ), hook->type );
      hook->delete = 1;
      return -1;
   }
 
   return ret;
}

static unsigned int hook_genID( void )
{
   unsigned int id = ++hook_id; /* default id, not safe if loading */
 
   /* If not loading we can just return. */
   if ( !hook_loadingstack )
      return id;
 
   /* Must check ids for collisions. */
   for ( Hook *h = hook_list; h != NULL; h = h->next )
      if ( id == h->id )      /* Check for collision. */
         return hook_genID(); /* recursively try again */
 
   return id;
}

static Hook *hook_new( HookType_t type, const char *stack )
{
   /* Get and create new hook. */
   Hook *new_hook = calloc( 1, sizeof( Hook ) );
   if ( hook_list == NULL )
      hook_list = new_hook;
   else {
      /* Put at front, O(1). */
      new_hook->next = hook_list;
      hook_list      = new_hook;
   }
 
   /* Fill out generic details. */
   new_hook->type    = type;
   new_hook->id      = hook_genID();
   new_hook->stack   = strdup( stack );
   new_hook->created = 1;

   if ( strcmp( stack, "safe" ) == 0 )
      new_hook->once = 1;
 
   return new_hook;
}

unsigned int hook_addMisn( unsigned int parent, const char *func,
                           const char *stack )
{
   /* Create the new hook. */
   Hook *new_hook = hook_new( HOOK_TYPE_MISN, stack );
 
   /* Put mission specific details. */
   new_hook->u.misn.parent = parent;
   new_hook->u.misn.func   = strdup( func );
 
   return new_hook->id;
}

unsigned int hook_addEvent( unsigned int parent, const char *func,
                            const char *stack )
{
   /* Create the new hook. */
   Hook *new_hook = hook_new( HOOK_TYPE_EVENT, stack );
 
   /* Put event specific details. */
   new_hook->u.event.parent = parent;
   new_hook->u.event.func   = strdup( func );
 
   return new_hook->id;
}

unsigned int hook_addTimerMisn( unsigned int parent, const char *func,
                                double ms )
{
   /* Create the new hook. */
   Hook *new_hook = hook_new( HOOK_TYPE_MISN, "timer" );
 
   /* Put mission specific details. */
   new_hook->u.misn.parent = parent;
   new_hook->u.misn.func   = strdup( func );
 
   /* Timer information. */
   new_hook->is_timer = 1;
   new_hook->ms       = ms;
 
   return new_hook->id;
}

unsigned int hook_addTimerEvt( unsigned int parent, const char *func,
                               double ms )
{
   /* Create the new hook. */
   Hook *new_hook = hook_new( HOOK_TYPE_EVENT, "timer" );
 
   /* Put event specific details. */
   new_hook->u.event.parent = parent;
   new_hook->u.event.func   = strdup( func );
 
   /* Timer information. */
   new_hook->is_timer = 1;
   new_hook->ms       = ms;
 
   return new_hook->id;
}

unsigned int hook_addTimerFunc( int ( *func )( void * ), void *data, double ms )
{
   Hook *new_hook = hook_new( HOOK_TYPE_FUNC, "timer" );
 
   /* Function special stuff. */
   new_hook->u.func.func = func;
   new_hook->u.func.data = data;
 
   /* Timer information. */
   new_hook->is_timer = 1;
   new_hook->ms       = ms;
 
   return new_hook->id;
}

unsigned int hook_addFunc( int ( *func )( void * ), void *data,
                           const char *stack )
{
   Hook *new_hook = hook_new( HOOK_TYPE_FUNC, stack );
 
   /* Function special stuff. */
   new_hook->u.func.func = func;
   new_hook->u.func.data = data;
 
   return new_hook->id;
}

static void hooks_purgeList( void )
{
   Hook *h, *hl;
 
   /* Do not run while stack is being run. */
   if ( hook_runningstack )
      return;
 
   /* Second pass to delete. */
   hl = NULL;
   h  = hook_list;
   while ( h != NULL ) {
      /* Find valid timer hooks. */
      if ( h->delete ) {
 
         if ( hl == NULL )
            hook_list = h->next;
         else
            hl->next = h->next;
 
         /* Free. */
         h->next = NULL;
         hook_free( h );
 
         /* Last. */
         h = hl;
      }
 
      hl = h;
      if ( h == NULL )
         h = hook_list;
      else
         h = h->next;
   }
}

void hooks_updateDate( ntime_t change )
{
   if ( change > 0 )
      hook_time_accum += change;
}

static void hooks_updateDateExecute( ntime_t change )
{
   /* Don't update without player. */
   if ( ( player.p == NULL ) || player_isFlag( PLAYER_CREATING ) )
      return;
 
   /* Clear creation flags. */
   for ( Hook *h = hook_list; h != NULL; h = h->next ) {
      h->created = 0;
      if ( h->is_date )
         h->ran_once = 0;
   }
 
   hook_runningstack++; /* running hooks */
   for ( int j = 1; j >= 0; j-- ) {
      for ( Hook *h = hook_list; h != NULL; h = h->next ) {
         /* Not be deleting. */
         if ( h->delete )
            continue;
         /* Find valid date hooks. */
         if ( h->is_date == 0 )
            continue;
         /* Don't update newly created hooks. */
         if ( h->created != 0 )
            continue;
 
         /* Decrement timer and check to see if should run. */
         if ( j == 1 )
            h->acc += change;
         if ( h->acc < h->res )
            continue;
 
         /* Time is modified at the end. */
         if ( j == 0 )
            h->acc %= h->res; /* We'll skip all buggers. */
         if ( h->ran_once )
            continue;
 
         /* Run the date hook. */
         hook_run( h, NULL, j );
         /* Date hooks are not deleted. */
      }
   }
   hook_runningstack--; /* not running hooks anymore */
 
   /* Second pass to delete. */
   hooks_purgeList();
}
 
unsigned int hook_addDateMisn( unsigned int parent, const char *func,
                               ntime_t resolution )
{
   /* Create the new hook. */
   Hook *new_hook = hook_new( HOOK_TYPE_MISN, "date" );
 
   /* Put mission specific details. */
   new_hook->u.misn.parent = parent;
   new_hook->u.misn.func   = strdup( func );
 
   /* Timer information. */
   new_hook->is_date = 1;
   new_hook->res     = resolution;
   new_hook->acc     = 0;
 
   return new_hook->id;
}
 
unsigned int hook_addDateEvt( unsigned int parent, const char *func,
                              ntime_t resolution )
{
   /* Create the new hook. */
   Hook *new_hook = hook_new( HOOK_TYPE_EVENT, "date" );
 
   /* Put event specific details. */
   new_hook->u.event.parent = parent;
   new_hook->u.event.func   = strdup( func );
 
   /* Timer information. */
   new_hook->is_date = 1;
   new_hook->res     = resolution;
   new_hook->acc     = 0;
 
   return new_hook->id;
}

void hooks_update( double dt )
{
   Hook *h;
 
   /* Don't update without player. */
   if ( ( player.p == NULL ) || player_isFlag( PLAYER_CREATING ) ||
        player_isFlag( PLAYER_DESTROYED ) )
      return;
 
   /* Clear creation flags. */
   for ( h = hook_list; h != NULL; h = h->next )
      h->created = 0;
 
   hook_runningstack++; /* running hooks */
   for ( int j = 1; j >= 0; j-- ) {
      for ( h = hook_list; h != NULL; h = h->next ) {
         /* Not be deleting. */
         if ( h->delete )
            continue;
         /* Find valid timer hooks. */
         if ( h->is_timer == 0 )
            continue;
         /* Don't update newly created hooks. */
         if ( h->created != 0 )
            continue;
 
         /* Decrement timer and check to see if should run. */
         if ( j == 1 )
            h->ms -= dt;
         if ( h->ms > 0. )
            continue;
 
         /* Run the timer hook. */
         hook_run( h, NULL, j );
         if ( h->ran_once ) /* Remove when run. */
            hook_rmRaw( h );
      }
   }
   hook_runningstack--; /* not running hooks anymore */
 
   /* Second pass to delete. */
   hooks_purgeList();
}

static Mission *hook_getMission( Hook *hook )
{
   for ( int i = 0; i < array_size( player_missions ); i++ )
      if ( player_missions[i]->id == hook->u.misn.parent )
         return player_missions[i];
 
   return NULL;
}

void hook_rm( unsigned int id )
{
   Hook *h = hook_get( id );
   if ( h == NULL )
      return;
 
   hook_rmRaw( h );
}

static void hook_rmRaw( Hook *h )
{
   h->delete = 1;
   hookL_unsetarg( h->id );
}

void hook_rmMisnParent( unsigned int parent )
{
   for ( Hook *h = hook_list; h != NULL; h = h->next )
      if ( ( h->type == HOOK_TYPE_MISN ) && ( parent == h->u.misn.parent ) )
         h->delete = 1;
}

void hook_rmEventParent( unsigned int parent )
{
   for ( Hook *h = hook_list; h != NULL; h = h->next )
      if ( ( h->type == HOOK_TYPE_EVENT ) && ( parent == h->u.event.parent ) )
         h->delete = 1;
}

int hook_hasMisnParent( unsigned int parent )
{
   int num = 0;
   for ( Hook *h = hook_list; h != NULL; h = h->next )
      if ( ( h->type == HOOK_TYPE_MISN ) && ( parent == h->u.misn.parent ) )
         num++;
 
   return num;
}

int hook_hasEventParent( unsigned int parent )
{
   int num = 0;
   for ( Hook *h = hook_list; h != NULL; h = h->next )
      if ( ( h->type == HOOK_TYPE_EVENT ) && ( parent == h->u.event.parent ) )
         num++;
 
   return num;
}
 
static int hooks_executeParam( const char *stack, const HookParam *param )
{
   int run;
 
   /* Don't update if player is dead. */
   if ( ( player.p == NULL ) || player_isFlag( PLAYER_DESTROYED ) )
      return 0;
 
   /* Reset the current stack's ran and creation flags. */
   for ( Hook *h = hook_list; h != NULL; h = h->next )
      if ( strcmp( stack, h->stack ) == 0 ) {
         h->ran_once = 0;
         h->created  = 0;
      }
 
   run = 0;
   hook_runningstack++; /* running hooks */
   for ( int j = 1; j >= 0; j-- ) {
      for ( Hook *h = hook_list; h != NULL; h = h->next ) {
         /* Should be deleted. */
         if ( h->delete )
            continue;
         /* Don't run again. */
         if ( h->ran_once )
            continue;
         /* Don't update newly created hooks. */
         if ( h->created != 0 )
            continue;
         /* Doesn't match stack. */
         if ( strcmp( stack, h->stack ) != 0 )
            continue;
 
         /* Run hook. */
         hook_run( h, param, j );
         run++;
 
         /* If hook_cleanup was run, hook_list will be NULL */
         if ( hook_list == NULL )
            break;
      }
      if ( hook_list == NULL )
         break;
   }
   hook_runningstack--; /* not running hooks anymore */
 
   /* Free reference parameters. */
   if ( param != NULL ) {
      int n = 0;
      while ( param[n].type != HOOK_PARAM_SENTINEL ) {
         switch ( param[n].type ) {
         case HOOK_PARAM_REF:
            luaL_unref( naevL, LUA_REGISTRYINDEX, param[n].u.ref );
            break;
 
         default:
            break;
         }
         n++;
      }
   }
 
   /* Check claims. */
   if ( run )
      claim_activateAll();
 
   return run;
}

int hooks_runParamDeferred( const char *stack, const HookParam *param )
{
   int          i;
   HookQueue_t *hq;
 
   /* Don't update if player is dead. */
   if ( ( player.p == NULL ) || player_isFlag( PLAYER_DESTROYED ) )
      return 0;
 
   hq        = calloc( 1, sizeof( HookQueue_t ) );
   hq->stack = strdup( stack );
   i         = 0;
   if ( param != NULL ) {
      for ( ; param[i].type != HOOK_PARAM_SENTINEL; i++ )
         hq->hparam[i] = param[i];
   }
#ifdef DEBUGGING
   if ( i >= HOOK_MAX_PARAM )
      WARN( _( "HOOK_MAX_PARAM is set too low (%d), need at least %d!" ),
            HOOK_MAX_PARAM, i );
#endif /* DEBUGGING */
   hq->hparam[i].type = HOOK_PARAM_SENTINEL;
   hq_add( hq );
   return 0;
}

int hooks_runParam( const char *stack, const HookParam *param )
{
   /* Don't update if player is dead. */
   if ( ( player.p == NULL ) || player_isFlag( PLAYER_DESTROYED ) )
      return 0;
 
   /* Not time to run hooks, so queue them. */
   if ( hook_atomic )
      return hooks_runParamDeferred( stack, param );
 
   /* Execute. */
   return hooks_executeParam( stack, param );
}

int hooks_run( const char *stack )
{
   return hooks_runParam( stack, NULL );
}

static Hook *hook_get( unsigned int id )
{
   for ( Hook *h = hook_list; h != NULL; h = h->next )
      if ( h->id == id )
         return h;
 
   return NULL;
}

nlua_env hook_env( unsigned int hook )
{
   Mission *misn;
   Event_t *evt;
 
   Hook *h = hook_get( hook );
   if ( h == NULL )
      return LUA_NOREF;
 
   switch ( h->type ) {
   case HOOK_TYPE_MISN:
      misn = hook_getMission( h );
      if ( misn != NULL )
         return misn->env;
      break;
   case HOOK_TYPE_EVENT:
      evt = event_get( h->u.event.parent );
      if ( evt != NULL )
         return evt->env;
      break;
   default:
      break;
   }
 
   return LUA_NOREF;
}

int hook_runIDparam( unsigned int id, const HookParam *param )
{
   Hook *h;
 
   /* Don't update if player is dead. */
   if ( ( player.p == NULL ) || player_isFlag( PLAYER_DESTROYED ) )
      return 0;
 
   /* Try to find the hook and run it. */
   h = hook_get( id );
   if ( h == NULL ) {
      WARN( _( "Attempting to run hook of id '%d' which is not in the stack" ),
            id );
      return -1;
   }
   hook_run( h, param, -1 );
 
   return 0;
}

int hook_runID( unsigned int id )
{
   return hook_runIDparam( id, 0 );
}

static void hook_free( Hook *h )
{
   /* Remove from all the pilots. */
   pilots_rmHook( h->id );
 
   /* Generic freeing. */
   free( h->stack );
 
   /* Free type specific. */
   switch ( h->type ) {
   case HOOK_TYPE_MISN:
      free( h->u.misn.func );
      break;
 
   case HOOK_TYPE_EVENT:
      free( h->u.event.func );
      break;
 
   default:
      break;
   }
 
   free( h );
}

void hook_cleanup( void )
{
   Hook *h;
 
   /* Clear queued hooks. */
   hq_clear();
 
   h = hook_list;
   while ( h != NULL ) {
      Hook *hn = h->next;
      hook_free( h );
      h = hn;
   }
   /* safe defaults just in case */
   hook_list = NULL;
}

void hook_clear( void )
{
   for ( Hook *h = hook_list; h != NULL; h = h->next ) {
      if ( h->delete )
         continue;
      hook_rmRaw( h );
   }
}

void hook_clearMissionTimers( unsigned int parent )
{
   for ( Hook *h = hook_list; h != NULL; h = h->next ) {
      if ( !h->is_timer )
         continue;
      if ( ( h->type == HOOK_TYPE_MISN ) && ( parent == h->u.misn.parent ) )
         h->delete = 1;
   }
}

void hook_clearEventTimers( unsigned int parent )
{
   for ( Hook *h = hook_list; h != NULL; h = h->next ) {
      if ( !h->is_timer )
         continue;
      if ( ( h->type == HOOK_TYPE_EVENT ) && ( parent == h->u.event.parent ) )
         h->delete = 1;
   }
}

static int hook_needSave( Hook *h )
{
   const char *nosave[] = { "p_death", "p_board",    "p_disable",
                            "p_jump",  "p_attacked", "p_idle", /* pilot hooks */
                            "timer",                           /* timers */
                            "end" };
 
   /* Impossible to save functions. */
   if ( h->type == HOOK_TYPE_FUNC )
      return 0;
 
   /* Events must need saving. */
   if ( ( h->type == HOOK_TYPE_EVENT ) && !event_save( h->u.event.parent ) )
      return 0;
 
   /* Must not be pending deletion. */
   if ( h->delete )
      return 0;
 
   /* Make sure it's in the proper stack. */
   for ( int i = 0; strcmp( nosave[i], "end" ) != 0; i++ )
      if ( strcmp( nosave[i], h->stack ) == 0 )
         return 0;
 
   return 1;
}

int hook_save( xmlTextWriterPtr writer )
{
   xmlw_startElem( writer, "hooks" );
   for ( Hook *h = hook_list; h != NULL; h = h->next ) {
 
      if ( !hook_needSave( h ) )
         continue; /* no need to save it */
 
      xmlw_startElem( writer, "hook" );
 
      switch ( h->type ) {
      case HOOK_TYPE_MISN:
         xmlw_attr( writer, "type", "misn" ); /* Save attribute. */
         xmlw_elem( writer, "parent", "%u", h->u.misn.parent );
         xmlw_elem( writer, "func", "%s", h->u.misn.func );
         break;
 
      case HOOK_TYPE_EVENT:
         xmlw_attr( writer, "type", "event" ); /* Save attribute. */
         xmlw_elem( writer, "parent", "%u", h->u.event.parent );
         xmlw_elem( writer, "func", "%s", h->u.event.func );
         break;
 
      default:
         WARN( _( "Something has gone screwy here..." ) );
         break;
      }
 
      /* Generic information. */
      xmlw_elem( writer, "id", "%u", h->id );
      xmlw_elem( writer, "stack", "%s", h->stack );
 
      /* Store additional date information. */
      if ( h->is_date )
         xmlw_elem( writer, "resolution", "%" PRId64, h->res );
 
      xmlw_endElem( writer ); /* "hook" */
   }
   xmlw_endElem( writer ); /* "hooks" */
 
   return 0;
}

int hook_load( xmlNodePtr parent )
{
   xmlNodePtr node;
 
   /* We're loading. */
   hook_loadingstack = 1;
 
   node = parent->xmlChildrenNode;
   do {
      if ( xml_isNode( node, "hooks" ) )
         hook_parse( node );
   } while ( xml_nextNode( node ) );
 
   /* Done loading. */
   hook_loadingstack = 0;
 
   /* Set ID gen to highest hook. */
   for ( Hook *h = hook_list; h != NULL; h = h->next )
      hook_id = MAX( h->id, hook_id );
 
   return 0;
}

static int hook_parse( xmlNodePtr base )
{
   xmlNodePtr   node, cur;
   char        *func, *stack, *stype;
   unsigned int parent, id, new_id;
   HookType_t   type;
   Hook        *h;
   int          is_date;
   ntime_t      res = 0;
 
   node = base->xmlChildrenNode;
   do {
      if ( xml_isNode( node, "hook" ) ) {
         id      = 0;
         parent  = 0;
         func    = NULL;
         stack   = NULL;
         is_date = 0;
 
         /* Handle the type. */
         xmlr_attr_strd( node, "type", stype );
         /* Default to mission for old saves. */
         if ( stype == NULL )
            type = HOOK_TYPE_MISN;
         /* Mission type. */
         else if ( strcmp( stype, "misn" ) == 0 ) {
            type = HOOK_TYPE_MISN;
            free( stype );
         }
         /* Event type. */
         else if ( strcmp( stype, "event" ) == 0 ) {
            type = HOOK_TYPE_EVENT;
            free( stype );
         }
         /* Unknown. */
         else {
            WARN( _( "Hook of unknown type '%s' found, skipping." ), stype );
            free( stype );
            continue;
         }
 
         /* Handle the data. */
         cur = node->xmlChildrenNode;
         do {
            xml_onlyNodes( cur );
 
            /* ID. */
            xmlr_long( cur, "id", id );
 
            /* Generic. */
            xmlr_str( cur, "stack", stack );
 
            /* Type specific. */
            if ( ( type == HOOK_TYPE_MISN ) || ( type == HOOK_TYPE_EVENT ) ) {
               xmlr_uint( cur, "parent", parent );
               xmlr_str( cur, "func", func );
            }
 
            /* Check for date hook. */
            if ( xml_isNode( cur, "resolution" ) ) {
               is_date = 1;
               res     = xml_getLong( cur );
               continue;
            }
 
            // cppcheck-suppress nullPointerRedundantCheck
            WARN( _( "Save has unknown hook node '%s'." ), cur->name );
         } while ( xml_nextNode( cur ) );
 
         /* Check for validity. */
         if ( ( parent == 0 ) || ( func == NULL ) || ( stack == NULL ) ) {
            WARN( _( "Invalid hook." ) );
            continue;
         }
 
         /* Create the hook. */
         switch ( type ) {
         case HOOK_TYPE_MISN:
            new_id = hook_addMisn( parent, func, stack );
            break;
         case HOOK_TYPE_EVENT:
            new_id = hook_addEvent( parent, func, stack );
            break;
         default:
            WARN( _( "Save has unsupported hook type." ) );
            continue;
         }
 
         /* Set the id. */
         if ( id != 0 ) {
            h     = hook_get( new_id );
            h->id = id;
 
            /* Additional info. */
            if ( is_date ) {
               h->is_date = 1;
               h->res     = res;
            }
         }
      }
   } while ( xml_nextNode( node ) );
 
   return 0;
}