nlua_faction.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <lauxlib.h>
 
#include "nlua_faction.h"
 
#include "array.h"
#include "faction.h"
#include "nlua.h"
#include "nlua_colour.h"
#include "nlua_system.h"
#include "nlua_tex.h"
#include "nluadef.h"
 
/* Internal useful functions. */
static LuaFaction luaL_validfactionSilent( lua_State *L, int ind );
/* Faction metatable methods */
static int factionL_exists( lua_State *L );
static int factionL_get( lua_State *L );
static int factionL_getAll( lua_State *L );
static int factionL_player( lua_State *L );
static int factionL_eq( lua_State *L );
static int factionL_name( lua_State *L );
static int factionL_nameRaw( lua_State *L );
static int factionL_longname( lua_State *L );
static int factionL_areneutral( lua_State *L );
static int factionL_areenemies( lua_State *L );
static int factionL_areallies( lua_State *L );
static int factionL_usesHiddenJumps( lua_State *L );
static int factionL_hit( lua_State *L );
static int factionL_hitTest( lua_State *L );
static int factionL_reputationGlobal( lua_State *L );
static int factionL_reputationText( lua_State *L );
static int factionL_reputationDefault( lua_State *L );
static int factionL_setReputationGlobal( lua_State *L );
static int factionL_applyLocalThreshold( lua_State *L );
static int factionL_enemies( lua_State *L );
static int factionL_allies( lua_State *L );
static int factionL_logo( lua_State *L );
static int factionL_colour( lua_State *L );
static int factionL_isKnown( lua_State *L );
static int factionL_setKnown( lua_State *L );
static int factionL_isInvisible( lua_State *L );
static int factionL_isStatic( lua_State *L );
static int factionL_reputationOverride( lua_State *L );
static int factionL_setReputationOverride( lua_State *L );
static int factionL_tags( lua_State *L );
static int factionL_dynAdd( lua_State *L );
static int factionL_dynAlly( lua_State *L );
static int factionL_dynEnemy( lua_State *L );
/* Following functions are deprecated and should be removed in 0.13.0. */
static int factionL_modplayer( lua_State *L );
static int factionL_modplayersingle( lua_State *L );
static int factionL_modplayerraw( lua_State *L );
static int factionL_setplayerstanding( lua_State *L );
static int factionL_playerstanding( lua_State *L );
static int factionL_playerstandingdefault( lua_State *L );
/* End of deprecated functions. */
 
static const luaL_Reg faction_methods[] = {
   { "exists", factionL_exists },
   { "get", factionL_get },
   { "getAll", factionL_getAll },
   { "player", factionL_player },
   { "__eq", factionL_eq },
   { "__tostring", factionL_name },
   { "name", factionL_name },
   { "nameRaw", factionL_nameRaw },
   { "longname", factionL_longname },
   { "areNeutral", factionL_areneutral },
   { "areEnemies", factionL_areenemies },
   { "areAllies", factionL_areallies },
   { "hit", factionL_hit },
   { "hitTest", factionL_hitTest },
   { "reputationGlobal", factionL_reputationGlobal },
   { "reputationText", factionL_reputationText },
   { "reputationDefault", factionL_reputationDefault },
   { "setReputationGlobal", factionL_setReputationGlobal },
   { "applyLocalThreshold", factionL_applyLocalThreshold },
   { "modPlayer", factionL_modplayer },
   { "modPlayerSingle", factionL_modplayersingle },
   { "modPlayerRaw", factionL_modplayerraw },
   { "setPlayerStanding", factionL_setplayerstanding },
   { "playerStanding", factionL_playerstanding },
   { "playerStandingDefault", factionL_playerstandingdefault },
   { "enemies", factionL_enemies },
   { "allies", factionL_allies },
   { "usesHiddenJumps", factionL_usesHiddenJumps },
   { "logo", factionL_logo },
   { "colour", factionL_colour },
   { "known", factionL_isKnown },
   { "setKnown", factionL_setKnown },
   { "invisible", factionL_isInvisible },
   { "static", factionL_isStatic },
   { "reputationOverride", factionL_reputationOverride },
   { "setReputationOverride", factionL_setReputationOverride },
   { "tags", factionL_tags },
   { "dynAdd", factionL_dynAdd },
   { "dynAlly", factionL_dynAlly },
   { "dynEnemy", factionL_dynEnemy },
   { 0, 0 } }; 

int nlua_loadFaction( nlua_env env )
{
   nlua_register( env, FACTION_METATABLE, faction_methods, 1 );
   return 0; /* No error */
}

static int factionL_exists( lua_State *L )
{
   const char *s = luaL_checkstring( L, 1 );
   if ( faction_exists( s ) ) {
      lua_pushfaction( L, faction_get( s ) );
      return 1;
   }
   return 0;
}

static int factionL_get( lua_State *L )
{
   LuaFaction f = luaL_validfaction( L, 1 );
   lua_pushfaction( L, f );
   return 1;
}

static int factionL_getAll( lua_State *L )
{
   const int *factions = faction_getAll();
   lua_newtable( L );
   for ( int i = 0; i < array_size( factions ); i++ ) {
      lua_pushfaction( L, factions[i] );
      lua_rawseti( L, -2, i + 1 );
   }
   array_free( factions );
   return 1;
}

static int factionL_player( lua_State *L )
{
   lua_pushfaction( L, faction_player );
   return 1;
}

LuaFaction lua_tofaction( lua_State *L, int ind )
{
   return *( (LuaFaction *)lua_touserdata( L, ind ) );
}
 
LuaFaction lua_checkfaction( lua_State *L, int ind )
{
   if ( lua_isfaction( L, ind ) )
      return lua_tofaction( L, ind );
   luaL_typerror( L, ind, FACTION_METATABLE );
   return -1;
}
 
static LuaFaction luaL_validfactionSilent( lua_State *L, int ind )
{
   if ( lua_isfaction( L, ind ) )
      return lua_tofaction( L, ind );
   else if ( lua_isstring( L, ind ) )
      return faction_get( lua_tostring( L, ind ) );
   luaL_typerror( L, ind, FACTION_METATABLE );
   return 0;
}

LuaFaction luaL_validfaction( lua_State *L, int ind )
{
   int id = luaL_validfactionSilent( L, ind );
   if ( id == -1 )
      return NLUA_ERROR( L, _( "Faction '%s' not found in stack." ),
                         lua_tostring( L, ind ) );
   return id;
}

LuaFaction *lua_pushfaction( lua_State *L, LuaFaction faction )
{
   LuaFaction *f = (LuaFaction *)lua_newuserdata( L, sizeof( LuaFaction ) );
   *f            = faction;
   luaL_getmetatable( L, FACTION_METATABLE );
   lua_setmetatable( L, -2 );
   return f;
}

int lua_isfaction( lua_State *L, int ind )
{
   int ret;
 
   if ( lua_getmetatable( L, ind ) == 0 )
      return 0;
   lua_getfield( L, LUA_REGISTRYINDEX, FACTION_METATABLE );
 
   ret = 0;
   if ( lua_rawequal( L, -1, -2 ) ) /* does it have the correct mt? */
      ret = 1;
 
   lua_pop( L, 2 ); /* remove both metatables */
   return ret;
}

static int factionL_eq( lua_State *L )
{
   int a = luaL_validfaction( L, 1 );
   int b = luaL_validfaction( L, 2 );
   lua_pushboolean( L, a == b );
   return 1;
}

static int factionL_name( lua_State *L )
{
   int f = luaL_validfaction( L, 1 );
   lua_pushstring( L, faction_shortname( f ) );
   return 1;
}

static int factionL_nameRaw( lua_State *L )
{
   int f = luaL_validfaction( L, 1 );
   lua_pushstring( L, faction_name( f ) );
   return 1;
}

static int factionL_longname( lua_State *L )
{
   int f = luaL_validfaction( L, 1 );
   lua_pushstring( L, faction_longname( f ) );
   return 1;
}

static int factionL_areneutral( lua_State *L )
{
   int f  = luaL_validfaction( L, 1 );
   int ff = luaL_validfaction( L, 2 );
   lua_pushboolean( L, areNeutral( f, ff ) );
   return 1;
}

static int factionL_areenemies( lua_State *L )
{
   int f  = luaL_validfaction( L, 1 );
   int ff = luaL_validfaction( L, 2 );
   if ( !lua_isnoneornil( L, 3 ) )
      lua_pushboolean( L, areEnemiesSystem( f, ff, luaL_validsystem( L, 3 ) ) );
   else
      lua_pushboolean( L, areEnemies( f, ff ) );
   return 1;
}

static int factionL_areallies( lua_State *L )
{
   int f  = luaL_validfaction( L, 1 );
   int ff = luaL_validfaction( L, 2 );
   if ( !lua_isnoneornil( L, 3 ) )
      lua_pushboolean( L, areAlliesSystem( f, ff, luaL_validsystem( L, 3 ) ) );
   else
      lua_pushboolean( L, areAllies( f, ff ) );
   return 1;
}

static int factionL_hit( lua_State *L )
{
   int               f   = luaL_validfaction( L, 1 );
   double            mod = luaL_checknumber( L, 2 );
   const StarSystem *sys =
      ( lua_isnoneornil( L, 3 ) ) ? NULL : luaL_validsystem( L, 3 );
   const char *reason = luaL_optstring( L, 4, "script" );
   double      ret = faction_hit( f, sys, mod, reason, lua_toboolean( L, 5 ) );
   lua_pushnumber( L, ret );
   return 1;
}

static int factionL_hitTest( lua_State *L )
{
   int               f   = luaL_validfaction( L, 1 );
   double            mod = luaL_checknumber( L, 2 );
   const StarSystem *sys =
      ( lua_isnoneornil( L, 3 ) ) ? NULL : luaL_validsystem( L, 3 );
   const char *reason = luaL_optstring( L, 4, "script" );
   double      ret    = faction_hitTest( f, sys, mod, reason );
   lua_pushnumber( L, ret );
   return 1;
}

static int factionL_reputationGlobal( lua_State *L )
{
   int f = luaL_validfaction( L, 1 );
   lua_pushnumber( L, faction_reputation( f ) );
   return 1;
}

static int factionL_reputationText( lua_State *L )
{
   int f = luaL_validfaction( L, 1 );
   if ( lua_isnoneornil( L, 2 ) )
      lua_pushstring( L, faction_getStandingTextAtValue(
                            f, faction_reputationDefault( f ) ) );
   else
      lua_pushstring(
         L, faction_getStandingTextAtValue( f, luaL_checknumber( L, 2 ) ) );
   return 1;
}

static int factionL_reputationDefault( lua_State *L )
{
   int f = luaL_validfaction( L, 1 );
   lua_pushnumber( L, faction_reputationDefault( f ) );
   return 1;
}

static int factionL_setReputationGlobal( lua_State *L )
{
   int    f = luaL_validfaction( L, 1 );
   double n = luaL_checknumber( L, 2 );
   /* TODO finish. */
   faction_setReputation( f, n );
   return 0;
}

static int factionL_applyLocalThreshold( lua_State *L )
{
   int         f   = luaL_validfaction( L, 1 );
   StarSystem *sys = luaL_validsystem( L, 2 );
   faction_applyLocalThreshold( f, sys );
   return 0;
}

static int factionL_modplayer( lua_State *L )
{
   NLUA_DEPRECATED( L, "modPlayer" );
   int         f      = luaL_validfaction( L, 1 );
   double      n      = luaL_checknumber( L, 2 );
   const char *reason = luaL_optstring( L, 3, "script" );
   faction_modPlayer( f, n, reason );
   return 0;
}

static int factionL_modplayersingle( lua_State *L )
{
   NLUA_DEPRECATED( L, "modPlayerSingle" );
   int         f      = luaL_validfaction( L, 1 );
   double      n      = luaL_checknumber( L, 2 );
   const char *reason = luaL_optstring( L, 3, "script" );
   faction_modPlayerSingle( f, n, reason );
   return 0;
}

static int factionL_modplayerraw( lua_State *L )
{
   NLUA_DEPRECATED( L, "modPlayerRaw" );
   int    f = luaL_validfaction( L, 1 );
   double n = luaL_checknumber( L, 2 );
   faction_modPlayerRaw( f, n );
   return 0;
}

static int factionL_setplayerstanding( lua_State *L )
{
   NLUA_DEPRECATED( L, "setPlayerStanding" );
   int    f = luaL_validfaction( L, 1 );
   double n = luaL_checknumber( L, 2 );
   faction_setReputation( f, n );
   return 0;
}

static int factionL_playerstanding( lua_State *L )
{
   NLUA_DEPRECATED( L, "playerStanding" );
   int    f = luaL_validfaction( L, 1 );
   double n;
   if ( !lua_isnoneornil( L, 2 ) )
      n = luaL_checknumber( L, 2 );
   else
      n = faction_reputation( f );
   lua_pushnumber( L, n );
   lua_pushstring( L, faction_getStandingTextAtValue( f, n ) );
   return 2;
}

static int factionL_playerstandingdefault( lua_State *L )
{
   NLUA_DEPRECATED( L, "playerStandingDefault" );
   int    f = luaL_validfaction( L, 1 );
   double n = faction_reputationDefault( f );
   lua_pushnumber( L, n );
   return 1;
}

static int factionL_enemies( lua_State *L )
{
   const int *factions;
   int        f = luaL_validfaction( L, 1 );
 
   /* Push the enemies in a table. */
   lua_newtable( L );
   factions = faction_getEnemies( f );
   for ( int i = 0; i < array_size( factions ); i++ ) {
      lua_pushfaction( L, factions[i] ); /* value */
      lua_rawseti( L, -2, i + 1 );
   }
 
   return 1;
}

static int factionL_allies( lua_State *L )
{
   const int *factions;
   int        f = luaL_validfaction( L, 1 );
 
   /* Push the enemies in a table. */
   lua_newtable( L );
   factions = faction_getAllies( f );
   for ( int i = 0; i < array_size( factions ); i++ ) {
      lua_pushfaction( L, factions[i] ); /* value */
      lua_rawseti( L, -2, i + 1 );
   }
 
   return 1;
}

static int factionL_usesHiddenJumps( lua_State *L )
{
   int f = luaL_validfaction( L, 1 );
   lua_pushboolean( L, faction_usesHiddenJumps( f ) );
   return 1;
}

static int factionL_logo( lua_State *L )
{
   int              lf  = luaL_validfaction( L, 1 );
   const glTexture *tex = faction_logo( lf );
   if ( tex == NULL )
      return 0;
   lua_pushtex( L, gl_dupTexture( tex ) );
   return 1;
}

static int factionL_colour( lua_State *L )
{
   int             lf  = luaL_validfaction( L, 1 );
   const glColour *col = faction_reputationColour( lf );
   if ( col == NULL )
      return 0;
   lua_pushcolour( L, *col );
   return 1;
}

static int factionL_isKnown( lua_State *L )
{
   int fac = luaL_validfaction( L, 1 );
   lua_pushboolean( L, faction_isKnown( fac ) );
   return 1;
}

static int factionL_setKnown( lua_State *L )
{
   int fac = luaL_validfaction( L, 1 );
   int b   = lua_toboolean( L, 2 );
   faction_setKnown( fac, b );
   return 0;
}

static int factionL_isInvisible( lua_State *L )
{
   int fac = luaL_validfaction( L, 1 );
   lua_pushboolean( L, faction_isInvisible( fac ) );
   return 1;
}

static int factionL_isStatic( lua_State *L )
{
   int fac = luaL_validfaction( L, 1 );
   lua_pushboolean( L, faction_isStatic( fac ) );
   return 1;
}

static int factionL_reputationOverride( lua_State *L )
{
   int    fac = luaL_validfaction( L, 1 );
   int    set;
   double val = faction_reputationOverride( fac, &set );
   if ( !set )
      return 0;
   lua_pushnumber( L, val );
   return 1;
}

static int factionL_setReputationOverride( lua_State *L )
{
   int fac = luaL_validfaction( L, 1 );
   int set = !lua_isnoneornil( L, 2 );
   faction_setReputationOverride( fac, set, luaL_optnumber( L, 2, 0. ) );
   return 1;
}

static int factionL_tags( lua_State *L )
{
   int fac = luaL_validfaction( L, 1 );
   return nlua_helperTags( L, 2, (char *const *)faction_tags( fac ) );
}

static int factionL_dynAdd( lua_State *L )
{
   LuaFaction      fac, newfac;
   const char     *name, *display, *ai;
   const glColour *colour;
   int             clear_allies, clear_enemies;
   double          player;
   int             set_player;
 
   if ( !lua_isnoneornil( L, 1 ) )
      fac = luaL_validfactionSilent( L, 1 ); /* Won't error. */
   else
      fac = -1;
   name       = luaL_checkstring( L, 2 );
   display    = luaL_optstring( L, 3, name );
   set_player = 0;
 
   /* Just return existing and ignore the rest. */
   if ( faction_exists( name ) ) {
      int f = faction_get( name );
      if ( !faction_isDynamic( f ) )
         return NLUA_ERROR( L,
                            _( "Trying to overwrite existing faction '%s' with "
                               "dynamic faction!" ),
                            name );
 
      lua_pushfaction( L, f );
      return 1;
   }
 
   /* Parse parameters. */
   if ( lua_istable( L, 4 ) ) {
      lua_getfield( L, 4, "ai" );
      ai = luaL_optstring( L, -1, NULL );
      lua_pop( L, 1 );
 
      lua_getfield( L, 4, "clear_allies" );
      clear_allies = lua_toboolean( L, -1 );
      lua_pop( L, 1 );
 
      lua_getfield( L, 4, "clear_enemies" );
      clear_enemies = lua_toboolean( L, -1 );
      lua_pop( L, 1 );
 
      lua_getfield( L, 4, "player" );
      if ( lua_isnumber( L, -1 ) ) {
         player     = lua_tonumber( L, -1 );
         set_player = 1;
      }
      lua_pop( L, 1 );
 
      lua_getfield( L, 4, "colour" );
      if ( lua_isstring( L, -1 ) )
         colour = col_fromName( lua_tostring( L, -1 ) );
      else
         colour = lua_tocolour( L, -1 );
      lua_pop( L, 1 );
   } else {
      ai            = NULL;
      clear_allies  = 0;
      clear_enemies = 0;
      player        = 0.;
      colour        = NULL;
   }
 
   /* Create new faction. */
   newfac = faction_dynAdd( fac, name, display, ai, colour );
 
   /* Clear if necessary. */
   if ( clear_allies )
      faction_clearAlly( newfac );
   if ( clear_enemies )
      faction_clearEnemy( newfac );
   if ( set_player )
      faction_setReputation( newfac, player );
 
   lua_pushfaction( L, newfac );
   return 1;
}

static int factionL_dynAlly( lua_State *L )
{
   LuaFaction fac, ally;
   int        remove;
   fac = luaL_validfaction( L, 1 );
   if ( !faction_isDynamic( fac ) )
      return NLUA_ERROR( L, _( "Can only add allies to dynamic factions" ) );
   ally   = luaL_validfaction( L, 2 );
   remove = lua_toboolean( L, 3 );
   if ( remove )
      faction_rmAlly( fac, ally );
   else
      faction_addAlly( fac, ally );
   return 0;
}

static int factionL_dynEnemy( lua_State *L )
{
   LuaFaction fac, enemy;
   int        remove;
   fac = luaL_validfaction( L, 1 );
   if ( !faction_isDynamic( fac ) )
      return NLUA_ERROR( L, _( "Can only add allies to dynamic factions" ) );
   enemy  = luaL_validfaction( L, 2 );
   remove = lua_toboolean( L, 3 );
   if ( remove )
      faction_rmEnemy( fac, enemy );
   else
      faction_addEnemy( fac, enemy );
   return 0;
}