src/event.c

   1 /*
   2  * See Licensing and Copyright notice in naev.h
   3  */
   4
   5 /**
   6  * @file event.c
   7  *
   8  * @brief Handles internal events.
   9  *
  10  * Events are a lot like missions except the player has no control over when
  11  *  or how they happen.  They can simple do something simple or actually lead up
  12  *  to and open an entire set of missions.
  13  */
  14
  15
  16 #include "event.h"
  17
  18 #include "naev.h"
  19
  20 #include <stdint.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23
  24 #include "log.h"
  25 #include "nlua.h"
  26 #include "nluadef.h"
  27 #include "nlua_evt.h"
  28 #include "nlua_hook.h"
  29 #include "nlua_tk.h"
  30 #include "rng.h"
  31 #include "ndata.h"
  32 #include "nxml.h"
  33 #include "cond.h"
  34 #include "hook.h"
  35 #include "player.h"
  36 #include "npc.h"
  37
  38
  39 #define XML_EVENT_ID          "Events" /**< XML document identifier */
  40 #define XML_EVENT_TAG         "event" /**< XML mission tag. */
  41
  42 #define EVENT_DATA            "dat/event.xml" /**< Path to missions XML. */
  43 #define EVENT_LUA_PATH        "dat/events/" /**< Path to Lua files. */
  44
  45 #define EVENT_CHUNK           32 /**< Size to grow event data by. */
  46
  47
  48 #define EVENT_FLAG_UNIQUE     (1<<0) /**< Unique event. */
  49
  50
  51 /**
  52  * @brief Event data structure.
  53  */
  54 typedef struct EventData_s {
  55    char *name; /**< Name of the event. */
  56    char *lua; /**< Name of Lua file to use. */
  57    unsigned int flags; /**< Bit flags. */
  58
  59    EventTrigger_t trigger; /**< What triggers the event. */
  60    char *cond; /**< Conditional Lua code to execute. */
  61    double chance; /**< Chance of appearing. */
  62 } EventData_t;
  63
  64
  65 /*
  66  * Event data.
  67  */
  68 static EventData_t *event_data   = NULL; /**< Allocated event data. */
  69 static int event_ndata           = 0; /**< Number of actual event data. */
  70
  71
  72 /*
  73  * Active events.
  74  */
  75 static unsigned int event_genid  = 0; /**< Event ID generator. */
  76 static Event_t *event_active     = NULL; /**< Active events. */
  77 static int event_nactive         = 0; /**< Number of active events. */
  78 static int event_mactive         = 0; /**< Allocated space for active events. */
  79
  80
  81 /*
  82  * Prototypes.
  83  */
  84 static Event_t *event_get( unsigned int eventid );
  85 static int event_alreadyRunning( int data );
  86 static int event_parse( EventData_t *temp, const xmlNodePtr parent );
  87 static void event_freeData( EventData_t *event );
  88 static int event_create( int dataid );
  89
  90
  91 /**
  92  * @brief Gets an event.
  93  */
  94 static Event_t *event_get( unsigned int eventid )
  95 {
  96    int i;
  97    Event_t *ev;
  98
  99    /* Iterate. */
 100    for (i=0; i<event_nactive; i++) {
 101       ev = &event_active[i];
 102       if (ev->id == eventid)
 103          return ev;
 104    }
 105
 106    WARN( "Event '%u' not found in stack.", eventid );
 107    return NULL;
 108 }
 109
 110
 111 /**
 112  * @brief Starts running a function, allows programmer to set up arguments.
 113  */
 114 lua_State *event_runStart( unsigned int eventid, const char *func )
 115 {
 116    Event_t *ev;
 117
 118    ev = event_get( eventid );
 119    if (ev == NULL)
 120       return NULL;
 121
 122    return event_setupLua( ev, func );
 123 }
 124
 125
 126 /**
 127  * @brief Runs a function previously set up with event_runStart.
 128  */
 129 int event_runFunc( unsigned int eventid, const char *func, int nargs )
 130 {
 131    Event_t *ev;
 132
 133    ev = event_get( eventid );
 134    if (ev == NULL)
 135       return 0;
 136
 137    return event_runLuaFunc( ev, func, nargs );
 138 }
 139
 140
 141 /**
 142  * @brief Runs the event function.
 143  *
 144  *    @param eventid ID of the event to run Lua function on.
 145  *    @param func Name of the function to run.
 146  *    @return 0 on success.
 147  */
 148 int event_run( unsigned int eventid, const char *func )
 149 {
 150    Event_t *ev;
 151
 152    ev = event_get( eventid );
 153    if (ev == NULL)
 154       return -1;
 155
 156    return event_runLua( ev, func );
 157 }
 158
 159
 160 /**
 161  * @brief Gets the name of the event data.
 162  *
 163  *    @param ev Event to get name of data from.
 164  *    @return Name of data ev has.
 165  */
 166 const char *event_getData( unsigned int eventid )
 167 {
 168    Event_t *ev;
 169
 170    ev = event_get( eventid );
 171    if (ev == NULL)
 172       return NULL;
 173
 174    return event_data[ ev->data ].name;
 175 }
 176
 177
 178 /**
 179  * @brief Checks to see if an event is unique.
 180  *
 181  *    @param eventid ID of event to see if is unique.
 182  *    @return 0 if isn't unique, 1 if is.
 183  */
 184 int event_isUnique( unsigned int eventid )
 185 {
 186    Event_t *ev;
 187
 188    ev = event_get( eventid );
 189    if (ev == NULL)
 190       return -1;
 191
 192    return !!(event_data[ ev->data ].flags & EVENT_FLAG_UNIQUE);
 193 }
 194
 195
 196 /**
 197  * @brief Creates an event.
 198  *
 199  *    @param data Data to base event off of.
 200  */
 201 static int event_create( int dataid )
 202 {
 203    lua_State *L;
 204    uint32_t bufsize;
 205    char *buf;
 206    Event_t *ev;
 207    EventData_t *data;
 208
 209    /* Create the event. */
 210    event_nactive++;
 211    if (event_nactive > event_mactive) {
 212       event_mactive += EVENT_CHUNK;
 213       event_active = realloc( event_active, sizeof(Event_t) * event_mactive );
 214    }
 215    ev = &event_active[ event_nactive-1 ];
 216    memset( ev, 0, sizeof(Event_t) );
 217    ev->id = ++event_genid; /* Create unique ID. */
 218
 219    /* Add the data. */
 220    ev->data = dataid;
 221    data = &event_data[dataid];
 222
 223    /* Open the new state. */
 224    ev->L = nlua_newState();
 225    L = ev->L;
 226    nlua_loadStandard(L,0);
 227    nlua_loadEvt(L);
 228    nlua_loadHook(L);
 229    nlua_loadTk(L);
 230
 231    /* Load file. */
 232    buf = ndata_read( data->lua, &bufsize );
 233    if (buf == NULL) {
 234       WARN("Event '%s' Lua script not found.", data->lua );
 235       return -1;
 236    }
 237    if (luaL_dobuffer(L, buf, bufsize, data->lua) != 0) {
 238       WARN("Error loading event file: %s\n"
 239             "%s\n"
 240             "Most likely Lua file has improper syntax, please check",
 241             data->lua, lua_tostring(L,-1));
 242       return -1;
 243    }
 244    free(buf);
 245
 246    /* Run Lua. */
 247    event_runLua( ev, "create" );
 248
 249    return 0;
 250 }
 251
 252
 253 /**
 254  * @brief Cleans up an event.
 255  *
 256  *    @param ev Event to clean up.
 257  */
 258 static void event_cleanup( Event_t *ev )
 259 {
 260    int i;
 261
 262    /* Destroy Lua. */
 263    lua_close(ev->L);
 264
 265    /* Free hooks. */
 266    hook_rmEventParent(ev->id);
 267
 268    /* Free NPC. */
 269    npc_rm_parentEvent(ev->id);
 270
 271    /* Free timers. */
 272    for (i=0; i<EVENT_TIMER_MAX; i++) {
 273       if (ev->tfunc[i] != NULL) {
 274          free(ev->tfunc[i]);
 275          ev->tfunc[i] = NULL;
 276       }
 277    }
 278 }
 279
 280
 281 /**
 282  * @brief Removes an event by ID.
 283  *
 284  *    @param eventid ID of the event to remove.
 285  */
 286 void event_remove( unsigned int eventid )
 287 {
 288    int i;
 289    Event_t *ev;
 290
 291    /* Find the event. */
 292    for (i=0; i<event_nactive; i++) {
 293       ev = &event_active[i];
 294       if (ev->id == eventid) {
 295          /* Clean up event. */
 296          event_cleanup(ev);
 297
 298          /* Move memory. */
 299          memmove( &event_active[i], &event_active[i+1],
 300                sizeof(Event_t) * (event_nactive-i-1) );
 301          event_nactive--;
 302          return;
 303       }
 304    }
 305
 306    WARN("Event ID '%u' not valid.", eventid);
 307 }
 308
 309
 310 /**
 311  * @brief Runs event timer stuff.
 312  */
 313 void events_update( double dt )
 314 {
 315    int i, j;
 316    Event_t *ev;
 317    char *tfunc;
 318
 319    for (i=0; i<event_nactive; i++) {
 320       ev = &event_active[i];
 321
 322       /* Decrement timers see if must run. */
 323       for (j=0; j<EVENT_TIMER_MAX; j++) {
 324
 325          if (ev->timer[j] > 0.) {
 326
 327             ev->timer[j] -= dt;
 328
 329             /* Timer is up - trigger function. */
 330             if (ev->timer[j] < 0.) {
 331
 332                /* Destroy timer. */
 333                ev->timer[j] = 0.;
 334                tfunc = ev->tfunc[j];
 335                ev->tfunc[j] = NULL;
 336
 337                /* Run function. */
 338                event_runLua( ev, tfunc );
 339
 340                /* Free remainder stuff. */
 341                free(tfunc);
 342             }
 343          }
 344       }
 345    }
 346 }
 347
 348
 349 /**
 350  * @brief Check to see if an event is already running.
 351  *
 352  *    @param data ID of data event to check if is already running.
 353  */
 354 static int event_alreadyRunning( int data )
 355 {
 356    int i;
 357    Event_t *ev;
 358
 359    /* Find events. */
 360    for (i=0; i<event_nactive; i++) {
 361       ev = &event_active[i];
 362       if (ev->data == data) {
 363          return 1;
 364       }
 365    }
 366
 367    return 0;
 368 }
 369
 370
 371 /**
 372  * @brief Runs all the events matching a trigger.
 373  *
 374  *    @param trigger Trigger to match.
 375  */
 376 void events_trigger( EventTrigger_t trigger )
 377 {
 378    int i, c;
 379
 380    for (i=0; i<event_ndata; i++) {
 381       /* Make sure trigger matches. */
 382       if (event_data[i].trigger != trigger)
 383          continue;
 384
 385       /* Make sure chance is succeeded. */
 386       if (RNGF() > event_data[i].chance)
 387          continue;
 388
 389       /* Test uniqueness. */
 390       if ((event_data[i].flags & EVENT_FLAG_UNIQUE) &&
 391             (player_eventAlreadyDone( i ) || event_alreadyRunning(i)))
 392          continue;
 393
 394       /* Test conditional. */
 395       if (event_data[i].cond != NULL) {
 396          c = cond_check(event_data[i].cond);
 397          if (c<0) {
 398             WARN("Conditional for event '%s' failed to run.", event_data[i].name);
 399             continue;
 400          }
 401          else if (!c)
 402             continue;
 403       }
 404
 405       /* Create the event. */
 406       event_create( i );
 407    }
 408 }
 409
 410
 411 /**
 412  * @brief Loads up an event from an XML node.
 413  *
 414  *    @param temp Event to load up.
 415  *    @param parent Event parent node.
 416  *    @return 0 on success.
 417  */
 418 static int event_parse( EventData_t *temp, const xmlNodePtr parent )
 419 {
 420    xmlNodePtr node, cur;
 421    char str[PATH_MAX] = "\0";
 422    char *buf;
 423
 424 #ifdef DEBUGGING
 425    /* To check if mission is valid. */
 426    lua_State *L;
 427    int ret;
 428    uint32_t len;
 429 #endif /* DEBUGGING */
 430
 431    memset( temp, 0, sizeof(EventData_t) );
 432
 433    /* get the name */
 434    temp->name = xml_nodeProp(parent,"name");
 435    if (temp->name == NULL)
 436       WARN("Event in "EVENT_DATA" has invalid or no name");
 437
 438    node = parent->xmlChildrenNode;
 439
 440    do { /* load all the data */
 441
 442       /* Only check nodes. */
 443       xml_onlyNodes(node);
 444
 445       if (xml_isNode(node,"lua")) {
 446          snprintf( str, PATH_MAX, EVENT_LUA_PATH"%s.lua", xml_get(node) );
 447          temp->lua = strdup( str );
 448          str[0] = '\0';
 449
 450 #ifdef DEBUGGING
 451          /* Check to see if syntax is valid. */
 452          L = luaL_newstate();
 453          buf = ndata_read( temp->lua, &len );
 454          ret = luaL_loadbuffer(L, buf, len, temp->name );
 455          if (ret == LUA_ERRSYNTAX) {
 456             WARN("Event Lua '%s' of mission '%s' syntax error: %s",
 457                   temp->name, temp->lua, lua_tostring(L,-1) );
 458          }
 459          free(buf);
 460          lua_close(L);
 461 #endif /* DEBUGGING */
 462
 463          continue;
 464       }
 465
 466       /* Trigger. */
 467       else if (xml_isNode(node,"trigger")) {
 468          buf = xml_get(node);
 469          if (buf == NULL)
 470             WARN("Event '%s': Null trigger type.", temp->name);
 471          else if (strcmp(buf,"enter")==0)
 472             temp->trigger = EVENT_TRIGGER_ENTER;
 473          else if (strcmp(buf,"land")==0)
 474             temp->trigger = EVENT_TRIGGER_LAND;
 475          else
 476             WARN("Event '%s' has invalid 'trigger' parameter: %s", temp->name, buf);
 477
 478          continue;
 479       }
 480
 481       /* Flags. */
 482       else if (xml_isNode(node,"flags")) { /* set the various flags */
 483          cur = node->children;
 484          do {
 485             if (xml_isNode(cur,"unique"))
 486                temp->flags |= EVENT_FLAG_UNIQUE;
 487          } while (xml_nextNode(cur));
 488          continue;
 489       }
 490
 491       /* Condition. */
 492       xmlr_strd(node,"cond",temp->cond);
 493
 494       /* Get chance. */
 495       xmlr_float(node,"chance",temp->chance);
 496
 497       DEBUG("Unknown node '%s' in event '%s'", node->name, temp->name);
 498    } while (xml_nextNode(node));
 499
 500    /* Process. */
 501    temp->chance /= 100.;
 502
 503 #define MELEMENT(o,s) \
 504    if (o) WARN("Mission '%s' missing/invalid '"s"' element", temp->name)
 505    MELEMENT(temp->lua==NULL,"lua");
 506    MELEMENT(temp->chance==0.,"chance");
 507    MELEMENT(temp->trigger==EVENT_TRIGGER_NULL,"trigger");
 508 #undef MELEMENT
 509
 510    return 0;
 511 }
 512
 513
 514 /**
 515  * @brief Loads all the events.
 516  *
 517  *    @return 0 on success.
 518  */
 519 int events_load (void)
 520 {
 521    int m;
 522    uint32_t bufsize;
 523    char *buf;
 524    xmlNodePtr node;
 525    xmlDocPtr doc;
 526
 527    /* Load the data. */
 528    buf = ndata_read( EVENT_DATA, &bufsize );
 529    if (buf == NULL) {
 530       WARN("Unable to read data from '%s'", EVENT_DATA);
 531       return -1;
 532    }
 533
 534    /* Load the document. */
 535    doc = xmlParseMemory( buf, bufsize );
 536    if (doc == NULL) {
 537       WARN("Unable to parse document '%s'", EVENT_DATA);
 538       return -1;
 539    }
 540
 541    /* Get the root node. */
 542    node = doc->xmlChildrenNode;
 543    if (!xml_isNode(node,XML_EVENT_ID)) {
 544       WARN("Malformed '"EVENT_DATA"' file: missing root element '"XML_EVENT_ID"'");
 545       return -1;
 546    }
 547
 548    /* Get the first node. */
 549    node = node->xmlChildrenNode; /* first mission node */
 550    if (node == NULL) {
 551       WARN("Malformed '"EVENT_DATA"' file: does not contain elements");
 552       return -1;
 553    }
 554
 555    m = 0;
 556    do {
 557       if (xml_isNode(node,XML_EVENT_TAG)) {
 558
 559          /* See if must grow. */
 560          event_ndata++;
 561          if (event_ndata > m) {
 562             m += EVENT_CHUNK;
 563             event_data = realloc(event_data, sizeof(EventData_t)*m);
 564          }
 565
 566          /* Load it. */
 567          event_parse( &event_data[event_ndata-1], node );
 568       }
 569    } while (xml_nextNode(node));
 570
 571    /* Shrink to minimum. */
 572    event_data = realloc(event_data, sizeof(EventData_t)*event_ndata);
 573
 574    /* Clean up. */
 575    xmlFreeDoc(doc);
 576    free(buf);
 577
 578    DEBUG("Loaded %d Event%s", event_ndata, (event_ndata==1) ? "" : "s" );
 579
 580    return 0;
 581 }
 582
 583
 584 /**
 585  * @brief Frees an EventData structure.
 586  *
 587  *    @param event Event Data to free.
 588  */
 589 static void event_freeData( EventData_t *event )
 590 {
 591    if (event->name) {
 592       free(event->name);
 593       event->name = NULL;
 594    }
 595    if (event->lua) {
 596       free(event->lua);
 597       event->lua = NULL;
 598    }
 599    if (event->cond) {
 600       free(event->cond);
 601       event->cond = NULL;
 602    }
 603 }
 604
 605
 606 /**
 607  * @brief Cleans up and removes active events.
 608  */
 609 void events_cleanup (void)
 610 {
 611    int i;
 612
 613    /* Free active events. */
 614    for (i=0; i<event_nactive; i++)
 615       event_cleanup( &event_active[i] );
 616    if (event_active != NULL) {
 617       free(event_active);
 618    }
 619    event_active = NULL;
 620    event_nactive = 0;
 621    event_mactive = 0;
 622 }
 623
 624
 625 /**
 626  * @brief Exits the event subsystem.
 627  */
 628 void events_exit (void)
 629 {
 630    int i;
 631
 632    events_cleanup();
 633
 634    /* Free data. */
 635    for (i=0; i<event_ndata; i++)
 636       event_freeData(&event_data[i]);
 637    if (event_data != NULL) {
 638       event_freeData(event_data);
 639       free(event_data);
 640    }
 641    event_data  = NULL;
 642    event_ndata = 0;
 643 }
 644
 645
 646 /**
 647  * @brief Gets the event data id from name.
 648  *
 649  *    @param evdata Name of the data.
 650  *    @return ID matching dataname.
 651  */
 652 int event_dataID( const char *evdata )
 653 {
 654    int i;
 655
 656    for (i=0; i<event_ndata; i++)
 657       if (strcmp(event_data[i].name, evdata)==0)
 658          return i;
 659    WARN("No event data found matching name '%s'.", evdata);
 660    return -1;
 661 }
 662
 663
 664 /**
 665  * @brief Gets the event data name from id.
 666  *
 667  *    @param dataid ID of the event data to get name of.
 668  *    @return Name of the event data.
 669  */
 670 const char *event_dataName( int dataid )
 671 {
 672    return event_data[dataid].name;
 673 }
 674