nlua_misn.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_misn.h"
 
#include "array.h"
#include "gui_osd.h"
#include "land.h"
#include "log.h"
#include "mission.h"
#include "music.h"
#include "ndata.h"
#include "nlua.h"
#include "nlua_audio.h"
#include "nlua_bkg.h"
#include "nlua_camera.h"
#include "nlua_commodity.h"
#include "nlua_faction.h"
#include "nlua_hook.h"
#include "nlua_music.h"
#include "nlua_spob.h"
#include "nlua_player.h"
#include "nlua_system.h"
#include "nlua_tex.h"
#include "nlua_tk.h"
#include "nluadef.h"
#include "npc.h"
#include "nstring.h"
#include "nxml.h"
#include "player.h"
#include "rng.h"
#include "shiplog.h"
#include "toolkit.h"
 
/*
 * libraries
 */
/* Mission methods */
static int misn_setTitle( lua_State *L );
static int misn_setDesc( lua_State *L );
static int misn_setReward( lua_State *L );
static int misn_setNPC( lua_State *L );
static int misn_factions( lua_State *L );
static int misn_accept( lua_State *L );
static int misn_finish( lua_State *L );
static int misn_markerAdd( lua_State *L );
static int misn_markerMove( lua_State *L );
static int misn_markerRm( lua_State *L );
static int misn_cargoAdd( lua_State *L );
static int misn_cargoRm( lua_State *L );
static int misn_cargoJet( lua_State *L );
static int misn_osdCreate( lua_State *L );
static int misn_osdDestroy( lua_State *L );
static int misn_osdActive( lua_State *L );
static int misn_osdGet( lua_State *L );
static int misn_osdGetActiveItem( lua_State *L );
static int misn_npcAdd( lua_State *L );
static int misn_npcRm( lua_State *L );
static int misn_claim( lua_State *L );
static const luaL_Reg misn_methods[] = {
   { "setTitle", misn_setTitle },
   { "setDesc", misn_setDesc },
   { "setReward", misn_setReward },
   { "setNPC", misn_setNPC },
   { "factions", misn_factions },
   { "accept", misn_accept },
   { "finish", misn_finish },
   { "markerAdd", misn_markerAdd },
   { "markerMove", misn_markerMove },
   { "markerRm", misn_markerRm },
   { "cargoAdd", misn_cargoAdd },
   { "cargoRm", misn_cargoRm },
   { "cargoJet", misn_cargoJet },
   { "osdCreate", misn_osdCreate },
   { "osdDestroy", misn_osdDestroy },
   { "osdActive", misn_osdActive },
   { "osdGet", misn_osdGet },
   { "osdGetActive", misn_osdGetActiveItem },
   { "npcAdd", misn_npcAdd },
   { "npcRm", misn_npcRm },
   { "claim", misn_claim },
   {0,0}
}; 
int misn_loadLibs( nlua_env env )
{
   nlua_loadStandard(env);
   nlua_loadMisn(env);
   nlua_loadHook(env);
   nlua_loadCamera(env);
   nlua_loadTex(env);
   nlua_loadBackground(env);
   nlua_loadMusic(env);
   nlua_loadTk(env);
   return 0;
}
/*
 * individual library loading
 */
int nlua_loadMisn( nlua_env env )
{
   nlua_register(env, "misn", misn_methods, 0);
   return 0;
}
 
int misn_tryRun( Mission *misn, const char *func )
{
   int ret;
   /* Get the function to run. */
   misn_runStart( misn, func );
   if (lua_isnil( naevL, -1 )) {
      lua_pop(naevL,1);
      return 0;
   }
   ret = misn_runFunc( misn, func, 0 );
   return ret;
}
 
int misn_run( Mission *misn, const char *func )
{
   misn_runStart( misn, func );
   return misn_runFunc( misn, func, 0 );
}
 
Mission* misn_getFromLua( lua_State *L )
{
   Mission *misn, **misnptr;
 
   nlua_getenv( L, __NLUA_CURENV, "__misn" );
   misnptr = lua_touserdata( L, -1 );
   misn = misnptr ? *misnptr : NULL;
   lua_pop( L, 1 );
 
   return misn;
}
 
void misn_runStart( Mission *misn, const char *func )
{
   Mission **misnptr;
   misnptr = lua_newuserdata( naevL, sizeof(Mission*) );
   *misnptr = misn;
   nlua_setenv( naevL, misn->env, "__misn" );
 
   /* Set the Lua state. */
   nlua_getenv( naevL, misn->env, func );
}
 
int misn_runFunc( const Mission *misn, const char *func, int nargs )
{
   int ret, misn_delete;
   Mission *cur_mission;
   nlua_env env;
 
   /* Check to see if it is accepted first. */
   int isaccepted = misn->accepted;
 
   /* Set up and run function. */
   env = misn->env;
   ret = nlua_pcall(env, nargs, 0);
 
   /* The mission can change if accepted. */
   nlua_getenv(naevL, env, "__misn");
   cur_mission = *(Mission**) lua_touserdata(naevL, -1);
   lua_pop(naevL, 1);
 
   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(_("Mission '%s' -> '%s': %s"),
               cur_mission->data->name, func, (err) ? err : _("unknown error"));
         ret = -1;
      }
      else
         ret = 1;
      lua_pop(naevL,1);
   }
 
   /* Get delete. */
   nlua_getenv(naevL, env, "__misn_delete");
   misn_delete = lua_toboolean(naevL,-1);
   lua_pop(naevL,1);
 
   /* Mission is finished */
   if (misn_delete) {
      ret = 2;
      mission_cleanup( cur_mission );
      for (int i=0; i<array_size(player_missions); i++) {
         if (cur_mission != player_missions[i])
            continue;
 
         mission_shift(i);
         break;
      }
   }
   /* Mission became accepted. */
   else if (!isaccepted && cur_mission->accepted)
      ret = 3;
 
   return ret;
}
 
static int misn_setTitle( lua_State *L )
{
   const char *str = luaL_checkstring(L,1);
   Mission *cur_mission = misn_getFromLua(L);
   free(cur_mission->title);
   cur_mission->title = strdup(str);
   return 0;
}
static int misn_setDesc( lua_State *L )
{
   const char *str = luaL_checkstring(L,1);
   Mission *cur_mission = misn_getFromLua(L);
   free(cur_mission->desc);
   cur_mission->desc = strdup(str);
   return 0;
}
static int misn_setReward( lua_State *L )
{
   Mission *cur_mission = misn_getFromLua(L);
   free(cur_mission->reward);
   cur_mission->reward_value = -1.;
   if (lua_isnumber(L,1)) {
      char buf[ECON_CRED_STRLEN];
      cur_mission->reward_value = CLAMP( CREDITS_MIN, CREDITS_MAX, (credits_t)round(luaL_checknumber(L,1)) );
      credits2str( buf, cur_mission->reward_value, 2 );
      cur_mission->reward = strdup(buf);
   }
   else {
      const char *str = luaL_checkstring(L,1);
      cur_mission->reward = strdup(str);
   }
   return 0;
}
 
static int misn_markerAdd( lua_State *L )
{
   int id, issys, objid;
   const char *stype;
   MissionMarkerType type;
   Mission *cur_mission;
 
   /* Check parameters. */
   if (lua_isspob(L,1)) {
      issys = 0;
      objid = luaL_checkspob(L,1);
   }
   else {
      issys = 1;
      objid = system_index( luaL_validsystem(L,1) );
   }
   stype = luaL_optstring( L, 2, "high" );
 
   /* Handle types. */
   if (strcmp(stype, "computer")==0)
      type = SPOBMARKER_COMPUTER;
   else if (strcmp(stype, "low")==0)
      type = SPOBMARKER_LOW;
   else if (strcmp(stype, "high")==0)
      type = SPOBMARKER_HIGH;
   else if (strcmp(stype, "plot")==0)
      type = SPOBMARKER_PLOT;
   else
      return NLUA_ERROR(L, _("Unknown marker type: %s"), stype);
 
   /* Convert spob -> system. */
   if (issys)
      type = mission_markerTypeSpobToSystem( type );
 
   cur_mission = misn_getFromLua(L);
 
   /* Add the marker. */
   id = mission_addMarker( cur_mission, -1, objid, type );
 
   /* Update system markers. */
   mission_sysMark();
 
   /* Return the ID. */
   lua_pushnumber( L, id );
   return 1;
}
 
static int misn_markerMove( lua_State *L )
{
   int id, objid, issys;
   MissionMarker *marker;
   Mission *cur_mission;
 
   /* Handle parameters. */
   id    = luaL_checkinteger( L, 1 );
   if (lua_isspob(L,2)) {
      issys = 0;
      objid = luaL_checkspob(L,2);
   }
   else {
      issys = 1;
      objid = luaL_checksystem(L,2);
   }
 
   cur_mission = misn_getFromLua(L);
 
   /* Check id. */
   marker = NULL;
   for (int i=0; i<array_size(cur_mission->markers); i++) {
      if (id == cur_mission->markers[i].id) {
         marker = &cur_mission->markers[i];
         break;
      }
   }
   if (marker == NULL)
      return NLUA_ERROR( L, _("Mission does not have a marker with id '%d'"), id );
 
   /* Update system. */
   if (issys)
      marker->type = mission_markerTypeSpobToSystem( marker->type );
   else
      marker->type = mission_markerTypeSystemToSpob( marker->type );
   marker->objid = objid;
 
   /* Update system markers. */
   mission_sysMark();
   return 0;
}
 
static int misn_markerRm( lua_State *L )
{
   int id;
   MissionMarker *marker;
   Mission *cur_mission = misn_getFromLua(L);
 
   /* Remove all markers. */
   if (lua_isnoneornil(L,1)) {
      array_erase( &cur_mission->markers, array_begin(cur_mission->markers), array_end(cur_mission->markers) );
      mission_sysMark();
      return 0;
   }
 
   /* Handle parameters. */
   id    = luaL_checkinteger( L, 1 );
 
   /* Check id. */
   marker = NULL;
   for (int i=0; i<array_size( cur_mission->markers ); i++) {
      if (id == cur_mission->markers[i].id) {
         marker = &cur_mission->markers[i];
         break;
      }
   }
   if (marker == NULL) {
      /* Already removed. */
      return 0;
   }
 
   /* Remove the marker. */
   array_erase( &cur_mission->markers, &marker[0], &marker[1] );
 
   /* Update system markers. */
   mission_sysMark();
   return 0;
}
 
static int misn_setNPC( lua_State *L )
{
   const char *name, *desc;
   Mission *cur_mission;
 
   cur_mission = misn_getFromLua(L);
 
   gl_freeTexture(cur_mission->portrait);
   cur_mission->portrait = NULL;
 
   free(cur_mission->npc);
   cur_mission->npc = NULL;
 
   free(cur_mission->npc_desc);
   cur_mission->npc_desc = NULL;
 
   /* For no parameters just leave having freed NPC. */
   if (lua_gettop(L) == 0)
      return 0;
 
   /* Get parameters. */
   name = luaL_checkstring(L,1);
   cur_mission->portrait = luaL_validtex(L,2,GFX_PATH"portraits/");
   desc = luaL_checkstring(L,3);
 
   /* Set NPC name and description. */
   cur_mission->npc = strdup(name);
   cur_mission->npc_desc = strdup(desc);
 
   return 0;
}
 
static int misn_factions( lua_State *L )
{
   Mission *cur_mission = misn_getFromLua(L);
   const MissionData *dat = cur_mission->data;
 
   /* we'll push all the factions in table form */
   lua_newtable(L);
   for (int i=0; i<array_size(dat->avail.factions); i++) {
      LuaFaction f = dat->avail.factions[i];
      lua_pushfaction(L, f); /* value */
      lua_rawseti(L,-2,i+1); /* store the value in the table */
   }
   return 1;
}
static int misn_accept( lua_State *L )
{
   Mission *new_misn, *cur_mission;
   int ret = 0;
 
   if (player_missions == NULL)
      player_missions = array_create( Mission* );
 
   /* Clean up old stale stuff if necessary. */
   for (int i=array_size(player_missions)-1; i>=0; i--) {
      Mission *m = player_missions[i];
      if (m->id != 0)
         continue;
      mission_cleanup( m );
      free( m );
      array_erase( &player_missions, &player_missions[i], &player_missions[i+1] );
   }
 
   /* Create the new mission. */
   new_misn = calloc( 1, sizeof(Mission) );
   array_push_back( &player_missions, new_misn );
 
   cur_mission = misn_getFromLua(L);
 
   /* no missions left */
   if (cur_mission->accepted)
      return NLUA_ERROR(L, _("Mission already accepted!"));
   else { /* copy it over */
      Mission **misnptr;
      *new_misn = *cur_mission;
      memset( cur_mission, 0, sizeof(Mission) );
      cur_mission->env = LUA_NOREF;
      cur_mission->accepted = 1; /* Propagated to the mission computer. */
      cur_mission = new_misn;
      cur_mission->accepted = 1; /* Mark as accepted. */
 
      /* Need to change pointer. */
      misnptr = lua_newuserdata( L, sizeof(Mission*) );
      *misnptr = cur_mission;
      nlua_setenv( L, cur_mission->env, "__misn" );
   }
 
   lua_pushboolean(L,!ret); /* we'll convert C style return to Lua */
   return 1;
}
static int misn_finish( lua_State *L )
{
   int b = lua_toboolean(L,1);
   Mission *cur_mission = misn_getFromLua(L);
 
   lua_pushboolean( L, 1 );
   nlua_setenv( L, cur_mission->env, "__misn_delete" );
 
   if (b)
      player_missionFinished( mission_getID( cur_mission->data->name ) );
 
   lua_pushstring(L, NLUA_DONE);
   lua_error(L); /* shouldn't return */
 
   return 0;
}
 
static int misn_cargoAdd( lua_State *L )
{
   Commodity *cargo;
   int quantity, ret;
   Mission *cur_mission;
 
   /* Parameters. */
   cargo    = luaL_validcommodity(L,1);
   quantity = luaL_checkint(L,2);
 
   cur_mission = misn_getFromLua(L);
 
   /* First try to add the cargo. */
   ret = pilot_addMissionCargo( player.p, cargo, quantity );
   mission_linkCargo( cur_mission, ret );
 
   lua_pushnumber(L, ret);
   return 1;
}
static int misn_cargoRm( lua_State *L )
{
   int ret;
   unsigned int id;
   Mission *cur_mission;
 
   id = luaL_checklong(L,1);
 
   /* First try to remove the cargo from player. */
   if (pilot_rmMissionCargo( player.p, id, 0 ) != 0) {
      lua_pushboolean(L,0);
      return 1;
   }
 
   cur_mission = misn_getFromLua(L);
 
   /* Now unlink the mission cargo if it was successful. */
   ret = mission_unlinkCargo( cur_mission, id );
 
   lua_pushboolean(L,!ret);
   return 1;
}
static int misn_cargoJet( lua_State *L )
{
   int ret;
   unsigned int id;
   Mission *cur_mission;
 
   id = luaL_checklong(L,1);
 
   /* First try to remove the cargo from player. */
   if (pilot_rmMissionCargo( player.p, id, 1 ) != 0) {
      lua_pushboolean(L,0);
      return 1;
   }
 
   cur_mission = misn_getFromLua(L);
 
   /* Now unlink the mission cargo if it was successful. */
   ret = mission_unlinkCargo( cur_mission, id );
 
   lua_pushboolean(L,!ret);
   return 1;
}
 
static int misn_osdCreate( lua_State *L )
{
   const char *title;
   int nitems;
   char **items;
   Mission *cur_mission = misn_getFromLua(L);
 
   /* Must be accepted. */
   if (!cur_mission->accepted) {
      WARN(_("Can't create an OSD on an unaccepted mission!"));
      return 0;
   }
 
   /* Check parameters. */
   title  = luaL_checkstring(L,1);
   luaL_checktype(L,2,LUA_TTABLE);
   nitems = lua_objlen(L,2);
 
   /* Destroy OSD if already exists. */
   if (cur_mission->osd != 0) {
      osd_destroy( cur_mission->osd );
      cur_mission->osd = 0;
   }
 
   /* Allocate items. */
   items = calloc( nitems, sizeof(char *) );
 
   /* Get items. */
   for (int i=0; i<nitems; i++) {
      lua_pushnumber(L,i+1);
      lua_gettable(L,2);
      if (!lua_isstring(L,-1)) {
         free(items);
         luaL_typerror(L, -1, "string");
         return 0;
      }
      items[i] = strdup( lua_tostring(L, -1) );
      lua_pop(L,1);
   }
 
   /* Create OSD. */
   cur_mission->osd = osd_create( title, nitems, (const char**) items,
         cur_mission->data->avail.priority );
   cur_mission->osd_set = 1; /* OSD was explicitly set. */
 
   /* Free items. */
   for (int i=0; i<nitems; i++)
      free(items[i]);
   free(items);
 
   return 0;
}
 
static int misn_osdDestroy( lua_State *L )
{
   Mission *cur_mission = misn_getFromLua(L);
 
   if (cur_mission->osd != 0) {
      osd_destroy( cur_mission->osd );
      cur_mission->osd = 0;
   }
 
   return 0;
}
 
static int misn_osdActive( lua_State *L )
{
   int n;
   Mission *cur_mission;
 
   n = luaL_checkint(L,1);
   n = n-1; /* Convert to C index. */
 
   cur_mission = misn_getFromLua(L);
 
   if (cur_mission->osd != 0)
      osd_active( cur_mission->osd, n );
 
   return 0;
}
 
static int misn_osdGetActiveItem( lua_State *L )
{
   const Mission *cur_mission = misn_getFromLua(L);
   char **items = osd_getItems(cur_mission->osd);
   int active   = osd_getActive(cur_mission->osd);
 
   if (!items || active < 0) {
      lua_pushnil(L);
      return 1;
   }
 
   lua_pushstring(L, items[active]);
   return 1;
}
 
static int misn_osdGet( lua_State *L )
{
   const Mission *cur_mission = misn_getFromLua(L);
   char **items;
 
   if (cur_mission->osd == 0)
      return 0;
 
   lua_pushstring( L, osd_getTitle(cur_mission->osd) );
   lua_newtable(L);
   items = osd_getItems(cur_mission->osd);
   for (int i=0; i<array_size(items); i++) {
      lua_pushstring( L, items[i] );
      lua_rawseti( L, -2, i+1 );
   }
   lua_pushinteger( L, osd_getActive(cur_mission->osd) );
   return 3;
}
 
static int misn_npcAdd( lua_State *L )
{
   unsigned int id;
   int priority;
   const char *func, *name, *desc;
   glTexture *portrait, *bg;
   Mission *cur_mission;
 
   /* 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_mission = misn_getFromLua(L);
 
   /* Add npc. */
   id = npc_add_mission( cur_mission->id, func, name, priority, portrait, desc, bg );
 
   /* Regenerate bar. */
   bar_regen();
 
   /* Return ID. */
   if (id > 0) {
      lua_pushnumber( L, id );
      return 1;
   }
   return 0;
}
 
static int misn_npcRm( lua_State *L )
{
   unsigned int id = luaL_checklong(L, 1);
   const Mission *cur_mission = misn_getFromLua(L);
   int ret = npc_rm_mission( id, cur_mission->id );
 
   /* Regenerate bar. */
   bar_regen();
 
   if (ret != 0)
      return NLUA_ERROR(L, _("Invalid NPC ID!"));
   return 0;
}
 
static int misn_claim( lua_State *L )
{
   Claim_t *claim;
   Mission *cur_mission;
   int inclusive;
 
   /* Get mission. */
   cur_mission = misn_getFromLua(L);
 
   inclusive = lua_toboolean(L,2);
 
   /* Check to see if already claimed. */
   if (!claim_isNull(cur_mission->claims))
      return NLUA_ERROR(L, _("Mission trying to claim but already has."));
 
   /* Create the claim. */
   claim = claim_create( !inclusive );
 
   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_mission->claims = claim;
   claim_activate( claim );
   lua_pushboolean(L,1);
   return 1;
}
 
void misn_pushMissionData( lua_State *L, const MissionData *md )
{
   const MissionAvail_t *ma = &md->avail;
 
   lua_newtable(L);
 
   lua_pushstring( L, md->name );
   lua_setfield(L,-2,"name");
 
   lua_pushstring( L, mission_availabilityStr(ma->loc) );
   lua_setfield(L,-2,"loc");
 
   lua_pushinteger( L, ma->chance );
   lua_setfield(L,-2,"chance");
 
   if (ma->spob != NULL) {
      lua_pushstring( L, ma->spob );
      lua_setfield(L,-2,"spob");
   }
 
   if (ma->system != NULL) {
      lua_pushstring( L, ma->system );
      lua_setfield(L,-2,"system");
   }
 
   if (ma->chapter != NULL) {
      lua_pushstring( L, ma->chapter );
      lua_setfield(L,-2,"chapter");
   }
 
   /* TODO factions. */
 
   if (ma->cond != NULL) {
      lua_pushstring( L, ma->cond );
      lua_setfield(L,-2,"cond");
   }
 
   if (ma->done != NULL) {
      lua_pushstring( L, ma->done );
      lua_setfield(L,-2,"done");
   }
 
   lua_pushinteger( L, ma->priority );
   lua_setfield(L,-2,"priority");
 
   if (mis_isFlag(md,MISSION_UNIQUE)) {
      lua_pushboolean( L, 1 );
      lua_setfield(L,-2,"unique");
   }
 
   lua_newtable(L);
   for (int t=0; t<array_size(md->tags); t++) {
      lua_pushstring( L, md->tags[t] );
      lua_pushboolean( L, 1 );
      lua_rawset( L, -3 );
   }
   lua_setfield(L,-2,"tags");
}