Exemplo n.º 1
0
int lua_mapgen(map * m, std::string terrain_type, mapgendata md, int t, float d, const std::string & scr) {
    lua_State* L = lua_state; 
    {
        map** map_userdata = (map**) lua_newuserdata(L, sizeof(map*));
        *map_userdata = m;
        luah_setmetatable(L, "map_metatable");
        luah_setglobal(L, "map", -1);
    }
   
    int err = luaL_loadstring(L, scr.c_str() );
    if(err) {
        // Error handling.
        const char* error = lua_tostring(L, -1);
        debugmsg("Error loading lua mapgen: %s", error);
        return err;
    }
//    int function_index = luaL_ref(L, LUA_REGISTRYINDEX); // todo; make use of this
//    lua_rawgeti(L, LUA_REGISTRYINDEX, function_index);

    lua_pushstring(L, terrain_type.c_str());
    lua_setglobal(L, "tertype");
    lua_pushinteger(L, t);
    lua_setglobal(L, "turn");

    err=lua_pcall(L, 0 , LUA_MULTRET, 0);
    if(err) {
        // Error handling.
        const char* error = lua_tostring(L, -1);
        debugmsg("Error running lua mapgen: %s", error);
    }

//    luah_remove_from_registry(L, function_index); // todo: make use of this

    return err;
}
Exemplo n.º 2
0
// Lua monster movement override
int lua_monster_move(monster* m) {
    lua_State *L = lua_state;

    update_globals(L);

    lua_getglobal(L, "monster_move");
    lua_getfield(L, -1, m->type->name.c_str());

    // OK our function should now be at the top.
    if(lua_isnil(L, -1)) {
        lua_settop(L, 0);
        return 0;
    }

    // Push the monster on top of the stack.
    monster** monster_userdata = (monster**) lua_newuserdata(L, sizeof(monster*));
    *monster_userdata = m;

    // Set the metatable for the monster.
    luah_setmetatable(L, "monster_metatable");

    // Call the function
    int err = lua_pcall(lua_state, 1, 0, 0);
    if(err) {
        // Error handling.
        const char* error = lua_tostring(L, -1);
        debugmsg("Error in lua monster move function: %s", error);
    }
    lua_settop(L, 0);

    return 1;
}
Exemplo n.º 3
0
// items = game.items_at(x, y)
static int game_items_at(lua_State *L) {
    int x = lua_tointeger(L, 1);
    int y = lua_tointeger(L, 2);

    std::vector<item>& items = g->m.i_at(x, y);

    lua_createtable(L, items.size(), 0); // Preallocate enough space for all our items.

    // Iterate over the monster list and insert each monster into our returned table.
    for(int i=0; i < items.size(); i++) {
        // The stack will look like this:
        // 1 - t, table containing item
        // 2 - k, index at which the next item will be inserted
        // 3 - v, next item to insert
        //
        // lua_rawset then does t[k] = v and pops v and k from the stack

        lua_pushnumber(L, i + 1);
        item** item_userdata = (item**) lua_newuserdata(L, sizeof(item*));
        *item_userdata = &(items[i]);
        luah_setmetatable(L, "item_metatable");
        lua_rawset(L, -3);
    }

    return 1; // 1 return values
}
Exemplo n.º 4
0
int lua_mapgen(map *m, std::string terrain_type, mapgendata, int t, float, const std::string &scr)
{
    if( lua_state == nullptr ) {
        return 0;
    }
    lua_State *L = lua_state;
    {
        map **map_userdata = (map **) lua_newuserdata(L, sizeof(map *));
        *map_userdata = m;
        luah_setmetatable(L, "map_metatable");
        luah_setglobal(L, "map", -1);
    }

    int err = luaL_loadstring(L, scr.c_str() );
    if( lua_report_error( L, err, scr.c_str() ) ) {
        return err;
    }
    //    int function_index = luaL_ref(L, LUA_REGISTRYINDEX); // todo; make use of this
    //    lua_rawgeti(L, LUA_REGISTRYINDEX, function_index);

    lua_pushstring(L, terrain_type.c_str());
    lua_setglobal(L, "tertype");
    lua_pushinteger(L, t);
    lua_setglobal(L, "turn");

    err = lua_pcall(L, 0 , LUA_MULTRET, 0);
    lua_report_error( L, err, scr.c_str() );

    //    luah_remove_from_registry(L, function_index); // todo: make use of this

    return err;
}
Exemplo n.º 5
0
// monstergroups = game.monstergroups(overmap)
static int game_monstergroups(lua_State *L) {
    overmap **userdata = (overmap**) lua_touserdata(L, 1);

    std::vector<mongroup>& mongroups = (*userdata)->zg;

    lua_createtable(L, mongroups.size(), 0); // Preallocate enough space for all our monster groups.

    // Iterate over the monster group list and insert each monster group into our returned table.
    for( size_t i = 0; i < mongroups.size(); ++i ) {
        // The stack will look like this:
        // 1 - t, table containing group
        // 2 - k, index at which the next group will be inserted
        // 3 - v, next group to insert
        //
        // lua_rawset then does t[k] = v and pops v and k from the stack

        lua_pushnumber(L, i + 1);
        mongroup** mongroup_userdata = (mongroup**) lua_newuserdata(L, sizeof(mongroup*));
        *mongroup_userdata = &(mongroups[i]);
        luah_setmetatable(L, "mongroup_metatable");
        lua_rawset(L, -3);
    }

    return 1; // 1 return values
}
Exemplo n.º 6
0
// mtype = game.monster_type(name)
static int game_monster_type(lua_State *L) {
    const char* parameter1 = (const char*) lua_tostring(L, 1);

    mtype** monster_type = (mtype**) lua_newuserdata(L, sizeof(mtype*));
    *monster_type = GetMType(parameter1);
    luah_setmetatable(L, "mtype_metatable");

    return 1; // 1 return values

}
Exemplo n.º 7
0
// monster = game.monster_at(x, y)
static int game_monster_at(lua_State *L) {
    int parameter1 = (int) lua_tonumber(L, 1);
    int parameter2 = (int) lua_tonumber(L, 2);
    int monster_idx = g->mon_at(parameter1, parameter2);

    monster& mon_ref = g->zombie(monster_idx);
    monster** monster_userdata = (monster**) lua_newuserdata(L, sizeof(monster*));
    *monster_userdata = &mon_ref;
    luah_setmetatable(L, "monster_metatable");

    return 1; // 1 return values
}
Exemplo n.º 8
0
void update_globals(lua_State *L) {
    // Make sure the player reference is up to date.
    {
        player** player_userdata = (player**) lua_newuserdata(L, sizeof(player*));
        *player_userdata = &g->u;

        // Set the metatable for the player.
        luah_setmetatable(L, "player_metatable");

        luah_setglobal(L, "player", -1);
    }

    // Make sure the map reference is up to date.
    {
        map** map_userdata = (map**) lua_newuserdata(L, sizeof(map*));
        *map_userdata = &g->m;

        // Set the metatable for the player.
        luah_setmetatable(L, "map_metatable");

        luah_setglobal(L, "map", -1);
    }
}
Exemplo n.º 9
0
// If we're not using lua, need to define Use_function in a way to always call the C++ function
int use_function::call(player* player_instance, item* item_instance, bool active) {
    if(function_type == USE_FUNCTION_CPP) {
        // If it's a C++ function, simply call it with the given arguments.
        iuse tmp;
        return (tmp.*cpp_function)(player_instance, item_instance, active);
    } else {
        #ifdef LUA

        // We'll be using lua_state a lot!
        lua_State* L = lua_state;

        // If it's a lua function, the arguments have to be wrapped in
        // lua userdata's and passed on the lua stack.
        // We will now call the function f(player, item, active)

        update_globals(L);

        // Push the lua function on top of the stack
        lua_rawgeti(L, LUA_REGISTRYINDEX, lua_function);

        // Push the item on top of the stack.
        int item_in_registry;
        {
            item** item_userdata = (item**) lua_newuserdata(L, sizeof(item*));
            *item_userdata = item_instance;

            // Save a reference to the item in the registry so that we can deallocate it
            // when we're done.
            item_in_registry = luah_store_in_registry(L, -1);

            // Set the metatable for the item.
            luah_setmetatable(L, "item_metatable");
        }

        // Push the "active" parameter on top of the stack.
        lua_pushboolean(L, active);

        // Call the iuse function
        int err = lua_pcall(L, 3, 1, 0);
        if(err) {
            // Error handling.
            const char* error = lua_tostring(L, -1);
            debugmsg("Error in lua iuse function: %s", error);
        }

        // Make sure the now outdated parameters we passed to lua aren't
        // being used anymore by setting a metatable that will error on
        // access.
        luah_remove_from_registry(L, item_in_registry);
        luah_setmetatable(L, "outdated_metatable");

        return lua_tointeger(L, -1);

        #else

        // If LUA isn't defined and for some reason we registered a lua function,
        // simply do nothing.
        return 0;

        #endif

    }
}
Exemplo n.º 10
0
// If we're not using lua, need to define Use_function in a way to always call the C++ function
int use_function::call(player *player_instance, item *item_instance, bool active, point pos) const
{
    if (function_type == USE_FUNCTION_NONE) {
        if (player_instance != NULL && player_instance->is_player()) {
            add_msg(_("You can't do anything interesting with your %s."), item_instance->tname().c_str());
        }
    } else if (function_type == USE_FUNCTION_CPP) {
        // If it's a C++ function, simply call it with the given arguments.
        iuse tmp;
        return (tmp.*cpp_function)(player_instance, item_instance, active, pos);
    } else if (function_type == USE_FUNCTION_ACTOR_PTR) {
        return actor_ptr->use(player_instance, item_instance, active, pos);
    } else {
#ifdef LUA

        // We'll be using lua_state a lot!
        lua_State *L = lua_state;

        // If it's a lua function, the arguments have to be wrapped in
        // lua userdata's and passed on the lua stack.
        // We will now call the function f(player, item, active)

        update_globals(L);

        // Push the lua function on top of the stack
        lua_rawgeti(L, LUA_REGISTRYINDEX, lua_function);

        // TODO: also pass the player object, because of NPCs and all
        //       I guess

        // Push the item on top of the stack.
        int item_in_registry;
        {
            item **item_userdata = (item **) lua_newuserdata(L, sizeof(item *));
            *item_userdata = item_instance;

            // Save a reference to the item in the registry so that we can deallocate it
            // when we're done.
            item_in_registry = luah_store_in_registry(L, -1);

            // Set the metatable for the item.
            luah_setmetatable(L, "item_metatable");
        }

        // Push the "active" parameter on top of the stack.
        lua_pushboolean(L, active);

        // Call the iuse function
        int err = lua_pcall(L, 2, 1, 0);
        lua_report_error( L, err, "iuse function" );

        // Make sure the now outdated parameters we passed to lua aren't
        // being used anymore by setting a metatable that will error on
        // access.
        luah_remove_from_registry(L, item_in_registry);
        luah_setmetatable(L, "outdated_metatable");

        return lua_tointeger(L, -1);

#else

        // If LUA isn't defined and for some reason we registered a lua function,
        // simply do nothing.
        return 0;

#endif

    }
    return 0;
}