server/src/bindings.c

/* 
+-------------------+
|                   |  Enno Rehling <enno@eressea.de>
| Eressea PBEM host |  Christian Schlittchen <corwin@amber.kn-bremen.de>
| (c) 1998 - 2008   |  Katja Zedel <katze@felidae.kn-bremen.de>
|                   |  Henning Peters <faroul@beyond.kn-bremen.de>
+-------------------+

This program may not be used, modified or distributed
without prior permission by the authors of Eressea.
*/

#include <platform.h>
#include "bindings.h"
#include "bind_unit.h"
#include "bind_storage.h"
#include "bind_building.h"
#include "bind_dict.h"
#include "bind_message.h"
#include "bind_building.h"
#include "bind_faction.h"
#include "bind_ship.h"
#include "bind_gmtool.h"
#include "bind_region.h"
#include "helpers.h"
#include "console.h"
#include "reports.h"

#include <kernel/config.h>

#include <kernel/alliance.h>
#include <kernel/building.h>
#include <kernel/curse.h>
#include <kernel/equipment.h>
#include <kernel/calendar.h>
#include <kernel/unit.h>
#include <kernel/terrain.h>
#include <kernel/messages.h>
#include <kernel/region.h>
#include <kernel/building.h>
#include <kernel/plane.h>
#include <kernel/race.h>
#include <kernel/item.h>
#include <kernel/order.h>
#include <kernel/ship.h>
#include <kernel/teleport.h>
#include <kernel/faction.h>
#include <kernel/save.h>
#include <kernel/spell.h>
#include <kernel/spellbook.h>

#include "creport.h"
#include "economy.h"
#include "summary.h"
#include "laws.h"
#include "monster.h"
#include "market.h"

#include <modules/autoseed.h>
#include <modules/score.h>
#include <attributes/key.h>

#include <util/attrib.h>
#include <util/base36.h>
#include <util/language.h>
#include <util/lists.h>
#include <util/log.h>
#include <quicklist.h>
#include <util/rand.h>
#include <util/rng.h>
#include <util/xml.h>

#include <storage.h>

#include <iniparser.h>
#include <tolua.h>
#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>

#include <time.h>
#include <assert.h>

#define TOLUA_PKG(NAME) extern void tolua_##NAME##_open(lua_State * L)

TOLUA_PKG(eressea);
TOLUA_PKG(process);
TOLUA_PKG(settings);
TOLUA_PKG(config);
TOLUA_PKG(locale);
TOLUA_PKG(log);
TOLUA_PKG(game);

int log_lua_error(lua_State * L)
{
    const char *error = lua_tostring(L, -1);
    log_fatal("LUA call failed.\n%s\n", error);
    lua_pop(L, 1);
    return 1;
}

int tolua_orderlist_next(lua_State * L)
{
    order **order_ptr = (order **)lua_touserdata(L, lua_upvalueindex(1));
    order *ord = *order_ptr;
    if (ord != NULL) {
        char cmd[8192];
        write_order(ord, cmd, sizeof(cmd));
        tolua_pushstring(L, cmd);
        *order_ptr = ord->next;
        return 1;
    }
    return 0;
}

static int tolua_quicklist_iter(lua_State * L)
{
    quicklist **qlp = (quicklist **)lua_touserdata(L, lua_upvalueindex(1));
    quicklist *ql = *qlp;
    if (ql != NULL) {
        int index = (int)lua_tointeger(L, lua_upvalueindex(2));
        const char *type = lua_tostring(L, lua_upvalueindex(3));
        void *data = ql_get(ql, index);
        tolua_pushusertype(L, data, TOLUA_CAST type);
        ql_advance(qlp, &index, 1);
        lua_pushinteger(L, index);
        lua_replace(L, lua_upvalueindex(2));
        return 1;
    }
    return 0;
}

int tolua_quicklist_push(struct lua_State *L, const char *list_type,
    const char *elem_type, struct quicklist *list)
{
    if (list) {
        quicklist **qlist_ptr =
            (quicklist **)lua_newuserdata(L, sizeof(quicklist *));
        *qlist_ptr = list;
        luaL_getmetatable(L, list_type);
        lua_setmetatable(L, -2);
        lua_pushinteger(L, 0);
        lua_pushstring(L, elem_type);
        lua_pushcclosure(L, tolua_quicklist_iter, 3);       /* OBS: this closure has multiple upvalues (list, index, type_name) */
    }
    else {
        lua_pushnil(L);
    }
    return 1;
}

int tolua_itemlist_next(lua_State * L)
{
    item **item_ptr = (item **)lua_touserdata(L, lua_upvalueindex(1));
    item *itm = *item_ptr;
    if (itm != NULL) {
        tolua_pushstring(L, itm->type->rtype->_name);
        *item_ptr = itm->next;
        return 1;
    }
    return 0;
}

static int tolua_autoseed(lua_State * L)
{
    const char *filename = tolua_tostring(L, 1, 0);
    int new_island = tolua_toboolean(L, 2, 0);
    newfaction *players = read_newfactions(filename);
    if (players != NULL) {
        while (players) {
            int n = listlen(players);
            int k = (n + ISLANDSIZE - 1) / ISLANDSIZE;
            k = n / k;
            n = autoseed(&players, k, new_island ? 0 : TURNS_PER_ISLAND);
            if (n == 0) {
                break;
            }
        }
    }
    return 0;
}

static int tolua_getkey(lua_State * L)
{
    const char *name = tolua_tostring(L, 1, 0);
    int flag = atoi36(name);
    attrib *a = find_key(global.attribs, flag);
    lua_pushboolean(L, a != NULL);
    return 1;
}

static int tolua_translate(lua_State * L)
{
    const char *str = tolua_tostring(L, 1, 0);
    const char *lang = tolua_tostring(L, 2, 0);
    struct locale *loc = lang ? get_locale(lang) : default_locale;
    if (loc) {
        str = LOC(loc, str);
        tolua_pushstring(L, str);
        return 1;
    }
    return 0;
}

static int tolua_setkey(lua_State * L)
{
    const char *name = tolua_tostring(L, 1, 0);
    int value = tolua_toboolean(L, 2, 0);
    int flag = atoi36(name);
    attrib *a = find_key(global.attribs, flag);
    if (a == NULL && value) {
        add_key(&global.attribs, flag);
    }
    else if (a != NULL && !value) {
        a_remove(&global.attribs, a);
    }
    return 0;
}

static int tolua_rng_int(lua_State * L)
{
    lua_pushinteger(L, rng_int());
    return 1;
}

static int tolua_read_orders(lua_State * L)
{
    const char *filename = tolua_tostring(L, 1, 0);
    int result = readorders(filename);
    lua_pushinteger(L, result);
    return 1;
}

static int tolua_message_unit(lua_State * L)
{
    unit *sender = (unit *)tolua_tousertype(L, 1, 0);
    unit *target = (unit *)tolua_tousertype(L, 2, 0);
    const char *str = tolua_tostring(L, 3, 0);
    if (!target)
        tolua_error(L, TOLUA_CAST "target is nil", NULL);
    if (!sender)
        tolua_error(L, TOLUA_CAST "sender is nil", NULL);
    deliverMail(target->faction, sender->region, sender, str, target);
    return 0;
}

static int tolua_message_faction(lua_State * L)
{
    unit *sender = (unit *)tolua_tousertype(L, 1, 0);
    faction *target = (faction *)tolua_tousertype(L, 2, 0);
    const char *str = tolua_tostring(L, 3, 0);
    if (!target)
        tolua_error(L, TOLUA_CAST "target is nil", NULL);
    if (!sender)
        tolua_error(L, TOLUA_CAST "sender is nil", NULL);
    deliverMail(target, sender->region, sender, str, NULL);
    return 0;
}

static int tolua_message_region(lua_State * L)
{
    unit *sender = (unit *)tolua_tousertype(L, 1, 0);
    const char *str = tolua_tostring(L, 2, 0);
    if (!sender)
        tolua_error(L, TOLUA_CAST "sender is nil", NULL);
    ADDMSG(&sender->region->msgs, msg_message("mail_result", "unit message",
        sender, str));
    return 0;
}

static int tolua_update_guards(lua_State * L)
{
    update_guards();
    return 0;
}

static int tolua_set_turn(lua_State * L)
{
    turn = (int)tolua_tonumber(L, 1, 0);
    return 0;
}

static int tolua_get_turn(lua_State * L)
{
    lua_pushinteger(L, turn);
    return 1;
}

static int tolua_atoi36(lua_State * L)
{
    const char *s = tolua_tostring(L, 1, 0);
    lua_pushinteger(L, atoi36(s));
    return 1;
}

static int tolua_itoa36(lua_State * L)
{
    int i = (int)tolua_tonumber(L, 1, 0);
    tolua_pushstring(L, itoa36(i));
    return 1;
}

static int tolua_dice_rand(lua_State * L)
{
    const char *s = tolua_tostring(L, 1, 0);
    lua_pushinteger(L, dice_rand(s));
    return 1;
}

static int tolua_addequipment(lua_State * L)
{
    const char *eqname = tolua_tostring(L, 1, 0);
    const char *iname = tolua_tostring(L, 2, 0);
    const char *value = tolua_tostring(L, 3, 0);
    int result = -1;
    if (iname != NULL) {
        const struct item_type *itype = it_find(iname);
        if (itype != NULL) {
            equipment_setitem(create_equipment(eqname), itype, value);
            result = 0;
        }
    }
    lua_pushinteger(L, result);
    return 1;
}

static int tolua_get_season(lua_State * L)
{
    int turnno = (int)tolua_tonumber(L, 1, 0);
    gamedate gd;
    get_gamedate(turnno, &gd);
    tolua_pushstring(L, seasonnames[gd.season]);
    return 1;
}

static int tolua_create_curse(lua_State * L)
{
    unit *u = (unit *)tolua_tousertype(L, 1, 0);
    tolua_Error tolua_err;
    attrib **ap = NULL;
    if (tolua_isusertype(L, 2, TOLUA_CAST "unit", 0, &tolua_err)) {
        unit *target = (unit *)tolua_tousertype(L, 2, 0);
        if (target)
            ap = &target->attribs;
    }
    else if (tolua_isusertype(L, 2, TOLUA_CAST "region", 0, &tolua_err)) {
        region *target = (region *)tolua_tousertype(L, 2, 0);
        if (target)
            ap = &target->attribs;
    }
    else if (tolua_isusertype(L, 2, TOLUA_CAST "ship", 0, &tolua_err)) {
        ship *target = (ship *)tolua_tousertype(L, 2, 0);
        if (target)
            ap = &target->attribs;
    }
    else if (tolua_isusertype(L, 2, TOLUA_CAST "building", 0, &tolua_err)) {
        building *target = (building *)tolua_tousertype(L, 2, 0);
        if (target)
            ap = &target->attribs;
    }
    if (ap) {
        const char *cname = tolua_tostring(L, 3, 0);
        const curse_type *ctype = ct_find(cname);
        if (ctype) {
            float vigour = (float)tolua_tonumber(L, 4, 0);
            int duration = (int)tolua_tonumber(L, 5, 0);
            float effect = (float)tolua_tonumber(L, 6, 0);
            int men = (int)tolua_tonumber(L, 7, 0);   /* optional */
            curse *c = create_curse(u, ap, ctype, vigour, duration, effect, men);
            if (c) {
                tolua_pushboolean(L, true);
                return 1;
            }
        }
    }
    tolua_pushboolean(L, false);
    return 1;
}

static int tolua_learn_skill(lua_State * L)
{
    unit *u = (unit *)tolua_tousertype(L, 1, 0);
    const char *skname = tolua_tostring(L, 2, 0);
    float chances = (float)tolua_tonumber(L, 3, 0);
    skill_t sk = findskill(skname);
    if (sk != NOSKILL) {
        learn_skill(u, sk, chances);
    }
    return 0;
}

static int tolua_update_scores(lua_State * L)
{
    score();
    return 0;
}

static int tolua_update_owners(lua_State * L)
{
    region *r;
    for (r = regions; r; r = r->next) {
        update_owners(r);
    }
    return 0;
}

static int tolua_update_subscriptions(lua_State * L)
{
    update_subscriptions();
    return 0;
}

static int tolua_remove_empty_units(lua_State * L)
{
    remove_empty_units();
    return 0;
}

static int tolua_get_nmrs(lua_State * L)
{
    int result = -1;
    int n = (int)tolua_tonumber(L, 1, 0);
    if (n >= 0 && n <= NMRTimeout()) {
        if (nmrs == NULL) {
            update_nmrs();
        }
        result = nmrs[n];
    }
    lua_pushinteger(L, result);
    return 1;
}

static int tolua_equipunit(lua_State * L)
{
    unit *u = (unit *)tolua_tousertype(L, 1, 0);
    const char *eqname = tolua_tostring(L, 2, 0);
    int mask = (int)tolua_tonumber(L, 3, EQUIP_ALL);
    assert(mask > 0);
    equip_unit_mask(u, get_equipment(eqname), mask);
    return 0;
}

static int tolua_equipment_setitem(lua_State * L)
{
    int result = -1;
    const char *eqname = tolua_tostring(L, 1, 0);
    const char *iname = tolua_tostring(L, 2, 0);
    const char *value = tolua_tostring(L, 3, 0);
    if (iname != NULL) {
        const struct item_type *itype = it_find(iname);
        if (itype != NULL) {
            equipment_setitem(create_equipment(eqname), itype, value);
            result = 0;
        }
    }
    lua_pushinteger(L, result);
    return 1;
}

static int tolua_spawn_braineaters(lua_State * L)
{
    float chance = (float)tolua_tonumber(L, 1, 0);
    spawn_braineaters(chance);
    return 0;
}

static int tolua_init_reports(lua_State * L)
{
    int result = init_reports();
    lua_pushinteger(L, result);
    return 1;
}

static int tolua_write_report(lua_State * L)
{
    faction *f = (faction *)tolua_tousertype(L, 1, 0);
    if (f) {
        time_t ltime = time(0);
        int result = write_reports(f, ltime);
        lua_pushinteger(L, result);
    }
    else {
        tolua_pushstring(L, "function expects a faction, got nil");
    }
    return 1;
}

static int tolua_write_reports(lua_State * L)
{
    int result;
    init_reports();
    result = reports();
    lua_pushinteger(L, result);
    return 1;
}

static void reset_game(void)
{
    region *r;
    faction *f;
    for (r = regions; r; r = r->next) {
        unit *u;
        building *b;
        r->flags &= RF_SAVEMASK;
        for (u = r->units; u; u = u->next) {
            u->flags &= UFL_SAVEMASK;
        }
        for (b = r->buildings; b; b = b->next) {
            b->flags &= BLD_SAVEMASK;
        }
        if (r->land && r->land->ownership && r->land->ownership->owner) {
            faction *owner = r->land->ownership->owner;
            if (owner == get_monsters()) {
                /* some compat-fix, i believe. */
                owner = update_owners(r);
            }
            if (owner) {
                fset(r, RF_GUARDED);
            }
        }
    }
    for (f = factions; f; f = f->next) {
        f->flags &= FFL_SAVEMASK;
    }
    init_locales();
}

static int tolua_process_orders(lua_State * L)
{
    ++turn;
    reset_game();
    processorders();
    return 0;
}

static int tolua_write_passwords(lua_State * L)
{
    int result = writepasswd();
    lua_pushinteger(L, result);
    return 0;
}

static struct summary *sum_begin = 0;
static int tolua_init_summary(lua_State * L)
{
    sum_begin = make_summary();
    return 0;
}

static int tolua_write_summary(lua_State * L)
{
    if (sum_begin) {
        struct summary *sum_end = make_summary();
        report_summary(sum_end, sum_begin, false);
        report_summary(sum_end, sum_begin, true);
        return 0;
    }
    return 0;
}

static int tolua_write_map(lua_State * L)
{
    const char *filename = tolua_tostring(L, 1, 0);
    if (filename) {
        crwritemap(filename);
    }
    return 0;
}

static int tolua_read_turn(lua_State * L)
{
    int cturn = current_turn();
    lua_pushinteger(L, cturn);
    return 1;
}

static int tolua_get_region(lua_State * L)
{
    int x = (int)tolua_tonumber(L, 1, 0);
    int y = (int)tolua_tonumber(L, 2, 0);
    region *r;
    assert(!pnormalize(&x, &y, findplane(x, y)));
    r = findregion(x, y);
    tolua_pushusertype(L, r, TOLUA_CAST "region");
    return 1;
}

static int tolua_get_region_byid(lua_State * L)
{
    int uid = (int)tolua_tonumber(L, 1, 0);
    region *r = findregionbyid(uid);
    tolua_pushusertype(L, r, TOLUA_CAST "region");
    return 1;
}

static int tolua_get_building(lua_State * L)
{
    int no = tolua_toid(L, 1, 0);
    building *b = findbuilding(no);
    tolua_pushusertype(L, b, TOLUA_CAST "building");
    return 1;
}

static int tolua_get_ship(lua_State * L)
{
    int no = tolua_toid(L, 1, 0);
    ship *sh = findship(no);
    tolua_pushusertype(L, sh, TOLUA_CAST "ship");
    return 1;
}

static int tolua_get_alliance(lua_State * L)
{
    int no = tolua_toid(L, 1, 0);
    alliance *f = findalliance(no);
    tolua_pushusertype(L, f, TOLUA_CAST "alliance");
    return 1;
}

static int tolua_get_unit(lua_State * L)
{
    int no = tolua_toid(L, 1, 0);
    unit *u = findunit(no);
    tolua_pushusertype(L, u, TOLUA_CAST "unit");
    return 1;
}

static int tolua_alliance_create(lua_State * L)
{
    int id = (int)tolua_tonumber(L, 1, 0);
    const char *name = tolua_tostring(L, 2, 0);
    alliance *alli = makealliance(id, name);
    tolua_pushusertype(L, alli, TOLUA_CAST "alliance");
    return 1;
}

static int tolua_get_regions(lua_State * L)
{
    region **region_ptr = (region **)lua_newuserdata(L, sizeof(region *));
    luaL_getmetatable(L, "region");
    lua_setmetatable(L, -2);
    *region_ptr = regions;
    lua_pushcclosure(L, tolua_regionlist_next, 1);
    return 1;
}

static int tolua_get_factions(lua_State * L)
{
    faction **faction_ptr = (faction **)lua_newuserdata(L, sizeof(faction *));
    luaL_getmetatable(L, "faction");
    lua_setmetatable(L, -2);
    *faction_ptr = factions;
    lua_pushcclosure(L, tolua_factionlist_next, 1);
    return 1;
}

static int tolua_get_alliance_factions(lua_State * L)
{
    alliance *self = (alliance *)tolua_tousertype(L, 1, 0);
    return tolua_quicklist_push(L, "faction_list", "faction", self->members);
}

static int tolua_get_alliance_id(lua_State * L)
{
    alliance *self = (alliance *)tolua_tousertype(L, 1, 0);
    lua_pushinteger(L, self->id);
    return 1;
}

static int tolua_get_alliance_name(lua_State * L)
{
    alliance *self = (alliance *)tolua_tousertype(L, 1, 0);
    tolua_pushstring(L, self->name);
    return 1;
}

static int tolua_set_alliance_name(lua_State * L)
{
    alliance *self = (alliance *)tolua_tousertype(L, 1, 0);
    alliance_setname(self, tolua_tostring(L, 2, 0));
    return 0;
}

#ifdef WRITE_SPELLS
#include <libxml/tree.h>
#include <util/functions.h>
#include <util/xml.h>
#include <kernel/spell.h>
static int tolua_write_spells(lua_State * L)
{
    spell_f fun = (spell_f) get_function("lua_castspell");
    const char *filename = "magic.xml";
    xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
    xmlNodePtr root = xmlNewNode(NULL, BAD_CAST "spells");
    quicklist *ql;
    int qi;
    for (ql = spells, qi = 0; ql; ql_advance(&ql, &qi, 1)) {
        spell *sp = (spell *) ql_get(ql, qi);
        if (sp->cast != fun) {
            int combat = 0;
            xmlNodePtr node = xmlNewNode(NULL, BAD_CAST "spell");
            xmlNewProp(node, BAD_CAST "name", BAD_CAST sp->sname);
            xmlNewProp(node, BAD_CAST "type", BAD_CAST magic_school[sp->magietyp]);
            xmlNewProp(node, BAD_CAST "rank", xml_i(sp->rank));
            xmlNewProp(node, BAD_CAST "level", xml_i(sp->level));
            xmlNewProp(node, BAD_CAST "index", xml_i(sp->id));
            if (sp->syntax)
                xmlNewProp(node, BAD_CAST "syntax", BAD_CAST sp->syntax);
            if (sp->parameter)
                xmlNewProp(node, BAD_CAST "parameters", BAD_CAST sp->parameter);
            if (sp->components) {
                spell_component *comp = sp->components;
                for (; comp->type != 0; ++comp) {
                    static const char *costs[] = { "fixed", "level", "linear" };
                    xmlNodePtr cnode = xmlNewNode(NULL, BAD_CAST "resource");
                    xmlNewProp(cnode, BAD_CAST "name", BAD_CAST comp->type->_name);
                    xmlNewProp(cnode, BAD_CAST "amount", xml_i(comp->amount));
                    xmlNewProp(cnode, BAD_CAST "cost", BAD_CAST costs[comp->cost]);
                    xmlAddChild(node, cnode);
                }}
            if (sp->sptyp & TESTCANSEE) {
                xmlNewProp(node, BAD_CAST "los", BAD_CAST "true");
            }
            if (sp->sptyp & ONSHIPCAST) {
                xmlNewProp(node, BAD_CAST "ship", BAD_CAST "true");
            }
            if (sp->sptyp & OCEANCASTABLE) {
                xmlNewProp(node, BAD_CAST "ocean", BAD_CAST "true");
            }
            if (sp->sptyp & FARCASTING) {
                xmlNewProp(node, BAD_CAST "far", BAD_CAST "true");
            }
            if (sp->sptyp & SPELLLEVEL) {
                xmlNewProp(node, BAD_CAST "variable", BAD_CAST "true");
            }
            if (sp->sptyp & POSTCOMBATSPELL)
                combat = 3;

            else if (sp->sptyp & COMBATSPELL)
                combat = 2;

            else if (sp->sptyp & PRECOMBATSPELL)
                combat = 1;
            if (combat) {
                xmlNewProp(node, BAD_CAST "combat", xml_i(combat));
            }
            xmlAddChild(root, node);
        }
    }
    xmlDocSetRootElement(doc, root);
    xmlKeepBlanksDefault(0);
    xmlSaveFormatFileEnc(filename, doc, "utf-8", 1);
    xmlFreeDoc(doc);
    return 0;
}
#endif

static int config_get_ships(lua_State * L)
{
    quicklist *ql;
    int qi, i = 0;
    lua_createtable(L, ql_length(shiptypes), 0);
    for (qi = 0, ql = shiptypes; ql; ql_advance(&ql, &qi, 1)) {
        ship_type *stype = (ship_type *)ql_get(ql, qi);
        tolua_pushstring(L, TOLUA_CAST stype->_name);
        lua_rawseti(L, -2, ++i);
    }
    return 1;
}

static int config_get_buildings(lua_State * L)
{
    quicklist *ql;
    int qi, i = 0;
    lua_createtable(L, ql_length(buildingtypes), 0);
    for (qi = 0, ql = buildingtypes; ql; ql_advance(&ql, &qi, 1)) {
        building_type *btype = (building_type *)ql_get(ql, qi);
        tolua_pushstring(L, TOLUA_CAST btype->_name);
        lua_rawseti(L, -2, ++i);
    }
    return 1;
}

static int config_get_locales(lua_State * L)
{
    const struct locale *lang;
    int i = 0, n = 0;
    for (lang = locales; lang; lang = nextlocale(lang)) ++n;
    lua_createtable(L, n, 0);
    for (lang = locales; lang; lang = nextlocale(lang)) {
        tolua_pushstring(L, TOLUA_CAST locale_name(lang));
        lua_rawseti(L, -2, ++i);
    }
    return 1;
}

static int config_get_resource(lua_State * L)
{
    const char *name = tolua_tostring(L, 1, 0);
    if (name) {
        const struct item_type *itype = it_find(name);
        if (itype) {
            lua_newtable(L);
            lua_pushstring(L, "weight");
            lua_pushinteger(L, itype->weight);
            lua_settable(L, -3);
            if (itype->capacity > 0) {
                lua_pushstring(L, "capacity");
                lua_pushinteger(L, itype->capacity);
                lua_settable(L, -3);
            }
            if (itype->construction) {
                int i;
                lua_pushstring(L, "build_skill_min");
                lua_pushinteger(L, itype->construction->minskill);
                lua_settable(L, -3);
                lua_pushstring(L, "build_skill_name");
                lua_pushstring(L, skillnames[itype->construction->skill]);
                lua_settable(L, -3);
                if (itype->construction->materials) {
                    lua_pushstring(L, "materials");
                    lua_newtable(L);
                    for (i = 0; itype->construction->materials[i].number; ++i) {
                        lua_pushstring(L,
                            itype->construction->materials[i].rtype->_name);
                        lua_pushinteger(L, itype->construction->materials[i].number);
                        lua_settable(L, -3);
                    }
                    lua_settable(L, -3);
                }
            }
            return 1;
        }
    }
    return 0;
}

static int config_get_btype(lua_State * L)
{
    const char *name = tolua_tostring(L, 1, 0);

    if (name) {
        const struct building_type *btype = bt_find(name);
        if (btype) {
            lua_newtable(L);
            lua_pushstring(L, "flags");
            lua_pushinteger(L, btype->flags);
            lua_settable(L, -3);
            if (btype->capacity > 0) {
                lua_pushstring(L, "capacity");
                lua_pushinteger(L, btype->capacity);
                lua_settable(L, -3);
            }
            if (btype->maxcapacity > 0) {
                lua_pushstring(L, "maxcapacity");
                lua_pushinteger(L, btype->maxcapacity);
                lua_settable(L, -3);
            }
            if (btype->maxsize > 0) {
                lua_pushstring(L, "maxsize");
                lua_pushinteger(L, btype->maxsize);
                lua_settable(L, -3);
            }
            if (btype->maintenance) {
                int i;
                lua_pushstring(L, "maintenance");
                lua_newtable(L);
                for (i = 0; btype->maintenance[i].number; ++i) {
                    lua_pushstring(L,
                        btype->maintenance[i].rtype->_name);
                    lua_pushinteger(L, btype->maintenance[i].number);
                    lua_settable(L, -3);
                }
                lua_settable(L, -3);
            }
            if (btype->construction) {
                int i;
                lua_pushstring(L, "build_skill_min");
                lua_pushinteger(L, btype->construction->minskill);
                lua_settable(L, -3);
                lua_pushstring(L, "build_skill_name");
                lua_pushstring(L, skillnames[btype->construction->skill]);
                lua_settable(L, -3);
                if (btype->construction->materials) {
                    lua_pushstring(L, "materials");
                    lua_newtable(L);
                    for (i = 0; btype->construction->materials[i].number; ++i) {
                        lua_pushstring(L,
                            btype->construction->materials[i].rtype->_name);
                        lua_pushinteger(L, btype->construction->materials[i].number);
                        lua_settable(L, -3);
                    }
                    lua_settable(L, -3);
                }
            }
            return 1;
        }
    }
    return 0;
}

static int config_get_stype(lua_State * L)
{
    const char *name = tolua_tostring(L, 1, 0);

    if (name) {
        const struct ship_type *stype = st_find(name);
        if (stype) {
            lua_newtable(L);
            lua_pushstring(L, "range");
            lua_pushinteger(L, stype->range);
            lua_settable(L, -3);
            lua_pushstring(L, "cabins");
            lua_pushinteger(L, stype->cabins);
            lua_settable(L, -3);
            lua_pushstring(L, "cargo");
            lua_pushinteger(L, stype->cargo);
            lua_settable(L, -3);
            lua_pushstring(L, "cptskill");
            lua_pushinteger(L, stype->cptskill);
            lua_settable(L, -3);
            lua_pushstring(L, "minskill");
            lua_pushinteger(L, stype->minskill);
            lua_settable(L, -3);
            lua_pushstring(L, "sumskill");
            lua_pushinteger(L, stype->sumskill);
            lua_settable(L, -3);
            lua_pushstring(L, "fishing");
            lua_pushinteger(L, stype->fishing);
            lua_settable(L, -3);
            if (stype->coasts) {
                const terrain_type *coast = *stype->coasts;
                lua_pushstring(L, "coasts");
                lua_newtable(L);
                while (coast) {
                    lua_pushstring(L, coast->_name);
                    lua_pushinteger(L, 1);
                    lua_settable(L, -3);
                    coast = coast->next;
                }
            }
            if (stype->construction) {
                int i;
                lua_pushstring(L, "build_skill_min");
                lua_pushinteger(L, stype->construction->minskill);
                lua_settable(L, -3);
                lua_pushstring(L, "build_skill_name");
                lua_pushstring(L, skillnames[stype->construction->skill]);
                lua_settable(L, -3);
                if (stype->construction->materials) {
                    lua_pushstring(L, "materials");
                    lua_newtable(L);
                    for (i = 0; stype->construction->materials[i].number; ++i) {
                        lua_pushstring(L,
                            stype->construction->materials[i].rtype->_name);
                        lua_pushinteger(L, stype->construction->materials[i].number);
                        lua_settable(L, -3);
                    }
                    lua_settable(L, -3);
                }
            }
            return 1;
        }
    }
    return 0;
}

static int tolua_get_spell_text(lua_State * L)
{
    const struct locale *loc = default_locale;
    spell *self = (spell *)tolua_tousertype(L, 1, 0);
    lua_pushstring(L, spell_info(self, loc));
    return 1;
}

#ifdef TODO
static int tolua_get_spell_school(lua_State * L)
{
    spell *self = (spell *) tolua_tousertype(L, 1, 0);
    lua_pushstring(L, magic_school[self->magietyp]);
    return 1;
}

static int tolua_get_spell_level(lua_State * L)
{
    spell *self = (spell *) tolua_tousertype(L, 1, 0);
    lua_pushinteger(L, self->level);
    return 1;
}
#endif

static int tolua_get_spell_name(lua_State * L)
{
    spell *self = (spell *)tolua_tousertype(L, 1, 0);
    lua_pushstring(L, self->sname);
    return 1;
}

static int tolua_get_spell_entry_name(lua_State * L)
{
    spellbook_entry *self = (spellbook_entry*)tolua_tousertype(L, 1, 0);
    lua_pushstring(L, self->sp->sname);
    return 1;
}

static int tolua_get_spell_entry_level(lua_State * L)
{
    spellbook_entry *self = (spellbook_entry*)tolua_tousertype(L, 1, 0);
    lua_pushinteger(L, self->level);
    return 1;
}

static int tolua_get_spells(lua_State * L)
{
    return tolua_quicklist_push(L, "spell_list", "spell", spells);
}

static int init_data(const char *filename, const char *catalog)
{
    int l;
    l = read_xml(filename, catalog);
    reset_locales();
    if (l) {
        return l;
    }
    if (turn < 0) {
        turn = first_turn;
    }
    return 0;
}


int tolua_read_xml(lua_State * L)
{
    const char *filename = tolua_tostring(L, 1, "config.xml");
    const char *catalog = tolua_tostring(L, 2, "catalog.xml");
    lua_pushinteger(L, init_data(filename, catalog));
    return 1;
}

typedef struct event_args {
    int hfunction;
    int hargs;
    const char *sendertype;
} event_args;

static int tolua_report_unit(lua_State * L)
{
    char buffer[512];
    unit *u = (unit *)tolua_tousertype(L, 1, 0);
    faction *f = (faction *)tolua_tousertype(L, 2, 0);
    bufunit(f, u, 0, see_unit, buffer, sizeof(buffer));
    tolua_pushstring(L, buffer);
    return 1;
}

static void parse_inifile(lua_State * L, dictionary * d, const char *section)
{
    int i;
    const char *arg;
    size_t len = strlen(section);

    for (i = 0; d && i != d->n; ++i) {
        const char *key = d->key[i];
        if (strncmp(section, key, len) == 0 && key[len] == ':') {
            const char *str_value = d->val[i];
            char *endp;
            double num_value = strtod(str_value, &endp);
            lua_pushstring(L, key + len + 1);
            if (*endp) {
                tolua_pushstring(L, str_value);
            }
            else {
                lua_pushnumber(L, num_value);
            }
            lua_rawset(L, -3);
        }
    }

    /* special case */
    lua_pushstring(L, "basepath");
    lua_pushstring(L, basepath());
    lua_rawset(L, -3);
    lua_pushstring(L, "reportpath");
    lua_pushstring(L, reportpath());
    lua_rawset(L, -3);
    arg = get_param(global.parameters, "config.rules");
    if (arg) {
        lua_pushstring(L, "rules");
        lua_pushstring(L, arg);
        lua_rawset(L, -3);
    }
}

void tolua_bind_open(lua_State * L);

int tolua_bindings_open(lua_State * L)
{
    tolua_open(L);

    tolua_bind_open(L);

    /* register user types */
    tolua_usertype(L, TOLUA_CAST "spellbook");
    tolua_usertype(L, TOLUA_CAST "spell_entry");
    tolua_usertype(L, TOLUA_CAST "spell");
    tolua_usertype(L, TOLUA_CAST "spell_list");
    tolua_usertype(L, TOLUA_CAST "order");
    tolua_usertype(L, TOLUA_CAST "item");
    tolua_usertype(L, TOLUA_CAST "alliance");
    tolua_usertype(L, TOLUA_CAST "event");
    tolua_usertype(L, TOLUA_CAST "faction_list");
    tolua_module(L, NULL, 0);
    tolua_beginmodule(L, NULL);
    {
        tolua_cclass(L, TOLUA_CAST "alliance", TOLUA_CAST "alliance",
            TOLUA_CAST "", NULL);
        tolua_beginmodule(L, TOLUA_CAST "alliance");
        {
            tolua_variable(L, TOLUA_CAST "name", tolua_get_alliance_name,
                tolua_set_alliance_name);
            tolua_variable(L, TOLUA_CAST "id", tolua_get_alliance_id, NULL);
            tolua_variable(L, TOLUA_CAST "factions", &tolua_get_alliance_factions,
                NULL);
            tolua_function(L, TOLUA_CAST "create", tolua_alliance_create);
        } tolua_endmodule(L);
        tolua_cclass(L, TOLUA_CAST "spell", TOLUA_CAST "spell", TOLUA_CAST "",
            NULL);
        tolua_beginmodule(L, TOLUA_CAST "spell");
        {
            tolua_function(L, TOLUA_CAST "__tostring", tolua_get_spell_name);
            tolua_variable(L, TOLUA_CAST "name", tolua_get_spell_name, 0);
            tolua_variable(L, TOLUA_CAST "text", tolua_get_spell_text, 0);
        } tolua_endmodule(L);
        tolua_cclass(L, TOLUA_CAST "spell_entry", TOLUA_CAST "spell_entry", TOLUA_CAST "",
            NULL);
        tolua_beginmodule(L, TOLUA_CAST "spell_entry");
        {
            tolua_function(L, TOLUA_CAST "__tostring", tolua_get_spell_entry_name);
            tolua_variable(L, TOLUA_CAST "name", tolua_get_spell_entry_name, 0);
            tolua_variable(L, TOLUA_CAST "level", tolua_get_spell_entry_level, 0);
        } tolua_endmodule(L);
        tolua_module(L, TOLUA_CAST "report", 1);
        tolua_beginmodule(L, TOLUA_CAST "report");
        {
            tolua_function(L, TOLUA_CAST "report_unit", &tolua_report_unit);
        } tolua_endmodule(L);
        tolua_module(L, TOLUA_CAST "config", 1);
        tolua_beginmodule(L, TOLUA_CAST "config");
        {
            parse_inifile(L, global.inifile, "lua");
            tolua_variable(L, TOLUA_CAST "locales", &config_get_locales, 0);
            tolua_function(L, TOLUA_CAST "get_resource", &config_get_resource);
            tolua_variable(L, TOLUA_CAST "buildings", &config_get_buildings, 0);
            tolua_function(L, TOLUA_CAST "get_building", &config_get_btype);
            tolua_variable(L, TOLUA_CAST "ships", &config_get_ships, 0);
            tolua_function(L, TOLUA_CAST "get_ship", &config_get_stype);
        } tolua_endmodule(L);
        tolua_function(L, TOLUA_CAST "get_region_by_id", tolua_get_region_byid);
        tolua_function(L, TOLUA_CAST "get_unit", tolua_get_unit);
        tolua_function(L, TOLUA_CAST "get_alliance", tolua_get_alliance);
        tolua_function(L, TOLUA_CAST "get_ship", tolua_get_ship);
        tolua_function(L, TOLUA_CAST "get_building", tolua_get_building);
        tolua_function(L, TOLUA_CAST "get_region", tolua_get_region);
        tolua_function(L, TOLUA_CAST "factions", tolua_get_factions);
        tolua_function(L, TOLUA_CAST "regions", tolua_get_regions);
        tolua_function(L, TOLUA_CAST "read_turn", tolua_read_turn);
        tolua_function(L, TOLUA_CAST "write_map", &tolua_write_map);
        tolua_function(L, TOLUA_CAST "read_orders", tolua_read_orders);
        tolua_function(L, TOLUA_CAST "process_orders", tolua_process_orders);
        tolua_function(L, TOLUA_CAST "init_reports", tolua_init_reports);
        tolua_function(L, TOLUA_CAST "write_reports", tolua_write_reports);
        tolua_function(L, TOLUA_CAST "write_report", tolua_write_report);
        tolua_function(L, TOLUA_CAST "init_summary", tolua_init_summary);
        tolua_function(L, TOLUA_CAST "write_summary", tolua_write_summary);
        tolua_function(L, TOLUA_CAST "write_passwords", tolua_write_passwords);
        tolua_function(L, TOLUA_CAST "message_unit", tolua_message_unit);
        tolua_function(L, TOLUA_CAST "message_faction", tolua_message_faction);
        tolua_function(L, TOLUA_CAST "message_region", tolua_message_region);

        /* scripted monsters */
        tolua_function(L, TOLUA_CAST "spawn_braineaters", tolua_spawn_braineaters);

        tolua_function(L, TOLUA_CAST "update_guards", tolua_update_guards);
        tolua_function(L, TOLUA_CAST "set_turn", &tolua_set_turn);
        tolua_function(L, TOLUA_CAST "get_turn", &tolua_get_turn);
        tolua_function(L, TOLUA_CAST "get_season", tolua_get_season);
        tolua_function(L, TOLUA_CAST "equipment_setitem", tolua_equipment_setitem);
        tolua_function(L, TOLUA_CAST "equip_unit", tolua_equipunit);
        tolua_function(L, TOLUA_CAST "add_equipment", tolua_addequipment);
        tolua_function(L, TOLUA_CAST "atoi36", tolua_atoi36);
        tolua_function(L, TOLUA_CAST "itoa36", tolua_itoa36);
        tolua_function(L, TOLUA_CAST "dice_roll", tolua_dice_rand);
        tolua_function(L, TOLUA_CAST "get_nmrs", tolua_get_nmrs);
        tolua_function(L, TOLUA_CAST "remove_empty_units", tolua_remove_empty_units);
        tolua_function(L, TOLUA_CAST "update_subscriptions", tolua_update_subscriptions);
        tolua_function(L, TOLUA_CAST "update_scores", tolua_update_scores);
        tolua_function(L, TOLUA_CAST "update_owners", tolua_update_owners);
        tolua_function(L, TOLUA_CAST "learn_skill", tolua_learn_skill);
        tolua_function(L, TOLUA_CAST "create_curse", tolua_create_curse);
        tolua_function(L, TOLUA_CAST "autoseed", tolua_autoseed);
        tolua_function(L, TOLUA_CAST "get_key", tolua_getkey);
        tolua_function(L, TOLUA_CAST "set_key", tolua_setkey);
        tolua_function(L, TOLUA_CAST "translate", &tolua_translate);
        tolua_function(L, TOLUA_CAST "rng_int", tolua_rng_int);
        tolua_function(L, TOLUA_CAST "spells", tolua_get_spells);
#ifdef WRITE_SPELLS
        tolua_function(L, TOLUA_CAST "write_spells", tolua_write_spells);
#endif
        tolua_function(L, TOLUA_CAST "read_xml", tolua_read_xml);
    } tolua_endmodule(L);
    return 1;
}

static void openlibs(lua_State * L)
{
    luaL_openlibs(L);
}

void lua_done(lua_State * L) {
    lua_close(L);
}

lua_State *lua_init(void) {
    lua_State *L = luaL_newstate();

    openlibs(L);
    register_tolua_helpers();
    tolua_bindings_open(L);
    tolua_eressea_open(L);
#ifdef USE_SQLITE
    tolua_sqlite_open(L);
#endif
    tolua_unit_open(L);
    tolua_building_open(L);
    tolua_ship_open(L);
    tolua_region_open(L);
    tolua_faction_open(L);
    tolua_unit_open(L);
    tolua_message_open(L);
    tolua_dict_open(L);
#ifdef USE_CURSES
    tolua_gmtool_open(L);
#endif
    tolua_storage_open(L);
    return L;
}

int eressea_run(lua_State *L, const char *luafile)
{
    int err = 0;

    global.vm_state = L;
    /* run the main script */
    if (luafile) {
        log_debug("executing script %s\n", luafile);

        lua_getglobal(L, "debug");
        lua_getfield(L, -1, "traceback");
        lua_remove(L, -2);
        lua_getglobal(L, "dofile");
        lua_pushstring(L, luafile);
        err = lua_pcall(L, 1, 1, -3);
        if (err != 0) {
            log_lua_error(L);
        }
        else  {
            if (lua_isnumber(L, -1)) {
                err = (int)lua_tonumber(L, -1);
            }
            lua_pop(L, 1);
        }
        return err;
    }
    return lua_console(L);
}