src/nlua_system.c

   1 /*
   2  * See Licensing and Copyright notice in naev.h
   3  */
   4
   5 /**
   6  * @file nlua_system.c
   7  *
   8  * @brief Lua system module.
   9  */
  10
  11 #include "nlua_system.h"
  12
  13 #include "naev.h"
  14
  15 #include "lauxlib.h"
  16
  17 #include "nlua.h"
  18 #include "nluadef.h"
  19 #include "nlua_faction.h"
  20 #include "nlua_vec2.h"
  21 #include "nlua_planet.h"
  22 #include "log.h"
  23 #include "rng.h"
  24 #include "land.h"
  25 #include "map.h"
  26
  27
  28 /* System metatable methods */
  29 static int systemL_cur( lua_State *L );
  30 static int systemL_get( lua_State *L );
  31 static int systemL_eq( lua_State *L );
  32 static int systemL_name( lua_State *L );
  33 static int systemL_faction( lua_State *L );
  34 static int systemL_nebula( lua_State *L );
  35 static int systemL_jumpdistance( lua_State *L );
  36 static int systemL_adjacent( lua_State *L );
  37 static int systemL_hasPresence( lua_State *L );
  38 static int systemL_planets( lua_State *L );
  39 static int systemL_security( lua_State *L );
  40 static const luaL_reg system_methods[] = {
  41    { "cur", systemL_cur },
  42    { "get", systemL_get },
  43    { "__eq", systemL_eq },
  44    { "__tostring", systemL_name },
  45    { "name", systemL_name },
  46    { "faction", systemL_faction },
  47    { "nebula", systemL_nebula },
  48    { "jumpDist", systemL_jumpdistance },
  49    { "adjacentSystems", systemL_adjacent },
  50    { "hasPresence", systemL_hasPresence },
  51    { "planets", systemL_planets },
  52    { "security", systemL_security },
  53    {0,0}
  54 }; /**< System metatable methods. */
  55
  56
  57 /**
  58  * @brief Loads the system library.
  59  *
  60  *    @param L State to load system library into.
  61  *    @param readonly Load read only functions?
  62  *    @return 0 on success.
  63  */
  64 int nlua_loadSystem( lua_State *L, int readonly )
  65 {
  66    (void)readonly; /* only read only atm */
  67
  68    /* Create the metatable */
  69    luaL_newmetatable(L, SYSTEM_METATABLE);
  70
  71    /* Create the access table */
  72    lua_pushvalue(L,-1);
  73    lua_setfield(L,-2,"__index");
  74
  75    /* Register the values */
  76    luaL_register(L, NULL, system_methods);
  77
  78    /* Clean up. */
  79    lua_setfield(L, LUA_GLOBALSINDEX, SYSTEM_METATABLE);
  80
  81    return 0; /* No error */
  82 }
  83
  84
  85 /**
  86  * @brief Lua system module.
  87  *
  88  * This module allows you to use the Star Systems from Lua.
  89  *
  90  * Typical example would be something like:
  91  * @code
  92  * cur = system.get() -- Gets current system
  93  * sys = system.get( "Gamma Polaris" )
  94  * @endcode
  95  *
  96  * @luamod system
  97  */
  98 /**
  99  * @brief Gets system at index.
 100  *
 101  *    @param L Lua state to get system from.
 102  *    @param ind Index position of system.
 103  *    @return The LuaSystem at ind.
 104  */
 105 LuaSystem* lua_tosystem( lua_State *L, int ind )
 106 {
 107    return (LuaSystem*) lua_touserdata(L,ind);
 108 }
 109 /**
 110  * @brief Gets system at index raising an error if type doesn't match.
 111  *
 112  *    @param L Lua state to get system from.
 113  *    @param ind Index position of system.
 114  *    @return The LuaSystem at ind.
 115  */
 116 LuaSystem* luaL_checksystem( lua_State *L, int ind )
 117 {
 118    if (lua_issystem(L,ind))
 119       return lua_tosystem(L,ind);
 120    luaL_typerror(L, ind, SYSTEM_METATABLE);
 121    return NULL;
 122 }
 123
 124 /**
 125  * @brief Pushes a system on the stack.
 126  *
 127  *    @param L Lua state to push system onto.
 128  *    @param sys System to push.
 129  *    @return System just pushed.
 130  */
 131 LuaSystem* lua_pushsystem( lua_State *L, LuaSystem sys )
 132 {
 133    LuaSystem *s;
 134    s = (LuaSystem*) lua_newuserdata(L, sizeof(LuaSystem));
 135    *s = sys;
 136    luaL_getmetatable(L, SYSTEM_METATABLE);
 137    lua_setmetatable(L, -2);
 138    return s;
 139 }
 140
 141 /**
 142  * @brief Checks to see if ind is a system.
 143  *
 144  *    @param L Lua state to check.
 145  *    @param ind Index position to check.
 146  *    @return 1 if there is a system at index position.
 147  */
 148 int lua_issystem( lua_State *L, int ind )
 149 {
 150    int ret;
 151
 152    if (lua_getmetatable(L,ind)==0)
 153       return 0;
 154    lua_getfield(L, LUA_REGISTRYINDEX, SYSTEM_METATABLE);
 155
 156    ret = 0;
 157    if (lua_rawequal(L, -1, -2))  /* does it have the correct mt? */
 158       ret = 1;
 159
 160    lua_pop(L, 2);  /* remove both metatables */
 161    return ret;
 162 }
 163
 164
 165 /**
 166  * @brief Gets the current system.
 167  *
 168  * @usage sys = system.cur() -- Gets the current system
 169  *
 170  *    @luareturn Current system.
 171  * @luafunc cur()
 172  */
 173 static int systemL_cur( lua_State *L )
 174 {
 175    LuaSystem sys;
 176    sys.s = cur_system;
 177    lua_pushsystem(L,sys);
 178    return 1;
 179 }
 180
 181
 182 /**
 183  * @brief Gets a system.
 184  *
 185  * Behaves differently depending on what you pass as param:
 186  *    - nil : -OBSOLETE- Gets the current system. Use system.cur() instead.
 187  *    - string : Gets the system by name.
 188  *    - planet : Gets the system by planet.
 189  *
 190  * @usage sys = system.get( p ) -- Gets system where planet 'p' is located.
 191  * @usage sys = system.get( "Gamma Polaris" ) -- Gets the system by name.
 192  *
 193  *    @luaparam param Read description for details.
 194  *    @luareturn System metatable matching param.
 195  * @luafunc get( param )
 196  */
 197 static int systemL_get( lua_State *L )
 198 {
 199    LuaSystem sys;
 200    LuaPlanet *p;
 201
 202    /* Get current system with no parameters */
 203    if (lua_gettop(L) == 0) {
 204       sys.s = cur_system;
 205    }
 206    /* Passing a string (systemname) */
 207    else if (lua_isstring(L,1)) {
 208       sys.s = system_get( lua_tostring(L,1) );
 209    }
 210    /* Passing a planet */
 211    else if (lua_isplanet(L,1)) {
 212       p = lua_toplanet(L,1);
 213       sys.s = system_get( planet_getSystem( p->p->name ) );
 214    }
 215    else NLUA_INVALID_PARAMETER();
 216
 217    /* Error checking. */
 218    if(sys.s == NULL) {
 219       NLUA_ERROR(L, "No matching systems found.");
 220       return 0;
 221    }
 222
 223    /* return the system */
 224    lua_pushsystem(L,sys);
 225    return 1;
 226 }
 227
 228 /**
 229  * @brief Check systems for equality.
 230  *
 231  * Allows you to use the '=' operator in Lua with systems.
 232  *
 233  * @usage if sys == system.get( "Draygar" ) then -- Do something
 234  *
 235  *    @luaparam s System comparing.
 236  *    @luaparam comp System to compare against.
 237  *    @luareturn true if both systems are the same.
 238  * @luafunc __eq( s, comp )
 239  */
 240 static int systemL_eq( lua_State *L )
 241 {
 242    LuaSystem *a, *b;
 243    a = luaL_checksystem(L,1);
 244    b = luaL_checksystem(L,2);
 245    if (a->s == b->s)
 246       lua_pushboolean(L,1);
 247    else
 248       lua_pushboolean(L,0);
 249    return 1;
 250 }
 251
 252 /**
 253  * @brief Returns the system's name.
 254  *
 255  * @usage name = sys:name()
 256  *
 257  *    @luaparam s System to get name of.
 258  *    @luareturn The name of the system.
 259  * @luafunc name( s )
 260  */
 261 static int systemL_name( lua_State *L )
 262 {
 263    LuaSystem *sys;
 264    sys = luaL_checksystem(L,1);
 265    lua_pushstring(L,sys->s->name);
 266    return 1;
 267 }
 268
 269 /**
 270  * @brief Gets system factions.
 271  *
 272  * @code
 273  * sys = system.get() -- Get current system
 274  * facts = sys:faction() -- Get factions
 275  * if facts["Empire"] then
 276  *    -- Do something since there is at least one Empire planet in the system
 277  * end
 278  * @endcode
 279  *
 280  *    @luaparam s System to get the factions of.
 281  *    @luareturn A table containing all the factions in the system.
 282  * @luafunc faction( s )
 283  */
 284 static int systemL_faction( lua_State *L )
 285 {
 286    int i;
 287    LuaSystem *sys;
 288    sys = luaL_checksystem(L,1);
 289
 290    /* Return result in table */
 291    lua_newtable(L);
 292    for (i=0; i<sys->s->nplanets; i++) {
 293       if (sys->s->planets[i]->faction > 0) { /* Faction must be valid */
 294          lua_pushboolean(L,1); /* value */
 295          lua_setfield(L,-2,faction_name(sys->s->planets[i]->faction)); /* key */
 296          /* allows syntax foo = space.faction("foo"); if foo["bar"] then ... end */
 297       }
 298    }
 299    return 1;
 300
 301 }
 302
 303
 304 /**
 305  * @brief Gets the system's nebula parameters.
 306  *
 307  * @usage density, volatility = sys:nebula()
 308  *
 309  *    @luaparam s System to get nebula parameters from.
 310  *    @luareturn The density and volatility of the system.
 311  * @luafunc nebula( s )
 312  */
 313 static int systemL_nebula( lua_State *L )
 314 {
 315    LuaSystem *sys;
 316    sys = luaL_checksystem(L,1);
 317
 318    /* Push the density and volatility. */
 319    lua_pushnumber(L, sys->s->nebu_density);
 320    lua_pushnumber(L, sys->s->nebu_volatility);
 321
 322    return 2;
 323 }
 324
 325
 326 /**
 327  * @brief Gets jump distance from current system, or to another.
 328  *
 329  * Does different things depending on the parameter type:
 330  *    - nil : Gets distance from current system.
 331  *    - string : Gets distance from system matching name.
 332  *    - system : Gets distance from system
 333  *
 334  * @usage d = sys:jumpDist() -- Distance from current system.
 335  * @usage d = sys:jumpDist( "Draygar" ) -- Distance from system Draygar.
 336  * @usage d = sys:jumpDist( another_sys ) -- Distance from system another_sys.
 337  *
 338  *    @luaparam param See description.
 339  *    @luareturn Number of jumps to system.
 340  * @luafunc jumpDist( param )
 341  */
 342 static int systemL_jumpdistance( lua_State *L )
 343 {
 344    LuaSystem *sys, *sysp;
 345    StarSystem **s;
 346    int jumps;
 347    const char *start, *goal;
 348
 349    sys = luaL_checksystem(L,1);
 350    start = sys->s->name;
 351
 352    if (lua_gettop(L) > 1) {
 353       if (lua_isstring(L,2))
 354          goal = lua_tostring(L,2);
 355       else if (lua_issystem(L,2)) {
 356          sysp = lua_tosystem(L,2);
 357          goal = sysp->s->name;
 358       }
 359       else NLUA_INVALID_PARAMETER();
 360    }
 361    else
 362       goal = cur_system->name;
 363
 364    s = map_getJumpPath( &jumps, start, goal, 1, NULL );
 365    free(s);
 366
 367    lua_pushnumber(L,jumps);
 368    return 1;
 369 }
 370
 371
 372 /**
 373  * @brief Gets all the ajacent systems to a system.
 374  *
 375  * @usage for k,v in pairs( sys:adjacentSystems() ) do -- Iterate over adjacent systems.
 376  *
 377  *    @luaparam s System to get adjacent systems of.
 378  *    @luareturn A table with all the adjacent systems.
 379  * @luafunc adjacentSystems( s )
 380  */
 381 static int systemL_adjacent( lua_State *L )
 382 {
 383    int i;
 384    LuaSystem *sys, sysp;
 385
 386    sys = luaL_checksystem(L,1);
 387
 388    /* Push all adjacent systems. */
 389    lua_newtable(L);
 390    for (i=0; i<sys->s->njumps; i++) {
 391       sysp.s = system_getIndex( sys->s->jumps[i] );
 392       lua_pushnumber(L,i+1); /* key */
 393       lua_pushsystem(L,sysp); /* value */
 394       lua_rawset(L,-3);
 395    }
 396
 397    return 1;
 398 }
 399
 400
 401 /**
 402  * @brief Checks to see if a faction has presence in a system.
 403  *
 404  * This checks to see if the faction has a possibility of having any ships at all
 405  *  be randomly generated in the system.
 406  *
 407  *  @usage if sys:hasPresence( "Empire" ) then -- Checks to see if Empire has ships in the system
 408  *  @usage if sys:hasPresence( faction.get("Pirate") ) then -- Checks to see if the Pirate has ships in the system
 409  *
 410  *    @luaparam s System to check to see if has presence of a certain faction.
 411  *    @luaparam f Faction or name of faction to check to see if has presence in the system.
 412  *    @luareturn true If faction has presence in the system, false otherwise.
 413  * @luafunc hasPresence( s, f )
 414  */
 415 static int systemL_hasPresence( lua_State *L )
 416 {
 417    LuaSystem *sys;
 418    LuaFaction *lf;
 419    int fct;
 420    int i, found;
 421
 422    sys = luaL_checksystem(L,1);
 423
 424    /* Get the second parameter. */
 425    if (lua_isstring(L,2)) {
 426       fct = faction_get( lua_tostring(L,2) );
 427    }
 428    else if (lua_isfaction(L,2)) {
 429       lf = lua_tofaction(L,2);
 430       fct = lf->f;
 431    }
 432    else NLUA_INVALID_PARAMETER();
 433
 434    /* Try to find a fleet of the faction. */
 435    found = 0;
 436    for (i=0; i<sys->s->nfleets; i++) {
 437       if (sys->s->fleets[i].fleet->faction == fct) {
 438          found = 1;
 439          break;
 440       }
 441    }
 442
 443    lua_pushboolean(L, found);
 444    return 1;
 445 }
 446
 447
 448 /**
 449  * @brief Gets the planets in a system.
 450  *
 451  * @usage for k,v in pairs( sys:planets() ) do -- Iterate over planets in system
 452  * @usage if #sys:planets() > 0then -- System has planets
 453  *
 454  *    @luaparam s System to get planets of
 455  *    @luareturn A table with all the planets
 456  * @luafunc planets( s )
 457  */
 458 static int systemL_planets( lua_State *L )
 459 {
 460    int i;
 461    LuaSystem *sys;
 462    LuaPlanet p;
 463
 464    sys = luaL_checksystem(L,1);
 465
 466    /* Push all planets. */
 467    lua_newtable(L);
 468    for (i=0; i<sys->s->nplanets; i++) {
 469       p.p = sys->s->planets[i];
 470       lua_pushnumber(L,i+1); /* key */
 471       lua_pushplanet(L,p); /* value */
 472       lua_rawset(L,-3);
 473    }
 474
 475    return 1;
 476 }
 477
 478
 479 /**
 480  * @brief Gets the security level in a system.
 481  *
 482  * @usage sec = sys:security()
 483  *
 484  *    @luaparam s System to get security level of.
 485  *    @luareturn The security level in sys (in % -> 25 = 25%).
 486  * @luafunc security( s )
 487  */
 488 static int systemL_security( lua_State *L )
 489 {
 490    LuaSystem *sys;
 491
 492    sys = luaL_checksystem(L,1);
 493
 494    lua_pushnumber(L, sys->s->security * 100. );
 495    return 1;
 496 }
 497