Marc/server
1
0
Fork 0
forked from github/server
Code Issues Pull requests Projects Releases Wiki Activity

stupidly named tolua_S renamed to just L, as is standard.

Browse source
This commit is contained in:
Enno Rehling 2009-06-21 19:54:14 +00:00
parent 18e7e14fc9
commit 27d8628084
22 changed files with 1171 additions and 1170 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

124
src/eressea/tolua/bind_building.c
View file

@ -21,12 +21,12 @@ without prior permission by the authors of Eressea.
#include <lua.h> #include <lua.h>
#include <tolua.h> #include <tolua.h>
int tolua_buildinglist_next(lua_State *tolua_S) int tolua_buildinglist_next(lua_State *L)
{ {
building** building_ptr = (building **)lua_touserdata(tolua_S, lua_upvalueindex(1)); building** building_ptr = (building **)lua_touserdata(L, lua_upvalueindex(1));
building * u = *building_ptr; building * u = *building_ptr;
if (u != NULL) { if (u != NULL) {
tolua_pushusertype(tolua_S, (void*)u, "building"); tolua_pushusertype(L, (void*)u, "building");
*building_ptr = u->next; *building_ptr = u->next;
return 1; return 1;
} }
@ -35,11 +35,11 @@ int tolua_buildinglist_next(lua_State *tolua_S)
static int static int
tolua_building_addaction(lua_State* tolua_S) tolua_building_addaction(lua_State* L)
{ {
building* self = (building*)tolua_tousertype(tolua_S, 1, 0); building* self = (building*)tolua_tousertype(L, 1, 0);
const char * fname = tolua_tostring(tolua_S, 2, 0); const char * fname = tolua_tostring(L, 2, 0);
const char * param = tolua_tostring(tolua_S, 3, 0); const char * param = tolua_tostring(L, 3, 0);
building_addaction(self, fname, param); building_addaction(self, fname, param);
@ -47,133 +47,133 @@ tolua_building_addaction(lua_State* tolua_S)
} }
static int static int
tolua_building_get_objects(lua_State* tolua_S) tolua_building_get_objects(lua_State* L)
{ {
building * self = (building *)tolua_tousertype(tolua_S, 1, 0); building * self = (building *)tolua_tousertype(L, 1, 0);
tolua_pushusertype(tolua_S, (void*)&self->attribs, "hashtable"); tolua_pushusertype(L, (void*)&self->attribs, "hashtable");
return 1; return 1;
} }
static int tolua_building_get_region(lua_State* tolua_S) static int tolua_building_get_region(lua_State* L)
{ {
building* self = (building*) tolua_tousertype(tolua_S, 1, 0); building* self = (building*) tolua_tousertype(L, 1, 0);
tolua_pushusertype(tolua_S, building_getregion(self), "region"); tolua_pushusertype(L, building_getregion(self), "region");
return 1; return 1;
} }
static int tolua_building_set_region(lua_State* tolua_S) static int tolua_building_set_region(lua_State* L)
{ {
building* self = (building*)tolua_tousertype(tolua_S, 1, 0); building* self = (building*)tolua_tousertype(L, 1, 0);
building_setregion(self, (region*)tolua_tousertype(tolua_S, 2, 0)); building_setregion(self, (region*)tolua_tousertype(L, 2, 0));
return 0; return 0;
} }
static int tolua_building_get_name(lua_State* tolua_S) static int tolua_building_get_name(lua_State* L)
{ {
building* self = (building*) tolua_tousertype(tolua_S, 1, 0); building* self = (building*) tolua_tousertype(L, 1, 0);
tolua_pushstring(tolua_S, building_getname(self)); tolua_pushstring(L, building_getname(self));
return 1; return 1;
} }
static int tolua_building_set_name(lua_State* tolua_S) static int tolua_building_set_name(lua_State* L)
{ {
building* self = (building*)tolua_tousertype(tolua_S, 1, 0); building* self = (building*)tolua_tousertype(L, 1, 0);
building_setname(self, tolua_tostring(tolua_S, 2, 0)); building_setname(self, tolua_tostring(L, 2, 0));
return 0; return 0;
} }
static int tolua_building_get_size(lua_State* tolua_S) static int tolua_building_get_size(lua_State* L)
{ {
building* self = (building*) tolua_tousertype(tolua_S, 1, 0); building* self = (building*) tolua_tousertype(L, 1, 0);
tolua_pushnumber(tolua_S, self->size); tolua_pushnumber(L, self->size);
return 1; return 1;
} }
static int tolua_building_set_size(lua_State* tolua_S) static int tolua_building_set_size(lua_State* L)
{ {
building* self = (building*)tolua_tousertype(tolua_S, 1, 0); building* self = (building*)tolua_tousertype(L, 1, 0);
self->size = (int)tolua_tonumber(tolua_S, 2, 0); self->size = (int)tolua_tonumber(L, 2, 0);
return 0; return 0;
} }
static int static int
tolua_building_get_units(lua_State* tolua_S) tolua_building_get_units(lua_State* L)
{ {
building * self = (building *)tolua_tousertype(tolua_S, 1, 0); building * self = (building *)tolua_tousertype(L, 1, 0);
unit ** unit_ptr = (unit**)lua_newuserdata(tolua_S, sizeof(unit *)); unit ** unit_ptr = (unit**)lua_newuserdata(L, sizeof(unit *));
unit * u = self->region->units; unit * u = self->region->units;
while (u && u->building!=self) u = u->next; while (u && u->building!=self) u = u->next;
luaL_getmetatable(tolua_S, "unit"); luaL_getmetatable(L, "unit");
lua_setmetatable(tolua_S, -2); lua_setmetatable(L, -2);
*unit_ptr = u; *unit_ptr = u;
lua_pushcclosure(tolua_S, tolua_unitlist_nextb, 1); lua_pushcclosure(L, tolua_unitlist_nextb, 1);
return 1; return 1;
} }
static int static int
tolua_building_get_id(lua_State* tolua_S) tolua_building_get_id(lua_State* L)
{ {
building * self = (building *)tolua_tousertype(tolua_S, 1, 0); building * self = (building *)tolua_tousertype(L, 1, 0);
tolua_pushnumber(tolua_S, (lua_Number)self->no); tolua_pushnumber(L, (lua_Number)self->no);
return 1; return 1;
} }
static int static int
tolua_building_create(lua_State* tolua_S) tolua_building_create(lua_State* L)
{ {
region * r = (region *)tolua_tousertype(tolua_S, 1, 0); region * r = (region *)tolua_tousertype(L, 1, 0);
const char * bname = tolua_tostring(tolua_S, 2, 0); const char * bname = tolua_tostring(L, 2, 0);
if (bname) { if (bname) {
const building_type * btype = bt_find(bname); const building_type * btype = bt_find(bname);
building * b = new_building(btype, r, NULL); building * b = new_building(btype, r, NULL);
tolua_pushusertype(tolua_S, (void*)b, "building"); tolua_pushusertype(L, (void*)b, "building");
return 1; return 1;
} }
return 0; return 0;
} }
static int static int
tolua_building_tostring(lua_State *tolua_S) tolua_building_tostring(lua_State *L)
{ {
building * self = (building *)tolua_tousertype(tolua_S, 1, 0); building * self = (building *)tolua_tousertype(L, 1, 0);
lua_pushstring(tolua_S, buildingname(self)); lua_pushstring(L, buildingname(self));
return 1; return 1;
} }
void void
tolua_building_open(lua_State* tolua_S) tolua_building_open(lua_State* L)
{ {
/* register user types */ /* register user types */
tolua_usertype(tolua_S, "building"); tolua_usertype(L, "building");
tolua_usertype(tolua_S, "building_list"); tolua_usertype(L, "building_list");
tolua_module(tolua_S, NULL, 0); tolua_module(L, NULL, 0);
tolua_beginmodule(tolua_S, NULL); tolua_beginmodule(L, NULL);
{ {
tolua_cclass(tolua_S, "building", "building", "", NULL); tolua_cclass(L, "building", "building", "", NULL);
tolua_beginmodule(tolua_S, "building"); tolua_beginmodule(L, "building");
{ {
tolua_function(tolua_S, "__tostring", tolua_building_tostring); tolua_function(L, "__tostring", tolua_building_tostring);
tolua_variable(tolua_S, "id", tolua_building_get_id, NULL); tolua_variable(L, "id", tolua_building_get_id, NULL);
tolua_variable(tolua_S, "name", tolua_building_get_name, tolua_building_set_name); tolua_variable(L, "name", tolua_building_get_name, tolua_building_set_name);
tolua_variable(tolua_S, "units", tolua_building_get_units, NULL); tolua_variable(L, "units", tolua_building_get_units, NULL);
tolua_variable(tolua_S, "region", tolua_building_get_region, tolua_building_set_region); tolua_variable(L, "region", tolua_building_get_region, tolua_building_set_region);
tolua_variable(tolua_S, "size", tolua_building_get_size, tolua_building_set_size); tolua_variable(L, "size", tolua_building_get_size, tolua_building_set_size);
tolua_function(tolua_S, "add_action", tolua_building_addaction); tolua_function(L, "add_action", tolua_building_addaction);
#ifdef TODO #ifdef TODO
.property("type", &building_gettype) .property("type", &building_gettype)
.def_readwrite("size", &building::size) .def_readwrite("size", &building::size)
#endif #endif
tolua_variable(tolua_S, "objects", tolua_building_get_objects, 0); tolua_variable(L, "objects", tolua_building_get_objects, 0);
tolua_function(tolua_S, "create", tolua_building_create); tolua_function(L, "create", tolua_building_create);
} }
tolua_endmodule(tolua_S); tolua_endmodule(L);
} }
tolua_endmodule(tolua_S); tolua_endmodule(L);
} }

4
src/eressea/tolua/bind_building.h
View file

@ -15,8 +15,8 @@ extern "C" {
#endif #endif
struct lua_State; struct lua_State;
int tolua_buildinglist_next(struct lua_State *tolua_S); int tolua_buildinglist_next(struct lua_State *L);
void tolua_building_open(struct lua_State *tolua_S); void tolua_building_open(struct lua_State *L);
#ifdef __cplusplus #ifdef __cplusplus
} }

334
src/eressea/tolua/bind_faction.c
View file

@ -28,49 +28,49 @@ without prior permission by the authors of Eressea.
#include <tolua.h> #include <tolua.h>
int tolua_factionlist_next(lua_State *tolua_S) int tolua_factionlist_next(lua_State *L)
{ {
faction** faction_ptr = (faction **)lua_touserdata(tolua_S, lua_upvalueindex(1)); faction** faction_ptr = (faction **)lua_touserdata(L, lua_upvalueindex(1));
faction * f = *faction_ptr; faction * f = *faction_ptr;
if (f != NULL) { if (f != NULL) {
tolua_pushusertype(tolua_S, (void*)f, "faction"); tolua_pushusertype(L, (void*)f, "faction");
*faction_ptr = f->next; *faction_ptr = f->next;
return 1; return 1;
} }
else return 0; /* no more values to return */ else return 0; /* no more values to return */
} }
int tolua_factionlist_iter(lua_State *tolua_S) int tolua_factionlist_iter(lua_State *L)
{ {
faction_list** faction_ptr = (faction_list **)lua_touserdata(tolua_S, lua_upvalueindex(1)); faction_list** faction_ptr = (faction_list **)lua_touserdata(L, lua_upvalueindex(1));
faction_list* flist = *faction_ptr; faction_list* flist = *faction_ptr;
if (flist != NULL) { if (flist != NULL) {
tolua_pushusertype(tolua_S, (void*)flist->data, "faction"); tolua_pushusertype(L, (void*)flist->data, "faction");
*faction_ptr = flist->next; *faction_ptr = flist->next;
return 1; return 1;
} }
else return 0; /* no more values to return */ else return 0; /* no more values to return */
} }
static int tolua_faction_get_units(lua_State* tolua_S) static int tolua_faction_get_units(lua_State* L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
unit ** unit_ptr = (unit**)lua_newuserdata(tolua_S, sizeof(unit *)); unit ** unit_ptr = (unit**)lua_newuserdata(L, sizeof(unit *));
luaL_getmetatable(tolua_S, "unit"); luaL_getmetatable(L, "unit");
lua_setmetatable(tolua_S, -2); lua_setmetatable(L, -2);
*unit_ptr = self->units; *unit_ptr = self->units;
lua_pushcclosure(tolua_S, tolua_unitlist_nextf, 1); lua_pushcclosure(L, tolua_unitlist_nextf, 1);
return 1; return 1;
} }
int tolua_faction_add_item(lua_State *tolua_S) int tolua_faction_add_item(lua_State *L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
const char * iname = tolua_tostring(tolua_S, 2, 0); const char * iname = tolua_tostring(L, 2, 0);
int number = (int)tolua_tonumber(tolua_S, 3, 0); int number = (int)tolua_tonumber(L, 3, 0);
int result = -1; int result = -1;
if (iname!=NULL) { if (iname!=NULL) {
@ -80,121 +80,121 @@ int tolua_faction_add_item(lua_State *tolua_S)
result = i?i->number:0; result = i?i->number:0;
} // if (itype!=NULL) } // if (itype!=NULL)
} }
lua_pushnumber(tolua_S, result); lua_pushnumber(L, result);
return 1; return 1;
} }
static int static int
tolua_faction_get_maxheroes(lua_State* tolua_S) tolua_faction_get_maxheroes(lua_State* L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
tolua_pushnumber(tolua_S, (lua_Number)maxheroes(self)); tolua_pushnumber(L, (lua_Number)maxheroes(self));
return 1; return 1;
} }
static int static int
tolua_faction_get_heroes(lua_State* tolua_S) tolua_faction_get_heroes(lua_State* L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
tolua_pushnumber(tolua_S, (lua_Number)countheroes(self)); tolua_pushnumber(L, (lua_Number)countheroes(self));
return 1; return 1;
} }
static int static int
tolua_faction_get_score(lua_State* tolua_S) tolua_faction_get_score(lua_State* L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
tolua_pushnumber(tolua_S, (lua_Number)self->score); tolua_pushnumber(L, (lua_Number)self->score);
return 1; return 1;
} }
static int static int
tolua_faction_get_id(lua_State* tolua_S) tolua_faction_get_id(lua_State* L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
tolua_pushnumber(tolua_S, (lua_Number)self->no); tolua_pushnumber(L, (lua_Number)self->no);
return 1; return 1;
} }
static int static int
tolua_faction_set_id(lua_State* tolua_S) tolua_faction_set_id(lua_State* L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
int id = (int)tolua_tonumber(tolua_S, 2, 0); int id = (int)tolua_tonumber(L, 2, 0);
if (findfaction(id)==NULL) { if (findfaction(id)==NULL) {
renumber_faction(self, id); renumber_faction(self, id);
lua_pushboolean(tolua_S, 1); lua_pushboolean(L, 1);
} else { } else {
lua_pushboolean(tolua_S, 0); lua_pushboolean(L, 0);
} }
return 1; return 1;
} }
static int static int
tolua_faction_get_age(lua_State* tolua_S) tolua_faction_get_age(lua_State* L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
tolua_pushnumber(tolua_S, (lua_Number)self->age); tolua_pushnumber(L, (lua_Number)self->age);
return 1; return 1;
} }
static int static int
tolua_faction_set_age(lua_State* tolua_S) tolua_faction_set_age(lua_State* L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
int age = (int)tolua_tonumber(tolua_S, 2, 0); int age = (int)tolua_tonumber(L, 2, 0);
self->age = age; self->age = age;
return 0; return 0;
} }
static int static int
tolua_faction_get_flags(lua_State* tolua_S) tolua_faction_get_flags(lua_State* L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
tolua_pushnumber(tolua_S, (lua_Number)self->flags); tolua_pushnumber(L, (lua_Number)self->flags);
return 1; return 1;
} }
static int static int
tolua_faction_get_options(lua_State* tolua_S) tolua_faction_get_options(lua_State* L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
tolua_pushnumber(tolua_S, (lua_Number)self->options); tolua_pushnumber(L, (lua_Number)self->options);
return 1; return 1;
} }
static int static int
tolua_faction_get_lastturn(lua_State* tolua_S) tolua_faction_get_lastturn(lua_State* L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
tolua_pushnumber(tolua_S, (lua_Number)self->lastorders); tolua_pushnumber(L, (lua_Number)self->lastorders);
return 1; return 1;
} }
static int static int
tolua_faction_renumber(lua_State* tolua_S) tolua_faction_renumber(lua_State* L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
int no = (int)tolua_tonumber(tolua_S, 2, 0); int no = (int)tolua_tonumber(L, 2, 0);
renumber_faction(self, no); renumber_faction(self, no);
return 0; return 0;
} }
static int static int
tolua_faction_get_objects(lua_State* tolua_S) tolua_faction_get_objects(lua_State* L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
tolua_pushusertype(tolua_S, (void*)&self->attribs, "hashtable"); tolua_pushusertype(L, (void*)&self->attribs, "hashtable");
return 1; return 1;
} }
static int static int
tolua_faction_get_policy(lua_State* tolua_S) tolua_faction_get_policy(lua_State* L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
faction * other = (faction *)tolua_tousertype(tolua_S, 2, 0); faction * other = (faction *)tolua_tousertype(L, 2, 0);
const char * policy = tolua_tostring(tolua_S, 3, 0); const char * policy = tolua_tostring(L, 3, 0);
int result = 0, mode; int result = 0, mode;
for (mode=0;helpmodes[mode].name!=NULL;++mode) { for (mode=0;helpmodes[mode].name!=NULL;++mode) {
@ -204,18 +204,18 @@ tolua_faction_get_policy(lua_State* tolua_S)
} }
} }
tolua_pushnumber(tolua_S, (lua_Number)result); tolua_pushnumber(L, (lua_Number)result);
return 1; return 1;
} }
static int static int
tolua_faction_set_policy(lua_State* tolua_S) tolua_faction_set_policy(lua_State* L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
faction * other = (faction *)tolua_tousertype(tolua_S, 2, 0); faction * other = (faction *)tolua_tousertype(L, 2, 0);
const char * policy = tolua_tostring(tolua_S, 3, 0); const char * policy = tolua_tostring(L, 3, 0);
int value = tolua_toboolean(tolua_S, 4, 0); int value = tolua_toboolean(L, 4, 0);
int mode; int mode;
for (mode=0;helpmodes[mode].name!=NULL;++mode) { for (mode=0;helpmodes[mode].name!=NULL;++mode) {
@ -233,9 +233,9 @@ tolua_faction_set_policy(lua_State* tolua_S)
} }
static int static int
tolua_faction_get_origin(lua_State* tolua_S) tolua_faction_get_origin(lua_State* L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
ursprung * origin = self->ursprung; ursprung * origin = self->ursprung;
int x, y; int x, y;
@ -250,17 +250,17 @@ tolua_faction_get_origin(lua_State* tolua_S)
y = 0; y = 0;
} }
tolua_pushnumber(tolua_S, (lua_Number)x); tolua_pushnumber(L, (lua_Number)x);
tolua_pushnumber(tolua_S, (lua_Number)y); tolua_pushnumber(L, (lua_Number)y);
return 2; return 2;
} }
static int static int
tolua_faction_create(lua_State* tolua_S) tolua_faction_create(lua_State* L)
{ {
const char * email = tolua_tostring(tolua_S, 1, 0); const char * email = tolua_tostring(L, 1, 0);
const char * racename = tolua_tostring(tolua_S, 2, 0); const char * racename = tolua_tostring(L, 2, 0);
const char * lang = tolua_tostring(tolua_S, 3, 0); const char * lang = tolua_tostring(L, 3, 0);
struct locale * loc = find_locale(lang); struct locale * loc = find_locale(lang);
faction * f = NULL; faction * f = NULL;
const struct race * frace = findrace(racename, default_locale); const struct race * frace = findrace(racename, default_locale);
@ -269,64 +269,64 @@ tolua_faction_create(lua_State* tolua_S)
if (frace!=NULL) { if (frace!=NULL) {
f = addfaction(email, NULL, frace, loc, 0); f = addfaction(email, NULL, frace, loc, 0);
} }
tolua_pushusertype(tolua_S, f, "faction"); tolua_pushusertype(L, f, "faction");
return 1; return 1;
} }
static int tolua_faction_get_password(lua_State* tolua_S) static int tolua_faction_get_password(lua_State* L)
{ {
faction* self = (faction*) tolua_tousertype(tolua_S, 1, 0); faction* self = (faction*) tolua_tousertype(L, 1, 0);
tolua_pushstring(tolua_S, faction_getpassword(self)); tolua_pushstring(L, faction_getpassword(self));
return 1; return 1;
} }
static int tolua_faction_set_password(lua_State* tolua_S) static int tolua_faction_set_password(lua_State* L)
{ {
faction* self = (faction*)tolua_tousertype(tolua_S, 1, 0); faction* self = (faction*)tolua_tousertype(L, 1, 0);
faction_setpassword(self, tolua_tostring(tolua_S, 2, 0)); faction_setpassword(self, tolua_tostring(L, 2, 0));
return 0; return 0;
} }
static int tolua_faction_get_email(lua_State* tolua_S) static int tolua_faction_get_email(lua_State* L)
{ {
faction* self = (faction*) tolua_tousertype(tolua_S, 1, 0); faction* self = (faction*) tolua_tousertype(L, 1, 0);
tolua_pushstring(tolua_S, faction_getemail(self)); tolua_pushstring(L, faction_getemail(self));
return 1; return 1;
} }
static int tolua_faction_set_email(lua_State* tolua_S) static int tolua_faction_set_email(lua_State* L)
{ {
faction* self = (faction*)tolua_tousertype(tolua_S, 1, 0); faction* self = (faction*)tolua_tousertype(L, 1, 0);
faction_setemail(self, tolua_tostring(tolua_S, 2, 0)); faction_setemail(self, tolua_tostring(L, 2, 0));
return 0; return 0;
} }
static int tolua_faction_get_locale(lua_State* tolua_S) static int tolua_faction_get_locale(lua_State* L)
{ {
faction* self = (faction*) tolua_tousertype(tolua_S, 1, 0); faction* self = (faction*) tolua_tousertype(L, 1, 0);
tolua_pushstring(tolua_S, locale_name(self->locale)); tolua_pushstring(L, locale_name(self->locale));
return 1; return 1;
} }
static int tolua_faction_set_locale(lua_State* tolua_S) static int tolua_faction_set_locale(lua_State* L)
{ {
faction* self = (faction*)tolua_tousertype(tolua_S, 1, 0); faction* self = (faction*)tolua_tousertype(L, 1, 0);
const char * name = tolua_tostring(tolua_S, 2, 0); const char * name = tolua_tostring(L, 2, 0);
self->locale = find_locale(name); self->locale = find_locale(name);
return 0; return 0;
} }
static int tolua_faction_get_race(lua_State* tolua_S) static int tolua_faction_get_race(lua_State* L)
{ {
faction* self = (faction*) tolua_tousertype(tolua_S, 1, 0); faction* self = (faction*) tolua_tousertype(L, 1, 0);
tolua_pushstring(tolua_S, self->race->_name[0]); tolua_pushstring(L, self->race->_name[0]);
return 1; return 1;
} }
static int tolua_faction_set_race(lua_State* tolua_S) static int tolua_faction_set_race(lua_State* L)
{ {
faction* self = (faction*)tolua_tousertype(tolua_S, 1, 0); faction* self = (faction*)tolua_tousertype(L, 1, 0);
const char * name = tolua_tostring(tolua_S, 2, 0); const char * name = tolua_tostring(L, 2, 0);
race * rc = rc_find(name); race * rc = rc_find(name);
if (rc!=NULL) { if (rc!=NULL) {
self->race = rc; self->race = rc;
@ -335,45 +335,45 @@ static int tolua_faction_set_race(lua_State* tolua_S)
return 0; return 0;
} }
static int tolua_faction_get_name(lua_State* tolua_S) static int tolua_faction_get_name(lua_State* L)
{ {
faction* self = (faction*) tolua_tousertype(tolua_S, 1, 0); faction* self = (faction*) tolua_tousertype(L, 1, 0);
tolua_pushstring(tolua_S, faction_getname(self)); tolua_pushstring(L, faction_getname(self));
return 1; return 1;
} }
static int tolua_faction_set_name(lua_State* tolua_S) static int tolua_faction_set_name(lua_State* L)
{ {
faction* self = (faction*)tolua_tousertype(tolua_S, 1, 0); faction* self = (faction*)tolua_tousertype(L, 1, 0);
faction_setname(self, tolua_tostring(tolua_S, 2, 0)); faction_setname(self, tolua_tostring(L, 2, 0));
return 0; return 0;
} }
static int tolua_faction_get_info(lua_State* tolua_S) static int tolua_faction_get_info(lua_State* L)
{ {
faction* self = (faction*) tolua_tousertype(tolua_S, 1, 0); faction* self = (faction*) tolua_tousertype(L, 1, 0);
tolua_pushstring(tolua_S, faction_getbanner(self)); tolua_pushstring(L, faction_getbanner(self));
return 1; return 1;
} }
static int tolua_faction_set_info(lua_State* tolua_S) static int tolua_faction_set_info(lua_State* L)
{ {
faction* self = (faction*)tolua_tousertype(tolua_S, 1, 0); faction* self = (faction*)tolua_tousertype(L, 1, 0);
faction_setbanner(self, tolua_tostring(tolua_S, 2, 0)); faction_setbanner(self, tolua_tostring(L, 2, 0));
return 0; return 0;
} }
static int tolua_faction_get_alliance(lua_State* tolua_S) static int tolua_faction_get_alliance(lua_State* L)
{ {
faction* self = (faction*) tolua_tousertype(tolua_S, 1, 0); faction* self = (faction*) tolua_tousertype(L, 1, 0);
tolua_pushusertype(tolua_S, self->alliance, "alliance"); tolua_pushusertype(L, self->alliance, "alliance");
return 1; return 1;
} }
static int tolua_faction_set_alliance(lua_State* tolua_S) static int tolua_faction_set_alliance(lua_State* L)
{ {
faction* self = (faction*)tolua_tousertype(tolua_S, 1, 0); faction* self = (faction*)tolua_tousertype(L, 1, 0);
alliance* alli = (alliance*)tolua_tousertype(tolua_S, 2, 0); alliance* alli = (alliance*)tolua_tousertype(L, 2, 0);
if (!self->alliance) { if (!self->alliance) {
setalliance(self, alli); setalliance(self, alli);
@ -382,89 +382,89 @@ static int tolua_faction_set_alliance(lua_State* tolua_S)
return 0; return 0;
} }
static int tolua_faction_get_items(lua_State* tolua_S) static int tolua_faction_get_items(lua_State* L)
{ {
faction* self = (faction*)tolua_tousertype(tolua_S, 1, 0); faction* self = (faction*)tolua_tousertype(L, 1, 0);
item ** item_ptr = (item **)lua_newuserdata(tolua_S, sizeof(item *)); item ** item_ptr = (item **)lua_newuserdata(L, sizeof(item *));
luaL_getmetatable(tolua_S, "item"); luaL_getmetatable(L, "item");
lua_setmetatable(tolua_S, -2); lua_setmetatable(L, -2);
*item_ptr = self->items; *item_ptr = self->items;
lua_pushcclosure(tolua_S, tolua_itemlist_next, 1); lua_pushcclosure(L, tolua_itemlist_next, 1);
return 1; return 1;
} }
static int static int
tolua_faction_tostring(lua_State *tolua_S) tolua_faction_tostring(lua_State *L)
{ {
faction * self = (faction *)tolua_tousertype(tolua_S, 1, 0); faction * self = (faction *)tolua_tousertype(L, 1, 0);
lua_pushstring(tolua_S, factionname(self)); lua_pushstring(L, factionname(self));
return 1; return 1;
} }
static int tolua_faction_get_spells(lua_State* tolua_S) static int tolua_faction_get_spells(lua_State* L)
{ {
faction* self = (faction*)tolua_tousertype(tolua_S, 1, 0); faction* self = (faction*)tolua_tousertype(L, 1, 0);
spell_list * slist = self->spellbook; spell_list * slist = self->spellbook;
if (slist) { if (slist) {
spell_list ** spell_ptr = (spell_list **)lua_newuserdata(tolua_S, sizeof(spell_list *)); spell_list ** spell_ptr = (spell_list **)lua_newuserdata(L, sizeof(spell_list *));
luaL_getmetatable(tolua_S, "spell_list"); luaL_getmetatable(L, "spell_list");
lua_setmetatable(tolua_S, -2); lua_setmetatable(L, -2);
*spell_ptr = slist; *spell_ptr = slist;
lua_pushcclosure(tolua_S, tolua_spelllist_next, 1); lua_pushcclosure(L, tolua_spelllist_next, 1);
return 1; return 1;
} }
lua_pushnil(tolua_S); lua_pushnil(L);
return 1; return 1;
} }
void void
tolua_faction_open(lua_State* tolua_S) tolua_faction_open(lua_State* L)
{ {
/* register user types */ /* register user types */
tolua_usertype(tolua_S, "faction"); tolua_usertype(L, "faction");
tolua_usertype(tolua_S, "faction_list"); tolua_usertype(L, "faction_list");
tolua_module(tolua_S, NULL, 0); tolua_module(L, NULL, 0);
tolua_beginmodule(tolua_S, NULL); tolua_beginmodule(L, NULL);
{ {
tolua_cclass(tolua_S, "faction", "faction", "", NULL); tolua_cclass(L, "faction", "faction", "", NULL);
tolua_beginmodule(tolua_S, "faction"); tolua_beginmodule(L, "faction");
{ {
tolua_function(tolua_S, "__tostring", tolua_faction_tostring); tolua_function(L, "__tostring", tolua_faction_tostring);
tolua_variable(tolua_S, "name", tolua_faction_get_name, tolua_faction_set_name); tolua_variable(L, "name", tolua_faction_get_name, tolua_faction_set_name);
tolua_variable(tolua_S, "info", tolua_faction_get_info, tolua_faction_set_info); tolua_variable(L, "info", tolua_faction_get_info, tolua_faction_set_info);
tolua_variable(tolua_S, "units", tolua_faction_get_units, NULL); tolua_variable(L, "units", tolua_faction_get_units, NULL);
tolua_variable(tolua_S, "heroes", tolua_faction_get_heroes, NULL); tolua_variable(L, "heroes", tolua_faction_get_heroes, NULL);
tolua_variable(tolua_S, "spells", tolua_faction_get_spells, 0); tolua_variable(L, "spells", tolua_faction_get_spells, 0);
tolua_variable(tolua_S, "maxheroes", tolua_faction_get_maxheroes, NULL); tolua_variable(L, "maxheroes", tolua_faction_get_maxheroes, NULL);
tolua_variable(tolua_S, "password", tolua_faction_get_password, tolua_faction_set_password); tolua_variable(L, "password", tolua_faction_get_password, tolua_faction_set_password);
tolua_variable(tolua_S, "email", tolua_faction_get_email, tolua_faction_set_email); tolua_variable(L, "email", tolua_faction_get_email, tolua_faction_set_email);
tolua_variable(tolua_S, "locale", tolua_faction_get_locale, tolua_faction_set_locale); tolua_variable(L, "locale", tolua_faction_get_locale, tolua_faction_set_locale);
tolua_variable(tolua_S, "race", tolua_faction_get_race, tolua_faction_set_race); tolua_variable(L, "race", tolua_faction_get_race, tolua_faction_set_race);
tolua_variable(tolua_S, "alliance", tolua_faction_get_alliance, tolua_faction_set_alliance); tolua_variable(L, "alliance", tolua_faction_get_alliance, tolua_faction_set_alliance);
tolua_variable(tolua_S, "score", tolua_faction_get_score, NULL); tolua_variable(L, "score", tolua_faction_get_score, NULL);
tolua_variable(tolua_S, "id", tolua_faction_get_id, tolua_faction_set_id); tolua_variable(L, "id", tolua_faction_get_id, tolua_faction_set_id);
tolua_variable(tolua_S, "age", tolua_faction_get_age, tolua_faction_set_age); tolua_variable(L, "age", tolua_faction_get_age, tolua_faction_set_age);
tolua_variable(tolua_S, "options", tolua_faction_get_options, NULL); tolua_variable(L, "options", tolua_faction_get_options, NULL);
tolua_variable(tolua_S, "flags", tolua_faction_get_flags, NULL); tolua_variable(L, "flags", tolua_faction_get_flags, NULL);
tolua_variable(tolua_S, "lastturn", tolua_faction_get_lastturn, NULL); tolua_variable(L, "lastturn", tolua_faction_get_lastturn, NULL);
tolua_function(tolua_S, "set_policy", tolua_faction_set_policy); tolua_function(L, "set_policy", tolua_faction_set_policy);
tolua_function(tolua_S, "get_policy", tolua_faction_get_policy); tolua_function(L, "get_policy", tolua_faction_get_policy);
tolua_function(tolua_S, "get_origin", tolua_faction_get_origin); tolua_function(L, "get_origin", tolua_faction_get_origin);
tolua_function(tolua_S, "add_item", tolua_faction_add_item); tolua_function(L, "add_item", tolua_faction_add_item);
tolua_variable(tolua_S, "items", tolua_faction_get_items, NULL); tolua_variable(L, "items", tolua_faction_get_items, NULL);
tolua_function(tolua_S, "renumber", tolua_faction_renumber); tolua_function(L, "renumber", tolua_faction_renumber);
tolua_function(tolua_S, "create", tolua_faction_create); tolua_function(L, "create", tolua_faction_create);
#ifdef TODO #ifdef TODO
def("faction_origin", &faction_getorigin, pure_out_value(_2) + pure_out_value(_3)), def("faction_origin", &faction_getorigin, pure_out_value(_2) + pure_out_value(_3)),
@ -475,9 +475,9 @@ tolua_faction_open(lua_State* tolua_S)
.def("add_notice", &faction_addnotice) .def("add_notice", &faction_addnotice)
#endif #endif
tolua_variable(tolua_S, "objects", tolua_faction_get_objects, NULL); tolua_variable(L, "objects", tolua_faction_get_objects, NULL);
} }
tolua_endmodule(tolua_S); tolua_endmodule(L);
} }
tolua_endmodule(tolua_S); tolua_endmodule(L);
} }

6
src/eressea/tolua/bind_faction.h
View file

@ -15,9 +15,9 @@ extern "C" {
#endif #endif
struct lua_State; struct lua_State;
int tolua_factionlist_next(struct lua_State *tolua_S); int tolua_factionlist_next(struct lua_State *L);
int tolua_factionlist_iter(struct lua_State *tolua_S); int tolua_factionlist_iter(struct lua_State *L);
void tolua_faction_open(struct lua_State *tolua_S); void tolua_faction_open(struct lua_State *L);
#ifdef __cplusplus #ifdef __cplusplus
} }

82
src/eressea/tolua/bind_gmtool.c
View file

@ -10,36 +10,36 @@
#include <tolua.h> #include <tolua.h>
static int static int
tolua_run_mapper(lua_State* tolua_S) tolua_run_mapper(lua_State* L)
{ {
run_mapper(); run_mapper();
return 0; return 0;
} }
static int static int
tolua_highlight_region(lua_State* tolua_S) tolua_highlight_region(lua_State* L)
{ {
region * r = tolua_tousertype(tolua_S, 1, 0); region * r = tolua_tousertype(L, 1, 0);
int select = tolua_toboolean(tolua_S, 2, 0); int select = tolua_toboolean(L, 2, 0);
highlight_region(r, select); highlight_region(r, select);
return 0; return 0;
} }
static int static int
tolua_current_region(lua_State* tolua_S) tolua_current_region(lua_State* L)
{ {
map_region * mr = cursor_region(&current_state->display, &current_state->cursor); map_region * mr = cursor_region(&current_state->display, &current_state->cursor);
tolua_pushusertype(tolua_S, mr?mr->r:NULL, "region"); tolua_pushusertype(L, mr?mr->r:NULL, "region");
return 1; return 1;
} }
static int static int
tolua_select_coordinate(lua_State* tolua_S) tolua_select_coordinate(lua_State* L)
{ {
int x = (int)tolua_tonumber(tolua_S, 1, 0); int x = (int)tolua_tonumber(L, 1, 0);
int y = (int)tolua_tonumber(tolua_S, 2, 0); int y = (int)tolua_tonumber(L, 2, 0);
int select = tolua_toboolean(tolua_S, 3, 0); int select = tolua_toboolean(L, 3, 0);
if (current_state) { if (current_state) {
select_coordinate(current_state->selected, x, y, select); select_coordinate(current_state->selected, x, y, select);
} }
@ -47,10 +47,10 @@ tolua_select_coordinate(lua_State* tolua_S)
} }
static int static int
tolua_select_region(lua_State* tolua_S) tolua_select_region(lua_State* L)
{ {
region * r = tolua_tousertype(tolua_S, 1, 0); region * r = tolua_tousertype(L, 1, 0);
int select = tolua_toboolean(tolua_S, 2, 0); int select = tolua_toboolean(L, 2, 0);
if (current_state) { if (current_state) {
select_coordinate(current_state->selected, r->x, r->y, select); select_coordinate(current_state->selected, r->x, r->y, select);
} }
@ -105,11 +105,11 @@ tag_rewind(tag_iterator * iter)
} }
static int static int
tolua_tags_next(lua_State *tolua_S) tolua_tags_next(lua_State *L)
{ {
tag_iterator * iter = (tag_iterator *)lua_touserdata(tolua_S, lua_upvalueindex(1)); tag_iterator * iter = (tag_iterator *)lua_touserdata(L, lua_upvalueindex(1));
if (iter->node) { if (iter->node) {
tolua_pushusertype(tolua_S, (void*)iter->r, "region"); tolua_pushusertype(L, (void*)iter->r, "region");
tag_advance(iter); tag_advance(iter);
return 1; return 1;
} }
@ -119,59 +119,59 @@ tolua_tags_next(lua_State *tolua_S)
} }
static int static int
tolua_selected_regions(lua_State* tolua_S) tolua_selected_regions(lua_State* L)
{ {
tag_iterator * iter = (tag_iterator*)lua_newuserdata(tolua_S, sizeof(tag_iterator)); tag_iterator * iter = (tag_iterator*)lua_newuserdata(L, sizeof(tag_iterator));
luaL_getmetatable(tolua_S, "tag_iterator"); luaL_getmetatable(L, "tag_iterator");
lua_setmetatable(tolua_S, -2); lua_setmetatable(L, -2);
iter->list = current_state->selected; iter->list = current_state->selected;
tag_rewind(iter); tag_rewind(iter);
lua_pushcclosure(tolua_S, tolua_tags_next, 1); lua_pushcclosure(L, tolua_tags_next, 1);
return 1; return 1;
} }
static int static int
tolua_state_open(lua_State* tolua_S) tolua_state_open(lua_State* L)
{ {
unused(tolua_S); unused(L);
state_open(); state_open();
return 0; return 0;
} }
static int static int
tolua_state_close(lua_State* tolua_S) tolua_state_close(lua_State* L)
{ {
unused(tolua_S); unused(L);
state_close(current_state); state_close(current_state);
return 0; return 0;
} }
void void
tolua_gmtool_open(lua_State* tolua_S) tolua_gmtool_open(lua_State* L)
{ {
/* register user types */ /* register user types */
tolua_usertype(tolua_S, "tag_iterator"); tolua_usertype(L, "tag_iterator");
tolua_module(tolua_S, NULL, 0); tolua_module(L, NULL, 0);
tolua_beginmodule(tolua_S, NULL); tolua_beginmodule(L, NULL);
{ {
tolua_module(tolua_S, "gmtool", 0); tolua_module(L, "gmtool", 0);
tolua_beginmodule(tolua_S, "gmtool"); tolua_beginmodule(L, "gmtool");
{ {
tolua_function(tolua_S, "open", tolua_state_open); tolua_function(L, "open", tolua_state_open);
tolua_function(tolua_S, "close", tolua_state_close); tolua_function(L, "close", tolua_state_close);
tolua_function(tolua_S, "editor", tolua_run_mapper); tolua_function(L, "editor", tolua_run_mapper);
tolua_function(tolua_S, "get_selection", tolua_selected_regions); tolua_function(L, "get_selection", tolua_selected_regions);
tolua_function(tolua_S, "get_cursor", tolua_current_region); tolua_function(L, "get_cursor", tolua_current_region);
tolua_function(tolua_S, "highlight", tolua_highlight_region); tolua_function(L, "highlight", tolua_highlight_region);
tolua_function(tolua_S, "select", tolua_select_region); tolua_function(L, "select", tolua_select_region);
tolua_function(tolua_S, "select_at", tolua_select_coordinate); tolua_function(L, "select_at", tolua_select_coordinate);
} }
tolua_endmodule(tolua_S); tolua_endmodule(L);
} }
tolua_endmodule(tolua_S); tolua_endmodule(L);
} }

2
src/eressea/tolua/bind_gmtool.h
View file

@ -3,7 +3,7 @@ extern "C" {
#endif #endif
struct lua_State; struct lua_State;
void tolua_gmtool_open(struct lua_State *tolua_S); void tolua_gmtool_open(struct lua_State *L);
#ifdef __cplusplus #ifdef __cplusplus
} }

96
src/eressea/tolua/bind_hashtable.c
View file

@ -29,10 +29,10 @@ without prior permission by the authors of Eressea.
#include <assert.h> #include <assert.h>
static int static int
tolua_hashtable_get(lua_State* tolua_S) tolua_hashtable_get(lua_State* L)
{ {
hashtable self = (hashtable) tolua_tousertype(tolua_S, 1, 0); hashtable self = (hashtable) tolua_tousertype(L, 1, 0);
const char * name = tolua_tostring(tolua_S, 2, 0); const char * name = tolua_tostring(L, 2, 0);
attrib * a = a_find(*self, &at_object); attrib * a = a_find(*self, &at_object);
for (; a && a->type == &at_object; a = a->next) { for (; a && a->type == &at_object; a = a->next) {
@ -44,28 +44,28 @@ tolua_hashtable_get(lua_State* tolua_S)
object_get(a, &type, &val); object_get(a, &type, &val);
switch (type) { switch (type) {
case TNONE: case TNONE:
lua_pushnil(tolua_S); lua_pushnil(L);
break; break;
case TINTEGER: case TINTEGER:
lua_pushnumber(tolua_S, (lua_Number)val.i); lua_pushnumber(L, (lua_Number)val.i);
break; break;
case TREAL: case TREAL:
lua_pushnumber(tolua_S, (lua_Number)val.f); lua_pushnumber(L, (lua_Number)val.f);
break; break;
case TREGION: case TREGION:
tolua_pushusertype(tolua_S, val.v, "region"); tolua_pushusertype(L, val.v, "region");
break; break;
case TBUILDING: case TBUILDING:
tolua_pushusertype(tolua_S, val.v, "building"); tolua_pushusertype(L, val.v, "building");
break; break;
case TUNIT: case TUNIT:
tolua_pushusertype(tolua_S, val.v, "unit"); tolua_pushusertype(L, val.v, "unit");
break; break;
case TSHIP: case TSHIP:
tolua_pushusertype(tolua_S, val.v, "ship"); tolua_pushusertype(L, val.v, "ship");
break; break;
case TSTRING: case TSTRING:
tolua_pushstring(tolua_S, (const char*) val.v); tolua_pushstring(L, (const char*) val.v);
break; break;
default: default:
assert(!"not implemented"); assert(!"not implemented");
@ -73,16 +73,16 @@ tolua_hashtable_get(lua_State* tolua_S)
return 1; return 1;
} }
} }
lua_pushnil(tolua_S); lua_pushnil(L);
return 1; return 1;
} }
static int static int
tolua_hashtable_set_number(lua_State* tolua_S) tolua_hashtable_set_number(lua_State* L)
{ {
hashtable self = (hashtable) tolua_tousertype(tolua_S, 1, 0); hashtable self = (hashtable) tolua_tousertype(L, 1, 0);
const char * name = tolua_tostring(tolua_S, 2, 0); const char * name = tolua_tostring(L, 2, 0);
lua_Number value = tolua_tonumber(tolua_S, 3, 0); lua_Number value = tolua_tonumber(L, 3, 0);
attrib * a = a_find(*self, &at_object); attrib * a = a_find(*self, &at_object);
variant val; variant val;
@ -100,11 +100,11 @@ tolua_hashtable_set_number(lua_State* tolua_S)
} }
static int static int
tolua_hashtable_set_string(lua_State* tolua_S) tolua_hashtable_set_string(lua_State* L)
{ {
hashtable self = (hashtable) tolua_tousertype(tolua_S, 1, 0); hashtable self = (hashtable) tolua_tousertype(L, 1, 0);
const char * name = tolua_tostring(tolua_S, 2, 0); const char * name = tolua_tostring(L, 2, 0);
const char * value = tolua_tostring(tolua_S, 3, 0); const char * value = tolua_tostring(L, 3, 0);
attrib * a = a_find(*self, &at_object); attrib * a = a_find(*self, &at_object);
variant val; variant val;
@ -122,11 +122,11 @@ tolua_hashtable_set_string(lua_State* tolua_S)
} }
static int static int
tolua_hashtable_set_usertype(lua_State* tolua_S, int type) tolua_hashtable_set_usertype(lua_State* L, int type)
{ {
hashtable self = (hashtable) tolua_tousertype(tolua_S, 1, 0); hashtable self = (hashtable) tolua_tousertype(L, 1, 0);
const char * name = tolua_tostring(tolua_S, 2, 0); const char * name = tolua_tostring(L, 2, 0);
unit * value = tolua_tousertype(tolua_S, 3, 0); unit * value = tolua_tousertype(L, 3, 0);
attrib * a = a_find(*self, &at_object); attrib * a = a_find(*self, &at_object);
variant val; variant val;
@ -145,43 +145,43 @@ tolua_hashtable_set_usertype(lua_State* tolua_S, int type)
static int static int
tolua_hashtable_set(lua_State* tolua_S) tolua_hashtable_set(lua_State* L)
{ {
tolua_Error tolua_err; tolua_Error tolua_err;
if (tolua_isnumber(tolua_S, 3, 0, &tolua_err)) { if (tolua_isnumber(L, 3, 0, &tolua_err)) {
return tolua_hashtable_set_number(tolua_S); return tolua_hashtable_set_number(L);
} else if (tolua_isusertype(tolua_S, 3, "unit", 0, &tolua_err)) { } else if (tolua_isusertype(L, 3, "unit", 0, &tolua_err)) {
return tolua_hashtable_set_usertype(tolua_S, TUNIT); return tolua_hashtable_set_usertype(L, TUNIT);
} else if (tolua_isusertype(tolua_S, 3, "faction", 0, &tolua_err)) { } else if (tolua_isusertype(L, 3, "faction", 0, &tolua_err)) {
return tolua_hashtable_set_usertype(tolua_S, TFACTION); return tolua_hashtable_set_usertype(L, TFACTION);
} else if (tolua_isusertype(tolua_S, 3, "ship", 0, &tolua_err)) { } else if (tolua_isusertype(L, 3, "ship", 0, &tolua_err)) {
return tolua_hashtable_set_usertype(tolua_S, TSHIP); return tolua_hashtable_set_usertype(L, TSHIP);
} else if (tolua_isusertype(tolua_S, 3, "building", 0, &tolua_err)) { } else if (tolua_isusertype(L, 3, "building", 0, &tolua_err)) {
return tolua_hashtable_set_usertype(tolua_S, TBUILDING); return tolua_hashtable_set_usertype(L, TBUILDING);
} else if (tolua_isusertype(tolua_S, 3, "region", 0, &tolua_err)) { } else if (tolua_isusertype(L, 3, "region", 0, &tolua_err)) {
return tolua_hashtable_set_usertype(tolua_S, TREGION); return tolua_hashtable_set_usertype(L, TREGION);
} }
return tolua_hashtable_set_string(tolua_S); return tolua_hashtable_set_string(L);
} }
void void
tolua_hashtable_open(lua_State* tolua_S) tolua_hashtable_open(lua_State* L)
{ {
/* register user types */ /* register user types */
tolua_usertype(tolua_S, "hashtable"); tolua_usertype(L, "hashtable");
tolua_module(tolua_S, NULL, 0); tolua_module(L, NULL, 0);
tolua_beginmodule(tolua_S, NULL); tolua_beginmodule(L, NULL);
{ {
tolua_cclass(tolua_S, "hashtable", "hashtable", "", NULL); tolua_cclass(L, "hashtable", "hashtable", "", NULL);
tolua_beginmodule(tolua_S, "hashtable"); tolua_beginmodule(L, "hashtable");
{ {
tolua_function(tolua_S, "get", tolua_hashtable_get); tolua_function(L, "get", tolua_hashtable_get);
tolua_function(tolua_S, "set", tolua_hashtable_set); tolua_function(L, "set", tolua_hashtable_set);
} }
tolua_endmodule(tolua_S); tolua_endmodule(L);
} }
tolua_endmodule(tolua_S); tolua_endmodule(L);
} }

2
src/eressea/tolua/bind_hashtable.h
View file

@ -15,7 +15,7 @@ extern "C" {
#endif #endif
struct lua_State; struct lua_State;
void tolua_hashtable_open(struct lua_State *tolua_S); void tolua_hashtable_open(struct lua_State *L);
typedef struct attrib ** hashtable; typedef struct attrib ** hashtable;

124
src/eressea/tolua/bind_message.c
View file

@ -195,129 +195,129 @@ msg_send_region(lua_message * lmsg, region * r)
static int static int
tolua_msg_create(lua_State * tolua_S) tolua_msg_create(lua_State * L)
{ {
const char * type = tolua_tostring(tolua_S, 1, 0); const char * type = tolua_tostring(L, 1, 0);
lua_message * lmsg = msg_create_message(type); lua_message * lmsg = msg_create_message(type);
tolua_pushusertype(tolua_S, (void*)lmsg, "message"); tolua_pushusertype(L, (void*)lmsg, "message");
return 1; return 1;
} }
static int static int
tolua_msg_set_string(lua_State * tolua_S) tolua_msg_set_string(lua_State * L)
{ {
lua_message * lmsg = (lua_message *)tolua_tousertype(tolua_S, 1, 0); lua_message * lmsg = (lua_message *)tolua_tousertype(L, 1, 0);
const char * param = tolua_tostring(tolua_S, 2, 0); const char * param = tolua_tostring(L, 2, 0);
const char * value = tolua_tostring(tolua_S, 3, 0); const char * value = tolua_tostring(L, 3, 0);
int result = msg_set_string(lmsg, param, value); int result = msg_set_string(lmsg, param, value);
tolua_pushnumber(tolua_S, (lua_Number)result); tolua_pushnumber(L, (lua_Number)result);
return 1; return 1;
} }
static int static int
tolua_msg_set_int(lua_State * tolua_S) tolua_msg_set_int(lua_State * L)
{ {
lua_message * lmsg = (lua_message *)tolua_tousertype(tolua_S, 1, 0); lua_message * lmsg = (lua_message *)tolua_tousertype(L, 1, 0);
const char * param = tolua_tostring(tolua_S, 2, 0); const char * param = tolua_tostring(L, 2, 0);
int value = (int)tolua_tonumber(tolua_S, 3, 0); int value = (int)tolua_tonumber(L, 3, 0);
int result = msg_set_int(lmsg, param, value); int result = msg_set_int(lmsg, param, value);
tolua_pushnumber(tolua_S, (lua_Number)result); tolua_pushnumber(L, (lua_Number)result);
return 1; return 1;
} }
static int static int
tolua_msg_set_resource(lua_State * tolua_S) tolua_msg_set_resource(lua_State * L)
{ {
lua_message * lmsg = (lua_message *)tolua_tousertype(tolua_S, 1, 0); lua_message * lmsg = (lua_message *)tolua_tousertype(L, 1, 0);
const char * param = tolua_tostring(tolua_S, 2, 0); const char * param = tolua_tostring(L, 2, 0);
const char * value = tolua_tostring(tolua_S, 3, 0); const char * value = tolua_tostring(L, 3, 0);
int result = msg_set_resource(lmsg, param, value); int result = msg_set_resource(lmsg, param, value);
tolua_pushnumber(tolua_S, (lua_Number)result); tolua_pushnumber(L, (lua_Number)result);
return 1; return 1;
} }
static int static int
tolua_msg_set_unit(lua_State * tolua_S) tolua_msg_set_unit(lua_State * L)
{ {
lua_message * lmsg = (lua_message *)tolua_tousertype(tolua_S, 1, 0); lua_message * lmsg = (lua_message *)tolua_tousertype(L, 1, 0);
const char * param = tolua_tostring(tolua_S, 2, 0); const char * param = tolua_tostring(L, 2, 0);
unit * value = (unit *)tolua_tousertype(tolua_S, 3, 0); unit * value = (unit *)tolua_tousertype(L, 3, 0);
int result = msg_set_unit(lmsg, param, value); int result = msg_set_unit(lmsg, param, value);
tolua_pushnumber(tolua_S, (lua_Number)result); tolua_pushnumber(L, (lua_Number)result);
return 1; return 1;
} }
static int static int
tolua_msg_set_region(lua_State * tolua_S) tolua_msg_set_region(lua_State * L)
{ {
lua_message * lmsg = (lua_message *)tolua_tousertype(tolua_S, 1, 0); lua_message * lmsg = (lua_message *)tolua_tousertype(L, 1, 0);
const char * param = tolua_tostring(tolua_S, 2, 0); const char * param = tolua_tostring(L, 2, 0);
region * value = (region *)tolua_tousertype(tolua_S, 3, 0); region * value = (region *)tolua_tousertype(L, 3, 0);
int result = msg_set_region(lmsg, param, value); int result = msg_set_region(lmsg, param, value);
tolua_pushnumber(tolua_S, (lua_Number)result); tolua_pushnumber(L, (lua_Number)result);
return 1; return 1;
} }
static int static int
tolua_msg_set(lua_State * tolua_S) tolua_msg_set(lua_State * L)
{ {
tolua_Error err; tolua_Error err;
if (tolua_isnumber(tolua_S, 3, 0, &err)) { if (tolua_isnumber(L, 3, 0, &err)) {
return tolua_msg_set_int(tolua_S); return tolua_msg_set_int(L);
} else if (tolua_isusertype(tolua_S, 3, "region", 0, &err)) { } else if (tolua_isusertype(L, 3, "region", 0, &err)) {
return tolua_msg_set_region(tolua_S); return tolua_msg_set_region(L);
} else if (tolua_isusertype(tolua_S, 3, "unit", 0, &err)) { } else if (tolua_isusertype(L, 3, "unit", 0, &err)) {
return tolua_msg_set_unit(tolua_S); return tolua_msg_set_unit(L);
} }
tolua_pushnumber(tolua_S, (lua_Number)-1); tolua_pushnumber(L, (lua_Number)-1);
return 1; return 1;
} }
static int static int
tolua_msg_send_region(lua_State * tolua_S) tolua_msg_send_region(lua_State * L)
{ {
lua_message * lmsg = (lua_message *)tolua_tousertype(tolua_S, 1, 0); lua_message * lmsg = (lua_message *)tolua_tousertype(L, 1, 0);
region * r = (region *)tolua_tousertype(tolua_S, 2, 0); region * r = (region *)tolua_tousertype(L, 2, 0);
int result = msg_send_region(lmsg, r); int result = msg_send_region(lmsg, r);
tolua_pushnumber(tolua_S, (lua_Number)result); tolua_pushnumber(L, (lua_Number)result);
return 1; return 1;
} }
static int static int
tolua_msg_send_faction(lua_State * tolua_S) tolua_msg_send_faction(lua_State * L)
{ {
lua_message * lmsg = (lua_message *)tolua_tousertype(tolua_S, 1, 0); lua_message * lmsg = (lua_message *)tolua_tousertype(L, 1, 0);
faction * f = (faction *)tolua_tousertype(tolua_S, 2, 0); faction * f = (faction *)tolua_tousertype(L, 2, 0);
int result = msg_send_faction(lmsg, f); int result = msg_send_faction(lmsg, f);
tolua_pushnumber(tolua_S, (lua_Number)result); tolua_pushnumber(L, (lua_Number)result);
return 1; return 1;
} }
void void
tolua_message_open(lua_State* tolua_S) tolua_message_open(lua_State* L)
{ {
/* register user types */ /* register user types */
tolua_usertype(tolua_S, "message"); tolua_usertype(L, "message");
tolua_module(tolua_S, NULL, 0); tolua_module(L, NULL, 0);
tolua_beginmodule(tolua_S, NULL); tolua_beginmodule(L, NULL);
{ {
tolua_function(tolua_S, "message", tolua_msg_create); tolua_function(L, "message", tolua_msg_create);
tolua_cclass(tolua_S, "message", "message", "", NULL); tolua_cclass(L, "message", "message", "", NULL);
tolua_beginmodule(tolua_S, "message"); tolua_beginmodule(L, "message");
{ {
tolua_function(tolua_S, "set", tolua_msg_set); tolua_function(L, "set", tolua_msg_set);
tolua_function(tolua_S, "set_unit", tolua_msg_set_unit); tolua_function(L, "set_unit", tolua_msg_set_unit);
tolua_function(tolua_S, "set_region", tolua_msg_set_region); tolua_function(L, "set_region", tolua_msg_set_region);
tolua_function(tolua_S, "set_resource", tolua_msg_set_resource); tolua_function(L, "set_resource", tolua_msg_set_resource);
tolua_function(tolua_S, "set_int", tolua_msg_set_int); tolua_function(L, "set_int", tolua_msg_set_int);
tolua_function(tolua_S, "set_string", tolua_msg_set_string); tolua_function(L, "set_string", tolua_msg_set_string);
tolua_function(tolua_S, "send_faction", tolua_msg_send_faction); tolua_function(L, "send_faction", tolua_msg_send_faction);
tolua_function(tolua_S, "send_region", tolua_msg_send_region); tolua_function(L, "send_region", tolua_msg_send_region);
tolua_function(tolua_S, "create", tolua_msg_create); tolua_function(L, "create", tolua_msg_create);
} }
tolua_endmodule(tolua_S); tolua_endmodule(L);
} }
tolua_endmodule(tolua_S); tolua_endmodule(L);
} }

2
src/eressea/tolua/bind_message.h
View file

@ -15,7 +15,7 @@ extern "C" {
#endif #endif
struct lua_State; struct lua_State;
void tolua_message_open(struct lua_State *tolua_S); void tolua_message_open(struct lua_State *L);
#ifdef __cplusplus #ifdef __cplusplus
} }

240
src/eressea/tolua/bind_region.c
View file

@ -35,12 +35,12 @@ without prior permission by the authors of Eressea.
#include <lua.h> #include <lua.h>
#include <tolua.h> #include <tolua.h>
int tolua_regionlist_next(lua_State *tolua_S) int tolua_regionlist_next(lua_State *L)
{ {
region** region_ptr = (region **)lua_touserdata(tolua_S, lua_upvalueindex(1)); region** region_ptr = (region **)lua_touserdata(L, lua_upvalueindex(1));
region * u = *region_ptr; region * u = *region_ptr;
if (u != NULL) { if (u != NULL) {
tolua_pushusertype(tolua_S, (void*)u, "region"); tolua_pushusertype(L, (void*)u, "region");
*region_ptr = u->next; *region_ptr = u->next;
return 1; return 1;
} }
@ -48,90 +48,90 @@ int tolua_regionlist_next(lua_State *tolua_S)
} }
static int static int
tolua_region_get_id(lua_State* tolua_S) tolua_region_get_id(lua_State* L)
{ {
region * self = (region *)tolua_tousertype(tolua_S, 1, 0); region * self = (region *)tolua_tousertype(L, 1, 0);
tolua_pushnumber(tolua_S, (lua_Number)self->uid); tolua_pushnumber(L, (lua_Number)self->uid);
return 1; return 1;
} }
static int static int
tolua_region_get_x(lua_State* tolua_S) tolua_region_get_x(lua_State* L)
{ {
region * self = (region *)tolua_tousertype(tolua_S, 1, 0); region * self = (region *)tolua_tousertype(L, 1, 0);
tolua_pushnumber(tolua_S, (lua_Number)self->x); tolua_pushnumber(L, (lua_Number)self->x);
return 1; return 1;
} }
static int static int
tolua_region_get_y(lua_State* tolua_S) tolua_region_get_y(lua_State* L)
{ {
region * self = (region *)tolua_tousertype(tolua_S, 1, 0); region * self = (region *)tolua_tousertype(L, 1, 0);
tolua_pushnumber(tolua_S, (lua_Number)self->y); tolua_pushnumber(L, (lua_Number)self->y);
return 1; return 1;
} }
static int static int
tolua_region_get_terrain(lua_State* tolua_S) tolua_region_get_terrain(lua_State* L)
{ {
region* self = (region*) tolua_tousertype(tolua_S, 1, 0); region* self = (region*) tolua_tousertype(L, 1, 0);
tolua_pushstring(tolua_S, self->terrain->_name); tolua_pushstring(L, self->terrain->_name);
return 1; return 1;
} }
static int tolua_region_get_info(lua_State* tolua_S) static int tolua_region_get_info(lua_State* L)
{ {
region* self = (region*) tolua_tousertype(tolua_S, 1, 0); region* self = (region*) tolua_tousertype(L, 1, 0);
tolua_pushstring(tolua_S, region_getinfo(self)); tolua_pushstring(L, region_getinfo(self));
return 1; return 1;
} }
static int tolua_region_set_info(lua_State* tolua_S) static int tolua_region_set_info(lua_State* L)
{ {
region* self = (region*)tolua_tousertype(tolua_S, 1, 0); region* self = (region*)tolua_tousertype(L, 1, 0);
region_setinfo(self, tolua_tostring(tolua_S, 2, 0)); region_setinfo(self, tolua_tostring(L, 2, 0));
return 0; return 0;
} }
static int tolua_region_get_name(lua_State* tolua_S) static int tolua_region_get_name(lua_State* L)
{ {
region* self = (region*) tolua_tousertype(tolua_S, 1, 0); region* self = (region*) tolua_tousertype(L, 1, 0);
tolua_pushstring(tolua_S, region_getname(self)); tolua_pushstring(L, region_getname(self));
return 1; return 1;
} }
static int tolua_region_set_name(lua_State* tolua_S) static int tolua_region_set_name(lua_State* L)
{ {
region* self = (region*)tolua_tousertype(tolua_S, 1, 0); region* self = (region*)tolua_tousertype(L, 1, 0);
region_setname(self, tolua_tostring(tolua_S, 2, 0)); region_setname(self, tolua_tostring(L, 2, 0));
return 0; return 0;
} }
static int tolua_region_get_flag(lua_State* tolua_S) static int tolua_region_get_flag(lua_State* L)
{ {
region* self = (region*)tolua_tousertype(tolua_S, 1, 0); region* self = (region*)tolua_tousertype(L, 1, 0);
int bit = (int)tolua_tonumber(tolua_S, 2, 0); int bit = (int)tolua_tonumber(L, 2, 0);
lua_pushboolean(tolua_S, (self->flags & (1<<bit))); lua_pushboolean(L, (self->flags & (1<<bit)));
return 1; return 1;
} }
static int tolua_region_get_adj(lua_State* tolua_S) static int tolua_region_get_adj(lua_State* L)
{ {
region* self = (region*)tolua_tousertype(tolua_S, 1, 0); region* self = (region*)tolua_tousertype(L, 1, 0);
direction_t dir = (direction_t)tolua_tonumber(tolua_S, 2, 0); direction_t dir = (direction_t)tolua_tonumber(L, 2, 0);
tolua_pushusertype(tolua_S, (void*)r_connect(self, dir), "region"); tolua_pushusertype(L, (void*)r_connect(self, dir), "region");
return 1; return 1;
} }
static int tolua_region_set_flag(lua_State* tolua_S) static int tolua_region_set_flag(lua_State* L)
{ {
region* self = (region*)tolua_tousertype(tolua_S, 1, 0); region* self = (region*)tolua_tousertype(L, 1, 0);
int bit = (int)tolua_tonumber(tolua_S, 2, 0); int bit = (int)tolua_tonumber(L, 2, 0);
int set = tolua_toboolean(tolua_S, 3, 0); int set = tolua_toboolean(L, 3, 0);
if (set) self->flags |= (1<<bit); if (set) self->flags |= (1<<bit);
else self->flags &= ~(1<<bit); else self->flags &= ~(1<<bit);
@ -139,16 +139,16 @@ static int tolua_region_set_flag(lua_State* tolua_S)
} }
static int static int
tolua_region_get_resourcelevel(lua_State* tolua_S) tolua_region_get_resourcelevel(lua_State* L)
{ {
region * r = (region *)tolua_tousertype(tolua_S, 1, 0); region * r = (region *)tolua_tousertype(L, 1, 0);
const char * type = tolua_tostring(tolua_S, 2, 0); const char * type = tolua_tostring(L, 2, 0);
const resource_type * rtype = rt_find(type); const resource_type * rtype = rt_find(type);
if (rtype!=NULL) { if (rtype!=NULL) {
const rawmaterial * rm; const rawmaterial * rm;
for (rm=r->resources;rm;rm=rm->next) { for (rm=r->resources;rm;rm=rm->next) {
if (rm->type->rtype==rtype) { if (rm->type->rtype==rtype) {
tolua_pushnumber(tolua_S, (lua_Number)rm->level); tolua_pushnumber(L, (lua_Number)rm->level);
return 1; return 1;
} }
} }
@ -157,10 +157,10 @@ tolua_region_get_resourcelevel(lua_State* tolua_S)
} }
static int static int
tolua_region_get_resource(lua_State* tolua_S) tolua_region_get_resource(lua_State* L)
{ {
region * r = (region *)tolua_tousertype(tolua_S, 1, 0); region * r = (region *)tolua_tousertype(L, 1, 0);
const char * type = tolua_tostring(tolua_S, 2, 0); const char * type = tolua_tostring(L, 2, 0);
const resource_type * rtype = rt_find(type); const resource_type * rtype = rt_find(type);
int result = 0; int result = 0;
@ -174,16 +174,16 @@ tolua_region_get_resource(lua_State* tolua_S)
result = region_getresource(r, rtype); result = region_getresource(r, rtype);
} }
tolua_pushnumber(tolua_S, (lua_Number)result); tolua_pushnumber(L, (lua_Number)result);
return 1; return 1;
} }
static int static int
tolua_region_set_resource(lua_State* tolua_S) tolua_region_set_resource(lua_State* L)
{ {
region * r = (region *)tolua_tousertype(tolua_S, 1, 0); region * r = (region *)tolua_tousertype(L, 1, 0);
const char * type = tolua_tostring(tolua_S, 2, 0); const char * type = tolua_tostring(L, 2, 0);
int value = (int)tolua_tonumber(tolua_S, 3, 0); int value = (int)tolua_tonumber(L, 3, 0);
const resource_type * rtype = rt_find(type); const resource_type * rtype = rt_find(type);
if (rtype!=NULL) { if (rtype!=NULL) {
@ -207,19 +207,19 @@ tolua_region_set_resource(lua_State* tolua_S)
} }
static int static int
tolua_region_get_objects(lua_State* tolua_S) tolua_region_get_objects(lua_State* L)
{ {
region * self = (region *)tolua_tousertype(tolua_S, 1, 0); region * self = (region *)tolua_tousertype(L, 1, 0);
tolua_pushusertype(tolua_S, (void*)&self->attribs, "hashtable"); tolua_pushusertype(L, (void*)&self->attribs, "hashtable");
return 1; return 1;
} }
static int static int
tolua_region_create(lua_State* tolua_S) tolua_region_create(lua_State* L)
{ {
short x = (short)tolua_tonumber(tolua_S, 1, 0); short x = (short)tolua_tonumber(L, 1, 0);
short y = (short)tolua_tonumber(tolua_S, 2, 0); short y = (short)tolua_tonumber(L, 2, 0);
const char * tname = tolua_tostring(tolua_S, 3, 0); const char * tname = tolua_tostring(L, 3, 0);
const terrain_type * terrain = get_terrain(tname); const terrain_type * terrain = get_terrain(tname);
region * r = findregion(x, y); region * r = findregion(x, y);
@ -241,82 +241,82 @@ tolua_region_create(lua_State* tolua_S)
} }
fix_demand(result); fix_demand(result);
tolua_pushusertype(tolua_S, result, "region"); tolua_pushusertype(L, result, "region");
return 1; return 1;
} }
static int tolua_region_get_units(lua_State* tolua_S) static int tolua_region_get_units(lua_State* L)
{ {
region * self = (region *)tolua_tousertype(tolua_S, 1, 0); region * self = (region *)tolua_tousertype(L, 1, 0);
unit ** unit_ptr = (unit**)lua_newuserdata(tolua_S, sizeof(unit *)); unit ** unit_ptr = (unit**)lua_newuserdata(L, sizeof(unit *));
luaL_getmetatable(tolua_S, "unit"); luaL_getmetatable(L, "unit");
lua_setmetatable(tolua_S, -2); lua_setmetatable(L, -2);
*unit_ptr = self->units; *unit_ptr = self->units;
lua_pushcclosure(tolua_S, tolua_unitlist_next, 1); lua_pushcclosure(L, tolua_unitlist_next, 1);
return 1; return 1;
} }
static int tolua_region_get_buildings(lua_State* tolua_S) static int tolua_region_get_buildings(lua_State* L)
{ {
region * self = (region *)tolua_tousertype(tolua_S, 1, 0); region * self = (region *)tolua_tousertype(L, 1, 0);
building ** building_ptr = (building**)lua_newuserdata(tolua_S, sizeof(building *)); building ** building_ptr = (building**)lua_newuserdata(L, sizeof(building *));
luaL_getmetatable(tolua_S, "building"); luaL_getmetatable(L, "building");
lua_setmetatable(tolua_S, -2); lua_setmetatable(L, -2);
*building_ptr = self->buildings; *building_ptr = self->buildings;
lua_pushcclosure(tolua_S, tolua_buildinglist_next, 1); lua_pushcclosure(L, tolua_buildinglist_next, 1);
return 1; return 1;
} }
static int tolua_region_get_ships(lua_State* tolua_S) static int tolua_region_get_ships(lua_State* L)
{ {
region * self = (region *)tolua_tousertype(tolua_S, 1, 0); region * self = (region *)tolua_tousertype(L, 1, 0);
ship ** ship_ptr = (ship**)lua_newuserdata(tolua_S, sizeof(ship *)); ship ** ship_ptr = (ship**)lua_newuserdata(L, sizeof(ship *));
luaL_getmetatable(tolua_S, "ship"); luaL_getmetatable(L, "ship");
lua_setmetatable(tolua_S, -2); lua_setmetatable(L, -2);
*ship_ptr = self->ships; *ship_ptr = self->ships;
lua_pushcclosure(tolua_S, tolua_shiplist_next, 1); lua_pushcclosure(L, tolua_shiplist_next, 1);
return 1; return 1;
} }
static int tolua_region_get_age(lua_State* tolua_S) static int tolua_region_get_age(lua_State* L)
{ {
region * self = (region *)tolua_tousertype(tolua_S, 1, 0); region * self = (region *)tolua_tousertype(L, 1, 0);
if (self) { if (self) {
lua_pushnumber(tolua_S, self->age); lua_pushnumber(L, self->age);
return 1; return 1;
} }
return 0; return 0;
} }
static int static int
tolua_region_getkey(lua_State* tolua_S) tolua_region_getkey(lua_State* L)
{ {
region * self = (region *)tolua_tousertype(tolua_S, 1, 0); region * self = (region *)tolua_tousertype(L, 1, 0);
const char * name = tolua_tostring(tolua_S, 2, 0); const char * name = tolua_tostring(L, 2, 0);
int flag = atoi36(name); int flag = atoi36(name);
attrib * a = find_key(self->attribs, flag); attrib * a = find_key(self->attribs, flag);
lua_pushboolean(tolua_S, a!=NULL); lua_pushboolean(L, a!=NULL);
return 1; return 1;
} }
static int static int
tolua_region_setkey(lua_State* tolua_S) tolua_region_setkey(lua_State* L)
{ {
region * self = (region *)tolua_tousertype(tolua_S, 1, 0); region * self = (region *)tolua_tousertype(L, 1, 0);
const char * name = tolua_tostring(tolua_S, 2, 0); const char * name = tolua_tostring(L, 2, 0);
int value = tolua_toboolean(tolua_S, 3, 0); int value = tolua_toboolean(L, 3, 0);
int flag = atoi36(name); int flag = atoi36(name);
attrib * a = find_key(self->attribs, flag); attrib * a = find_key(self->attribs, flag);
@ -329,47 +329,47 @@ tolua_region_setkey(lua_State* tolua_S)
} }
static int static int
tolua_region_tostring(lua_State *tolua_S) tolua_region_tostring(lua_State *L)
{ {
region * self = (region *)tolua_tousertype(tolua_S, 1, 0); region * self = (region *)tolua_tousertype(L, 1, 0);
lua_pushstring(tolua_S, regionname(self, NULL)); lua_pushstring(L, regionname(self, NULL));
return 1; return 1;
} }
void void
tolua_region_open(lua_State* tolua_S) tolua_region_open(lua_State* L)
{ {
/* register user types */ /* register user types */
tolua_usertype(tolua_S, "region"); tolua_usertype(L, "region");
tolua_module(tolua_S, NULL, 0); tolua_module(L, NULL, 0);
tolua_beginmodule(tolua_S, NULL); tolua_beginmodule(L, NULL);
{ {
tolua_cclass(tolua_S, "region", "region", "", NULL); tolua_cclass(L, "region", "region", "", NULL);
tolua_beginmodule(tolua_S, "region"); tolua_beginmodule(L, "region");
{ {
tolua_function(tolua_S, "create", tolua_region_create); tolua_function(L, "create", tolua_region_create);
tolua_function(tolua_S, "__tostring", tolua_region_tostring); tolua_function(L, "__tostring", tolua_region_tostring);
tolua_variable(tolua_S, "id", tolua_region_get_id, NULL); tolua_variable(L, "id", tolua_region_get_id, NULL);
tolua_variable(tolua_S, "x", tolua_region_get_x, NULL); tolua_variable(L, "x", tolua_region_get_x, NULL);
tolua_variable(tolua_S, "y", tolua_region_get_y, NULL); tolua_variable(L, "y", tolua_region_get_y, NULL);
tolua_variable(tolua_S, "name", tolua_region_get_name, tolua_region_set_name); tolua_variable(L, "name", tolua_region_get_name, tolua_region_set_name);
tolua_variable(tolua_S, "info", tolua_region_get_info, tolua_region_set_info); tolua_variable(L, "info", tolua_region_get_info, tolua_region_set_info);
tolua_variable(tolua_S, "units", tolua_region_get_units, NULL); tolua_variable(L, "units", tolua_region_get_units, NULL);
tolua_variable(tolua_S, "ships", tolua_region_get_ships, NULL); tolua_variable(L, "ships", tolua_region_get_ships, NULL);
tolua_variable(tolua_S, "age", tolua_region_get_age, NULL); tolua_variable(L, "age", tolua_region_get_age, NULL);
tolua_variable(tolua_S, "buildings", tolua_region_get_buildings, NULL); tolua_variable(L, "buildings", tolua_region_get_buildings, NULL);
tolua_variable(tolua_S, "terrain", tolua_region_get_terrain, NULL); tolua_variable(L, "terrain", tolua_region_get_terrain, NULL);
tolua_function(tolua_S, "get_resourcelevel", tolua_region_get_resourcelevel); tolua_function(L, "get_resourcelevel", tolua_region_get_resourcelevel);
tolua_function(tolua_S, "get_resource", tolua_region_get_resource); tolua_function(L, "get_resource", tolua_region_get_resource);
tolua_function(tolua_S, "set_resource", tolua_region_set_resource); tolua_function(L, "set_resource", tolua_region_set_resource);
tolua_function(tolua_S, "get_flag", tolua_region_get_flag); tolua_function(L, "get_flag", tolua_region_get_flag);
tolua_function(tolua_S, "set_flag", tolua_region_set_flag); tolua_function(L, "set_flag", tolua_region_set_flag);
tolua_function(tolua_S, "next", tolua_region_get_adj); tolua_function(L, "next", tolua_region_get_adj);
tolua_function(tolua_S, "get_key", tolua_region_getkey); tolua_function(L, "get_key", tolua_region_getkey);
tolua_function(tolua_S, "set_key", tolua_region_setkey); tolua_function(L, "set_key", tolua_region_setkey);
#if 0 #if 0
.property("owner", &lua_region_getowner, &lua_region_setowner) .property("owner", &lua_region_getowner, &lua_region_setowner)
.property("herbtype", &region_getherbtype, &region_setherbtype) .property("herbtype", &region_getherbtype, &region_setherbtype)
@ -383,9 +383,9 @@ tolua_region_open(lua_State* tolua_S)
.property("items", &region_items, return_stl_iterator) .property("items", &region_items, return_stl_iterator)
.property("plane_id", &region_plane) .property("plane_id", &region_plane)
#endif #endif
tolua_variable(tolua_S, "objects", tolua_region_get_objects, 0); tolua_variable(L, "objects", tolua_region_get_objects, 0);
} }
tolua_endmodule(tolua_S); tolua_endmodule(L);
} }
tolua_endmodule(tolua_S); tolua_endmodule(L);
} }

4
src/eressea/tolua/bind_region.h
View file

@ -15,8 +15,8 @@ extern "C" {
#endif #endif
struct lua_State; struct lua_State;
void tolua_region_open(struct lua_State *tolua_S); void tolua_region_open(struct lua_State *L);
int tolua_regionlist_next(struct lua_State *tolua_S); int tolua_regionlist_next(struct lua_State *L);
#ifdef __cplusplus #ifdef __cplusplus
} }

99
src/eressea/tolua/bind_ship.c
View file

@ -24,12 +24,12 @@ without prior permission by the authors of Eressea.
#include <lua.h> #include <lua.h>
#include <tolua.h> #include <tolua.h>
int tolua_shiplist_next(lua_State *tolua_S) int tolua_shiplist_next(lua_State *L)
{ {
ship** ship_ptr = (ship **)lua_touserdata(tolua_S, lua_upvalueindex(1)); ship** ship_ptr = (ship **)lua_touserdata(L, lua_upvalueindex(1));
ship * u = *ship_ptr; ship * u = *ship_ptr;
if (u != NULL) { if (u != NULL) {
tolua_pushusertype(tolua_S, (void*)u, "ship"); tolua_pushusertype(L, (void*)u, "ship");
*ship_ptr = u->next; *ship_ptr = u->next;
return 1; return 1;
} }
@ -37,83 +37,83 @@ int tolua_shiplist_next(lua_State *tolua_S)
} }
static int static int
tolua_ship_get_id(lua_State* tolua_S) tolua_ship_get_id(lua_State* L)
{ {
ship * self = (ship *)tolua_tousertype(tolua_S, 1, 0); ship * self = (ship *)tolua_tousertype(L, 1, 0);
tolua_pushnumber(tolua_S, (lua_Number)self->no); tolua_pushnumber(L, (lua_Number)self->no);
return 1; return 1;
} }
static int tolua_ship_get_name(lua_State* tolua_S) static int tolua_ship_get_name(lua_State* L)
{ {
ship* self = (ship*) tolua_tousertype(tolua_S, 1, 0); ship* self = (ship*) tolua_tousertype(L, 1, 0);
tolua_pushstring(tolua_S, ship_getname(self)); tolua_pushstring(L, ship_getname(self));
return 1; return 1;
} }
static int tolua_ship_get_region(lua_State* tolua_S) static int tolua_ship_get_region(lua_State* L)
{ {
ship* self = (ship*) tolua_tousertype(tolua_S, 1, 0); ship* self = (ship*) tolua_tousertype(L, 1, 0);
if (self) { if (self) {
tolua_pushusertype(tolua_S, self->region, "region"); tolua_pushusertype(L, self->region, "region");
return 1; return 1;
} }
return 0; return 0;
} }
static int tolua_ship_set_region(lua_State* tolua_S) static int tolua_ship_set_region(lua_State* L)
{ {
ship* self = (ship*) tolua_tousertype(tolua_S, 1, 0); ship* self = (ship*) tolua_tousertype(L, 1, 0);
region * r = (region*) tolua_tousertype(tolua_S, 1, 0); region * r = (region*) tolua_tousertype(L, 1, 0);
if (self) { if (self) {
move_ship(self, self->region, r, NULL); move_ship(self, self->region, r, NULL);
} }
return 0; return 0;
} }
static int tolua_ship_set_name(lua_State* tolua_S) static int tolua_ship_set_name(lua_State* L)
{ {
ship* self = (ship*)tolua_tousertype(tolua_S, 1, 0); ship* self = (ship*)tolua_tousertype(L, 1, 0);
ship_setname(self, tolua_tostring(tolua_S, 2, 0)); ship_setname(self, tolua_tostring(L, 2, 0));
return 0; return 0;
} }
static int static int
tolua_ship_get_units(lua_State* tolua_S) tolua_ship_get_units(lua_State* L)
{ {
ship * self = (ship *)tolua_tousertype(tolua_S, 1, 0); ship * self = (ship *)tolua_tousertype(L, 1, 0);
unit ** unit_ptr = (unit**)lua_newuserdata(tolua_S, sizeof(unit *)); unit ** unit_ptr = (unit**)lua_newuserdata(L, sizeof(unit *));
unit * u = self->region->units; unit * u = self->region->units;
while (u && u->ship!=self) u = u->next; while (u && u->ship!=self) u = u->next;
luaL_getmetatable(tolua_S, "unit"); luaL_getmetatable(L, "unit");
lua_setmetatable(tolua_S, -2); lua_setmetatable(L, -2);
*unit_ptr = u; *unit_ptr = u;
lua_pushcclosure(tolua_S, tolua_unitlist_nexts, 1); lua_pushcclosure(L, tolua_unitlist_nexts, 1);
return 1; return 1;
} }
static int static int
tolua_ship_get_objects(lua_State* tolua_S) tolua_ship_get_objects(lua_State* L)
{ {
ship * self = (ship *)tolua_tousertype(tolua_S, 1, 0); ship * self = (ship *)tolua_tousertype(L, 1, 0);
tolua_pushusertype(tolua_S, (void*)&self->attribs, "hashtable"); tolua_pushusertype(L, (void*)&self->attribs, "hashtable");
return 1; return 1;
} }
static int static int
tolua_ship_create(lua_State* tolua_S) tolua_ship_create(lua_State* L)
{ {
region * r = (region *)tolua_tousertype(tolua_S, 1, 0); region * r = (region *)tolua_tousertype(L, 1, 0);
const char * sname = tolua_tostring(tolua_S, 2, 0); const char * sname = tolua_tostring(L, 2, 0);
if (sname) { if (sname) {
const ship_type * stype = st_find(sname); const ship_type * stype = st_find(sname);
if (stype) { if (stype) {
ship * sh = new_ship(stype, NULL, r); ship * sh = new_ship(stype, NULL, r);
sh->size = stype->construction->maxsize; sh->size = stype->construction->maxsize;
tolua_pushusertype(tolua_S, (void*)sh, "ship"); tolua_pushusertype(L, (void*)sh, "ship");
return 1; return 1;
} }
} }
@ -121,30 +121,31 @@ tolua_ship_create(lua_State* tolua_S)
} }
static int static int
tolua_ship_tostring(lua_State *tolua_S)
tolua_ship_tostring(lua_State *L)
{ {
ship * self = (ship *)tolua_tousertype(tolua_S, 1, 0); ship * self = (ship *)tolua_tousertype(L, 1, 0);
lua_pushstring(tolua_S, shipname(self)); lua_pushstring(L, shipname(self));
return 1; return 1;
} }
void void
tolua_ship_open(lua_State* tolua_S) tolua_ship_open(lua_State* L)
{ {
/* register user types */ /* register user types */
tolua_usertype(tolua_S, "ship"); tolua_usertype(L, "ship");
tolua_module(tolua_S, NULL, 0); tolua_module(L, NULL, 0);
tolua_beginmodule(tolua_S, NULL); tolua_beginmodule(L, NULL);
{ {
tolua_cclass(tolua_S, "ship", "ship", "", NULL); tolua_cclass(L, "ship", "ship", "", NULL);
tolua_beginmodule(tolua_S, "ship"); tolua_beginmodule(L, "ship");
{ {
tolua_function(tolua_S, "__tostring", tolua_ship_tostring); tolua_function(L, "__tostring", tolua_ship_tostring);
tolua_variable(tolua_S, "id", tolua_ship_get_id, NULL); tolua_variable(L, "id", tolua_ship_get_id, NULL);
tolua_variable(tolua_S, "name", tolua_ship_get_name, tolua_ship_set_name); tolua_variable(L, "name", tolua_ship_get_name, tolua_ship_set_name);
tolua_variable(tolua_S, "units", tolua_ship_get_units, NULL); tolua_variable(L, "units", tolua_ship_get_units, NULL);
tolua_variable(tolua_S, "region", tolua_ship_get_region, tolua_ship_set_region); tolua_variable(L, "region", tolua_ship_get_region, tolua_ship_set_region);
#ifdef TODO #ifdef TODO
.property("type", &ship_gettype) .property("type", &ship_gettype)
.property("weight", &ship_getweight) .property("weight", &ship_getweight)
@ -155,11 +156,11 @@ tolua_ship_open(lua_State* tolua_S)
.def_readwrite("size", &ship::size) .def_readwrite("size", &ship::size)
.def_readwrite("coast", &ship::coast) .def_readwrite("coast", &ship::coast)
#endif #endif
tolua_variable(tolua_S, "objects", tolua_ship_get_objects, 0); tolua_variable(L, "objects", tolua_ship_get_objects, 0);
tolua_function(tolua_S, "create", tolua_ship_create); tolua_function(L, "create", tolua_ship_create);
} }
tolua_endmodule(tolua_S); tolua_endmodule(L);
} }
tolua_endmodule(tolua_S); tolua_endmodule(L);
} }

4
src/eressea/tolua/bind_ship.h
View file

@ -15,8 +15,8 @@ extern "C" {
#endif #endif
struct lua_State; struct lua_State;
int tolua_shiplist_next(struct lua_State *tolua_S); int tolua_shiplist_next(struct lua_State *L);
void tolua_ship_open(struct lua_State *tolua_S); void tolua_ship_open(struct lua_State *L);
#ifdef __cplusplus #ifdef __cplusplus
} }

82
src/eressea/tolua/bind_storage.c
View file

@ -25,10 +25,10 @@ without prior permission by the authors of Eressea.
static int static int
tolua_storage_create(lua_State* tolua_S) tolua_storage_create(lua_State* L)
{ {
const char * filename = tolua_tostring(tolua_S, 1, 0); const char * filename = tolua_tostring(L, 1, 0);
const char * type = tolua_tostring(tolua_S, 2, "rb"); const char * type = tolua_tostring(L, 2, "rb");
storage * store = 0; storage * store = 0;
int mode = IO_READ; int mode = IO_READ;
if (strchr(type, 't')) { if (strchr(type, 't')) {
@ -41,53 +41,53 @@ tolua_storage_create(lua_State* tolua_S)
if (strchr(type, 'r')) mode = IO_READ; if (strchr(type, 'r')) mode = IO_READ;
if (strchr(type, 'w')) mode = IO_WRITE; if (strchr(type, 'w')) mode = IO_WRITE;
store->open(store, filename, mode); store->open(store, filename, mode);
tolua_pushusertype(tolua_S, (void*)store, "storage"); tolua_pushusertype(L, (void*)store, "storage");
return 1; return 1;
} }
static int static int
tolua_storage_read_unit(lua_State *tolua_S) tolua_storage_read_unit(lua_State *L)
{ {
storage * self = (storage *)tolua_tousertype(tolua_S, 1, 0); storage * self = (storage *)tolua_tousertype(L, 1, 0);
struct unit * u = read_unit(self); struct unit * u = read_unit(self);
tolua_pushusertype(tolua_S, (void*)u, "unit"); tolua_pushusertype(L, (void*)u, "unit");
return 1; return 1;
} }
static int static int
tolua_storage_write_unit(lua_State *tolua_S) tolua_storage_write_unit(lua_State *L)
{ {
storage * self = (storage *)tolua_tousertype(tolua_S, 1, 0); storage * self = (storage *)tolua_tousertype(L, 1, 0);
struct unit * u = (struct unit *)tolua_tousertype(tolua_S, 2, 0); struct unit * u = (struct unit *)tolua_tousertype(L, 2, 0);
write_unit(self, u); write_unit(self, u);
return 0; return 0;
} }
static int static int
tolua_storage_read_float(lua_State *tolua_S) tolua_storage_read_float(lua_State *L)
{ {
storage * self = (storage *)tolua_tousertype(tolua_S, 1, 0); storage * self = (storage *)tolua_tousertype(L, 1, 0);
float num = self->r_flt(self); float num = self->r_flt(self);
tolua_pushnumber(tolua_S, (lua_Number)num); tolua_pushnumber(L, (lua_Number)num);
return 1; return 1;
} }
static int static int
tolua_storage_read_int(lua_State *tolua_S) tolua_storage_read_int(lua_State *L)
{ {
storage * self = (storage *)tolua_tousertype(tolua_S, 1, 0); storage * self = (storage *)tolua_tousertype(L, 1, 0);
int num = self->r_int(self); int num = self->r_int(self);
tolua_pushnumber(tolua_S, (lua_Number)num); tolua_pushnumber(L, (lua_Number)num);
return 1; return 1;
} }
static int static int
tolua_storage_write(lua_State *tolua_S) tolua_storage_write(lua_State *L)
{ {
storage * self = (storage *)tolua_tousertype(tolua_S, 1, 0); storage * self = (storage *)tolua_tousertype(L, 1, 0);
if (tolua_isnumber(tolua_S, 2, 0, 0)) { if (tolua_isnumber(L, 2, 0, 0)) {
lua_Number num = tolua_tonumber(tolua_S, 2, 0); lua_Number num = tolua_tonumber(L, 2, 0);
double n; double n;
if (modf(num, &n)==0.0) { if (modf(num, &n)==0.0) {
self->w_int(self, (int)num); self->w_int(self, (int)num);
@ -99,45 +99,45 @@ tolua_storage_write(lua_State *tolua_S)
} }
static int static int
tolua_storage_tostring(lua_State *tolua_S) tolua_storage_tostring(lua_State *L)
{ {
storage * self = (storage *)tolua_tousertype(tolua_S, 1, 0); storage * self = (storage *)tolua_tousertype(L, 1, 0);
char name[64]; char name[64];
snprintf(name, sizeof(name), "<storage enc=%d ver=%d>", self->encoding, self->version); snprintf(name, sizeof(name), "<storage enc=%d ver=%d>", self->encoding, self->version);
lua_pushstring(tolua_S, name); lua_pushstring(L, name);
return 1; return 1;
} }
static int static int
tolua_storage_close(lua_State *tolua_S) tolua_storage_close(lua_State *L)
{ {
storage * self = (storage *)tolua_tousertype(tolua_S, 1, 0); storage * self = (storage *)tolua_tousertype(L, 1, 0);
self->close(self); self->close(self);
return 0; return 0;
} }
void void
tolua_storage_open(lua_State* tolua_S) tolua_storage_open(lua_State* L)
{ {
/* register user types */ /* register user types */
tolua_usertype(tolua_S, "storage"); tolua_usertype(L, "storage");
tolua_module(tolua_S, NULL, 0); tolua_module(L, NULL, 0);
tolua_beginmodule(tolua_S, NULL); tolua_beginmodule(L, NULL);
{ {
tolua_cclass(tolua_S, "storage", "storage", "", NULL); tolua_cclass(L, "storage", "storage", "", NULL);
tolua_beginmodule(tolua_S, "storage"); tolua_beginmodule(L, "storage");
{ {
tolua_function(tolua_S, "__tostring", tolua_storage_tostring); tolua_function(L, "__tostring", tolua_storage_tostring);
tolua_function(tolua_S, "write", tolua_storage_write); tolua_function(L, "write", tolua_storage_write);
tolua_function(tolua_S, "read_int", tolua_storage_read_int); tolua_function(L, "read_int", tolua_storage_read_int);
tolua_function(tolua_S, "read_float", tolua_storage_read_float); tolua_function(L, "read_float", tolua_storage_read_float);
tolua_function(tolua_S, "write_unit", tolua_storage_write_unit); tolua_function(L, "write_unit", tolua_storage_write_unit);
tolua_function(tolua_S, "read_unit", tolua_storage_read_unit); tolua_function(L, "read_unit", tolua_storage_read_unit);
tolua_function(tolua_S, "close", tolua_storage_close); tolua_function(L, "close", tolua_storage_close);
tolua_function(tolua_S, "create", tolua_storage_create); tolua_function(L, "create", tolua_storage_create);
} }
tolua_endmodule(tolua_S); tolua_endmodule(L);
} }
tolua_endmodule(tolua_S); tolua_endmodule(L);
} }

2
src/eressea/tolua/bind_storage.h
View file

@ -15,7 +15,7 @@ extern "C" {
#endif #endif
struct lua_State; struct lua_State;
void tolua_storage_open(struct lua_State *tolua_S); void tolua_storage_open(struct lua_State *L);
#ifdef __cplusplus #ifdef __cplusplus
} }

560
src/eressea/tolua/bind_unit.c
View file

File diff suppressed because it is too large Load diff

10
src/eressea/tolua/bind_unit.h
View file

@ -15,11 +15,11 @@ extern "C" {
#endif #endif
struct lua_State; struct lua_State;
int tolua_unitlist_nextb(struct lua_State *tolua_S); int tolua_unitlist_nextb(struct lua_State *L);
int tolua_unitlist_nexts(struct lua_State *tolua_S); int tolua_unitlist_nexts(struct lua_State *L);
int tolua_unitlist_nextf(struct lua_State *tolua_S); int tolua_unitlist_nextf(struct lua_State *L);
int tolua_unitlist_next(struct lua_State *tolua_S); int tolua_unitlist_next(struct lua_State *L);
void tolua_unit_open(struct lua_State *tolua_S); void tolua_unit_open(struct lua_State *L);
#ifdef __cplusplus #ifdef __cplusplus
} }

546
src/eressea/tolua/bindings.c
View file

File diff suppressed because it is too large Load diff

8
src/eressea/tolua/bindings.h
View file

@ -15,10 +15,10 @@ extern "C" {
#endif #endif
struct lua_State; struct lua_State;
int tolua_eressea_open(struct lua_State* tolua_S); int tolua_eressea_open(struct lua_State* L);
int tolua_spelllist_next(struct lua_State *tolua_S); int tolua_spelllist_next(struct lua_State *L);
int tolua_itemlist_next(struct lua_State *tolua_S); int tolua_itemlist_next(struct lua_State *L);
int tolua_orderlist_next(struct lua_State *tolua_S); int tolua_orderlist_next(struct lua_State *L);
#ifdef __cplusplus #ifdef __cplusplus
} }

8
src/eressea/tolua/helpers.c
View file

@ -530,14 +530,14 @@ lua_recruit(struct unit * u, const struct archetype * arch, int amount)
} }
int int
tolua_toid(lua_State* tolua_S, int idx, int def) tolua_toid(lua_State* L, int idx, int def)
{ {
int no = 0; int no = 0;
int type = lua_type(tolua_S, idx); int type = lua_type(L, idx);
if (type==LUA_TNUMBER) { if (type==LUA_TNUMBER) {
no = (int)tolua_tonumber(tolua_S, idx, def); no = (int)tolua_tonumber(L, idx, def);
} else { } else {
const char * str = tolua_tostring(tolua_S, idx, NULL); const char * str = tolua_tostring(L, idx, NULL);
no = str?atoi36(str):def; no = str?atoi36(str):def;
} }
return no; return no;

2
src/eressea/tolua/helpers.h
View file

@ -15,7 +15,7 @@ extern "C" {
#endif #endif
void register_tolua_helpers(void); void register_tolua_helpers(void);
int tolua_toid(struct lua_State* tolua_S, int idx, int def); int tolua_toid(struct lua_State* L, int idx, int def);
#ifdef __cplusplus #ifdef __cplusplus
} }