383 lines
8.7 KiB
C
383 lines
8.7 KiB
C
#include "lauxlib.h"
|
|
|
|
#include "log.h"
|
|
#include "lephisto.h"
|
|
#include "rng.h"
|
|
#include "land.h"
|
|
#include "lluadef.h"
|
|
#include "map.h"
|
|
#include "llua_space.h"
|
|
|
|
static int planetL_createmetatable(lua_State* L);
|
|
static int systemL_createmetatable(lua_State* L);
|
|
|
|
/* Space. */
|
|
static int planetL_get(lua_State* L);
|
|
static int systemL_get(lua_State* L);
|
|
static const luaL_reg space_methods[] = {
|
|
{ "getPlanet", planetL_get },
|
|
{ "getSystem", systemL_get },
|
|
{ 0, 0 }
|
|
};
|
|
|
|
/* Planet metatable methods. */
|
|
static int planetL_eq(lua_State* L);
|
|
static int planetL_name(lua_State* L);
|
|
static int planetL_faction(lua_State* L);
|
|
static int planetL_class(lua_State* L);
|
|
static int planetL_services(lua_State* L);
|
|
static const luaL_reg planet_methods[] = {
|
|
{ "__eq", planetL_eq },
|
|
{ "name", planetL_name },
|
|
{ "faction", planetL_faction },
|
|
{ "class", planetL_class },
|
|
{ "services", planetL_services },
|
|
{ 0, 0 }
|
|
};
|
|
|
|
/* System metatable methods. */
|
|
static int systemL_eq(lua_State* L);
|
|
static int systemL_name(lua_State* L);
|
|
static int systemL_faction(lua_State* L);
|
|
static int systemL_jumpdistance(lua_State* L);
|
|
static const luaL_reg system_methods[] = {
|
|
{ "__eq", systemL_eq },
|
|
{ "name", systemL_name },
|
|
{ "faction", systemL_faction },
|
|
{ "jumpDist", systemL_jumpdistance },
|
|
{ 0, 0 }
|
|
};
|
|
|
|
/* Load the space library. */
|
|
int lua_loadSpace(lua_State* L, int readonly) {
|
|
(void)readonly;
|
|
|
|
/* Register the functions. */
|
|
luaL_register(L, "space", space_methods);
|
|
|
|
/* Register the metatables. */
|
|
planetL_createmetatable(L);
|
|
systemL_createmetatable(L);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* -- SPACE -- */
|
|
|
|
/* Create a planet metatable from a planet and put it on top of the stack. */
|
|
static int planetL_createmetatable(lua_State* L) {
|
|
/* Create the metatable. */
|
|
luaL_newmetatable(L, PLANET_METATABLE);
|
|
|
|
/* Create the access table. */
|
|
lua_pushvalue(L, -1);
|
|
lua_setfield(L, -2,"__index");
|
|
|
|
/* Register the values. */
|
|
luaL_register(L, NULL, planet_methods);
|
|
|
|
return 0; /* No error. */
|
|
}
|
|
|
|
/* Register the system metatable. */
|
|
static int systemL_createmetatable(lua_State* L) {
|
|
/* Create the metatable. */
|
|
luaL_newmetatable(L, SYSTEM_METATABLE);
|
|
|
|
/* Create the access table. */
|
|
lua_pushvalue(L, -1);
|
|
lua_setfield(L, -2, "__index");
|
|
|
|
/* Register the values. */
|
|
luaL_register(L, NULL, system_methods);
|
|
|
|
return 0; /* No error. */
|
|
}
|
|
|
|
/* -- PLANET -- */
|
|
|
|
/* Get planet at index. */
|
|
LuaPlanet* lua_toplanet(lua_State* L, int ind) {
|
|
if(lua_isuserdata(L, ind)) {
|
|
return (LuaPlanet*) lua_touserdata(L, ind);
|
|
}
|
|
|
|
luaL_typerror(L, ind, PLANET_METATABLE);
|
|
return NULL;
|
|
}
|
|
|
|
/* Push a planet on the stack. */
|
|
LuaPlanet* lua_pushplanet(lua_State* L, LuaPlanet planet) {
|
|
LuaPlanet* p;
|
|
p = (LuaPlanet*) lua_newuserdata(L, sizeof(LuaPlanet));
|
|
*p = planet;
|
|
luaL_getmetatable(L, PLANET_METATABLE);
|
|
lua_setmetatable(L, -2);
|
|
return p;
|
|
}
|
|
|
|
/* Check see if ind is a planet. */
|
|
int lua_isplanet(lua_State* L, int ind) {
|
|
int ret;
|
|
|
|
if(lua_getmetatable(L, ind)==0)
|
|
return 0;
|
|
lua_getfield(L, LUA_REGISTRYINDEX, PLANET_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;
|
|
}
|
|
|
|
/* get a planet. */
|
|
static int planetL_get(lua_State* L) {
|
|
int i;
|
|
int* factions;
|
|
int nfactions;
|
|
char** planets;
|
|
int nplanets;
|
|
char* rndplanet;
|
|
LuaPlanet planet;
|
|
LuaSystem sys;
|
|
|
|
rndplanet = NULL;
|
|
nplanets = 0;
|
|
|
|
/* Get the landed planet. */
|
|
if(lua_gettop(L) == 0) {
|
|
if(land_planet != NULL) {
|
|
planet.p = land_planet;
|
|
lua_pushplanet(L, planet);
|
|
sys.s = system_get(planet_getSystem(land_planet->name));
|
|
lua_pushsystem(L, sys);
|
|
return 2;
|
|
}
|
|
return 0; /* Not landed. */
|
|
}
|
|
|
|
/* Get a planet by faction */
|
|
else if(lua_isnumber(L, 1)) {
|
|
i = lua_tonumber(L, 1);
|
|
planets = space_getFactionPlanet(&nplanets, &i, 1);
|
|
}
|
|
|
|
/* Get a planet by name. */
|
|
else if(lua_isstring(L, 1)) {
|
|
rndplanet = (char*) lua_tostring(L, 1);
|
|
}
|
|
|
|
/* Get a planet from faction list. */
|
|
else if(lua_istable(L, 1)) {
|
|
/* Load up the table. */
|
|
lua_pushnil(L);
|
|
nfactions = (int)lua_gettop(L);
|
|
factions = malloc(sizeof(int) * nfactions);
|
|
i = 0;
|
|
|
|
while(lua_next(L, -2) != 0) {
|
|
factions[i++] = (int)lua_tonumber(L, -1);
|
|
lua_pop(L,1);
|
|
}
|
|
|
|
/* Get the planets. */
|
|
planets = space_getFactionPlanet(&nplanets, factions, nfactions);
|
|
free(factions);
|
|
}
|
|
else LLUA_INVALID_PARAMETER(); /* Bad parameter. */
|
|
|
|
/* No suitable planet found. */
|
|
if((rndplanet == NULL) && (nplanets == 0)) {
|
|
free(planets);
|
|
return 0;
|
|
}
|
|
|
|
/* Pick random planet. */
|
|
else if(rndplanet == NULL) {
|
|
rndplanet = planets[RNG(0, nplanets-1)];
|
|
free(planets);
|
|
}
|
|
|
|
/* Push the planet. */
|
|
planet.p = planet_get(rndplanet); /* The real planet. */
|
|
lua_pushplanet(L, planet);
|
|
sys.s = system_get(planet_getSystem(rndplanet));
|
|
lua_pushsystem(L, sys);
|
|
return 2;
|
|
}
|
|
|
|
/* __eq (equality) metamethod for planets. */
|
|
static int planetL_eq(lua_State* L) {
|
|
LuaPlanet* a, *b;
|
|
a = lua_toplanet(L, 1);
|
|
b = lua_toplanet(L, 2);
|
|
if(a->p == b->p)
|
|
lua_pushboolean(L, 1);
|
|
else
|
|
lua_pushboolean(L, 0);
|
|
return 1;
|
|
}
|
|
|
|
/* Get the planets name. */
|
|
static int planetL_name(lua_State* L) {
|
|
LuaPlanet* p;
|
|
p = lua_toplanet(L, 1);
|
|
lua_pushstring(L, p->p->name);
|
|
return 1;
|
|
}
|
|
|
|
/* Get the planets faction. */
|
|
static int planetL_faction(lua_State* L) {
|
|
LuaPlanet* p;
|
|
p = lua_toplanet(L, 1);
|
|
lua_pushstring(L, faction_name(p->p->faction));
|
|
return 1;
|
|
}
|
|
|
|
/* Get the planets class. */
|
|
static int planetL_class(lua_State* L) {
|
|
char buf[2];
|
|
LuaPlanet* p;
|
|
p = lua_toplanet(L, 1);
|
|
buf[0] = planet_getClass(p->p);
|
|
buf[1] = '\0';
|
|
lua_pushstring(L, buf);
|
|
return 1;
|
|
}
|
|
|
|
/* Get planet services. */
|
|
static int planetL_services(lua_State* L) {
|
|
LuaPlanet* p;
|
|
p = lua_toplanet(L, 1);
|
|
lua_pushnumber(L, p->p->services);
|
|
return 1;
|
|
}
|
|
|
|
/* -- SYSTEM -- */
|
|
|
|
/* Get system at index. */
|
|
LuaSystem* lua_tosystem(lua_State* L, int ind) {
|
|
if(lua_isuserdata(L, ind)) {
|
|
return (LuaSystem*) lua_touserdata(L,ind);
|
|
}
|
|
luaL_typerror(L, ind, SYSTEM_METATABLE);
|
|
return NULL;
|
|
}
|
|
|
|
/* Pushes a system on the stack. */
|
|
LuaSystem* lua_pushsystem(lua_State* L, LuaSystem sys) {
|
|
LuaSystem* s;
|
|
s = (LuaSystem*) lua_newuserdata(L, sizeof(LuaSystem));
|
|
*s = sys;
|
|
luaL_getmetatable(L, SYSTEM_METATABLE);
|
|
lua_setmetatable(L, -2);
|
|
return s;
|
|
}
|
|
|
|
/* Check to see if ind is a planet. */
|
|
int lua_issystem(lua_State* L, int ind) {
|
|
int ret;
|
|
|
|
if(lua_getmetatable(L, ind)==0)
|
|
return 0;
|
|
lua_getfield(L, LUA_REGISTRYINDEX, SYSTEM_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;
|
|
}
|
|
|
|
/* Get a system. */
|
|
static int systemL_get(lua_State* L) {
|
|
LuaSystem sys;
|
|
LuaPlanet* p;
|
|
|
|
/* Get the current system with no parameters. */
|
|
if(lua_gettop(L) == 0) {
|
|
sys.s = cur_system;
|
|
}
|
|
/* Passing a string (systemname) */
|
|
else if(lua_isstring(L, 1)) {
|
|
sys.s = system_get((char*)lua_tostring(L, 1));
|
|
}
|
|
/* Passing a planet */
|
|
else if(lua_isplanet(L, 1)) {
|
|
p = lua_toplanet(L, 1);
|
|
sys.s = system_get(planet_getSystem(p->p->name));
|
|
}
|
|
else LLUA_INVALID_PARAMETER();
|
|
|
|
/* Return the system. */
|
|
lua_pushsystem(L, sys);
|
|
return 1;
|
|
}
|
|
|
|
/* Check system for equality. */
|
|
static int systemL_eq(lua_State* L) {
|
|
LuaSystem* a, *b;
|
|
a = lua_tosystem(L, 1);
|
|
b = lua_tosystem(L, 2);
|
|
if(a->s == b->s)
|
|
lua_pushboolean(L, 1);
|
|
else
|
|
lua_pushboolean(L, 0);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* Return the systems name. */
|
|
static int systemL_name(lua_State* L) {
|
|
LuaSystem* sys;
|
|
sys = lua_tosystem(L, 1);
|
|
lua_pushstring(L, sys->s->name);
|
|
return 1;
|
|
}
|
|
|
|
/* Get system factions. */
|
|
static int systemL_faction(lua_State* L) {
|
|
int i;
|
|
LuaSystem* sys;
|
|
sys = lua_tosystem(L, 1);
|
|
|
|
/* Return result in table. */
|
|
lua_newtable(L);
|
|
for(i = 0; i < sys->s->nplanets; i++) {
|
|
if(sys->s->planets[i].faction > 0) { /* Faction must be valid. */
|
|
lua_pushboolean(L, 1); /* Value. */
|
|
lua_setfield(L, -2, faction_name(sys->s->planets[i].faction)); /* Key. */
|
|
/* Allows syntax foo = space.faction("foo"); if foo["bar"] then ... end */
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* Get jump distance for current system, or to another. */
|
|
static int systemL_jumpdistance(lua_State* L) {
|
|
LLUA_MIN_ARGS(1);
|
|
LuaSystem* sys;
|
|
StarSystem** s;
|
|
int jumps;
|
|
char* start, *goal;
|
|
|
|
sys = lua_tosystem(L, 1);
|
|
start = sys->s->name;
|
|
|
|
if((lua_gettop(L) > 1) && lua_isstring(L, 2))
|
|
goal = (char*)lua_tostring(L, 2);
|
|
else
|
|
goal = cur_system->name;
|
|
|
|
s = map_getJumpPath(&jumps, start, goal, 1);
|
|
free(s);
|
|
|
|
lua_pushnumber(L, jumps);
|
|
return 1;
|
|
}
|
|
|