src/script/lua_api/l_mapgen.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "lua_api/l_mapgen.h"
  21 #include "lua_api/l_internal.h"
  22 #include "lua_api/l_vmanip.h"
  23 #include "common/c_converter.h"
  24 #include "common/c_content.h"
  25 #include "cpp_api/s_security.h"
  26 #include "util/serialize.h"
  27 #include "server.h"
  28 #include "environment.h"
  29 #include "emerge.h"
  30 #include "mapgen/mg_biome.h"
  31 #include "mapgen/mg_ore.h"
  32 #include "mapgen/mg_decoration.h"
  33 #include "mapgen/mg_schematic.h"
  34 #include "mapgen/mapgen_v5.h"
  35 #include "mapgen/mapgen_v7.h"
  36 #include "filesys.h"
  37 #include "settings.h"
  38 #include "log.h"
  39
  40 struct EnumString ModApiMapgen::es_BiomeTerrainType[] =
  41 {
  42         {BIOMETYPE_NORMAL, "normal"},
  43         {0, NULL},
  44 };
  45
  46 struct EnumString ModApiMapgen::es_DecorationType[] =
  47 {
  48         {DECO_SIMPLE,    "simple"},
  49         {DECO_SCHEMATIC, "schematic"},
  50         {DECO_LSYSTEM,   "lsystem"},
  51         {0, NULL},
  52 };
  53
  54 struct EnumString ModApiMapgen::es_MapgenObject[] =
  55 {
  56         {MGOBJ_VMANIP,    "voxelmanip"},
  57         {MGOBJ_HEIGHTMAP, "heightmap"},
  58         {MGOBJ_BIOMEMAP,  "biomemap"},
  59         {MGOBJ_HEATMAP,   "heatmap"},
  60         {MGOBJ_HUMIDMAP,  "humiditymap"},
  61         {MGOBJ_GENNOTIFY, "gennotify"},
  62         {0, NULL},
  63 };
  64
  65 struct EnumString ModApiMapgen::es_OreType[] =
  66 {
  67         {ORE_SCATTER, "scatter"},
  68         {ORE_SHEET,   "sheet"},
  69         {ORE_PUFF,    "puff"},
  70         {ORE_BLOB,    "blob"},
  71         {ORE_VEIN,    "vein"},
  72         {ORE_STRATUM, "stratum"},
  73         {0, NULL},
  74 };
  75
  76 struct EnumString ModApiMapgen::es_Rotation[] =
  77 {
  78         {ROTATE_0,    "0"},
  79         {ROTATE_90,   "90"},
  80         {ROTATE_180,  "180"},
  81         {ROTATE_270,  "270"},
  82         {ROTATE_RAND, "random"},
  83         {0, NULL},
  84 };
  85
  86 struct EnumString ModApiMapgen::es_SchematicFormatType[] =
  87 {
  88         {SCHEM_FMT_HANDLE, "handle"},
  89         {SCHEM_FMT_MTS,    "mts"},
  90         {SCHEM_FMT_LUA,    "lua"},
  91         {0, NULL},
  92 };
  93
  94 ObjDef *get_objdef(lua_State *L, int index, const ObjDefManager *objmgr);
  95
  96 Biome *get_or_load_biome(lua_State *L, int index,
  97         BiomeManager *biomemgr);
  98 Biome *read_biome_def(lua_State *L, int index, const NodeDefManager *ndef);
  99 size_t get_biome_list(lua_State *L, int index,
 100         BiomeManager *biomemgr, std::unordered_set<biome_t> *biome_id_list);
 101
 102 Schematic *get_or_load_schematic(lua_State *L, int index,
 103         SchematicManager *schemmgr, StringMap *replace_names);
 104 Schematic *load_schematic(lua_State *L, int index, const NodeDefManager *ndef,
 105         StringMap *replace_names);
 106 Schematic *load_schematic_from_def(lua_State *L, int index,
 107         const NodeDefManager *ndef, StringMap *replace_names);
 108 bool read_schematic_def(lua_State *L, int index,
 109         Schematic *schem, std::vector<std::string> *names);
 110
 111 bool read_deco_simple(lua_State *L, DecoSimple *deco);
 112 bool read_deco_schematic(lua_State *L, SchematicManager *schemmgr, DecoSchematic *deco);
 113
 114
 115 ///////////////////////////////////////////////////////////////////////////////
 116
 117 ObjDef *get_objdef(lua_State *L, int index, const ObjDefManager *objmgr)
 118 {
 119         if (index < 0)
 120                 index = lua_gettop(L) + 1 + index;
 121
 122         // If a number, assume this is a handle to an object def
 123         if (lua_isnumber(L, index))
 124                 return objmgr->get(lua_tointeger(L, index));
 125
 126         // If a string, assume a name is given instead
 127         if (lua_isstring(L, index))
 128                 return objmgr->getByName(lua_tostring(L, index));
 129
 130         return NULL;
 131 }
 132
 133 ///////////////////////////////////////////////////////////////////////////////
 134
 135 Schematic *get_or_load_schematic(lua_State *L, int index,
 136         SchematicManager *schemmgr, StringMap *replace_names)
 137 {
 138         if (index < 0)
 139                 index = lua_gettop(L) + 1 + index;
 140
 141         Schematic *schem = (Schematic *)get_objdef(L, index, schemmgr);
 142         if (schem)
 143                 return schem;
 144
 145         schem = load_schematic(L, index, schemmgr->getNodeDef(),
 146                 replace_names);
 147         if (!schem)
 148                 return NULL;
 149
 150         if (schemmgr->add(schem) == OBJDEF_INVALID_HANDLE) {
 151                 delete schem;
 152                 return NULL;
 153         }
 154
 155         return schem;
 156 }
 157
 158
 159 Schematic *load_schematic(lua_State *L, int index, const NodeDefManager *ndef,
 160         StringMap *replace_names)
 161 {
 162         if (index < 0)
 163                 index = lua_gettop(L) + 1 + index;
 164
 165         Schematic *schem = NULL;
 166
 167         if (lua_istable(L, index)) {
 168                 schem = load_schematic_from_def(L, index, ndef,
 169                         replace_names);
 170                 if (!schem) {
 171                         delete schem;
 172                         return NULL;
 173                 }
 174         } else if (lua_isnumber(L, index)) {
 175                 return NULL;
 176         } else if (lua_isstring(L, index)) {
 177                 schem = SchematicManager::create(SCHEMATIC_NORMAL);
 178
 179                 std::string filepath = lua_tostring(L, index);
 180                 if (!fs::IsPathAbsolute(filepath))
 181                         filepath = ModApiBase::getCurrentModPath(L) + DIR_DELIM + filepath;
 182
 183                 if (!schem->loadSchematicFromFile(filepath, ndef,
 184                                 replace_names)) {
 185                         delete schem;
 186                         return NULL;
 187                 }
 188         }
 189
 190         return schem;
 191 }
 192
 193
 194 Schematic *load_schematic_from_def(lua_State *L, int index,
 195         const NodeDefManager *ndef, StringMap *replace_names)
 196 {
 197         Schematic *schem = SchematicManager::create(SCHEMATIC_NORMAL);
 198
 199         if (!read_schematic_def(L, index, schem, &schem->m_nodenames)) {
 200                 delete schem;
 201                 return NULL;
 202         }
 203
 204         size_t num_nodes = schem->m_nodenames.size();
 205
 206         schem->m_nnlistsizes.push_back(num_nodes);
 207
 208         if (replace_names) {
 209                 for (size_t i = 0; i != num_nodes; i++) {
 210                         StringMap::iterator it = replace_names->find(schem->m_nodenames[i]);
 211                         if (it != replace_names->end())
 212                                 schem->m_nodenames[i] = it->second;
 213                 }
 214         }
 215
 216         if (ndef)
 217                 ndef->pendNodeResolve(schem);
 218
 219         return schem;
 220 }
 221
 222
 223 bool read_schematic_def(lua_State *L, int index,
 224         Schematic *schem, std::vector<std::string> *names)
 225 {
 226         if (!lua_istable(L, index))
 227                 return false;
 228
 229         //// Get schematic size
 230         lua_getfield(L, index, "size");
 231         v3s16 size = check_v3s16(L, -1);
 232         lua_pop(L, 1);
 233
 234         schem->size = size;
 235
 236         //// Get schematic data
 237         lua_getfield(L, index, "data");
 238         luaL_checktype(L, -1, LUA_TTABLE);
 239
 240         u32 numnodes = size.X * size.Y * size.Z;
 241         schem->schemdata = new MapNode[numnodes];
 242
 243         size_t names_base = names->size();
 244         std::unordered_map<std::string, content_t> name_id_map;
 245
 246         u32 i = 0;
 247         for (lua_pushnil(L); lua_next(L, -2); i++, lua_pop(L, 1)) {
 248                 if (i >= numnodes)
 249                         continue;
 250
 251                 //// Read name
 252                 std::string name;
 253                 if (!getstringfield(L, -1, "name", name))
 254                         throw LuaError("Schematic data definition with missing name field");
 255
 256                 //// Read param1/prob
 257                 u8 param1;
 258                 if (!getintfield(L, -1, "param1", param1) &&
 259                         !getintfield(L, -1, "prob", param1))
 260                         param1 = MTSCHEM_PROB_ALWAYS_OLD;
 261
 262                 //// Read param2
 263                 u8 param2 = getintfield_default(L, -1, "param2", 0);
 264
 265                 //// Find or add new nodename-to-ID mapping
 266                 std::unordered_map<std::string, content_t>::iterator it = name_id_map.find(name);
 267                 content_t name_index;
 268                 if (it != name_id_map.end()) {
 269                         name_index = it->second;
 270                 } else {
 271                         name_index = names->size() - names_base;
 272                         name_id_map[name] = name_index;
 273                         names->push_back(name);
 274                 }
 275
 276                 //// Perform probability/force_place fixup on param1
 277                 param1 >>= 1;
 278                 if (getboolfield_default(L, -1, "force_place", false))
 279                         param1 |= MTSCHEM_FORCE_PLACE;
 280
 281                 //// Actually set the node in the schematic
 282                 schem->schemdata[i] = MapNode(name_index, param1, param2);
 283         }
 284
 285         if (i != numnodes) {
 286                 errorstream << "read_schematic_def: incorrect number of "
 287                         "nodes provided in raw schematic data (got " << i <<
 288                         ", expected " << numnodes << ")." << std::endl;
 289                 return false;
 290         }
 291
 292         //// Get Y-slice probability values (if present)
 293         schem->slice_probs = new u8[size.Y];
 294         for (i = 0; i != (u32) size.Y; i++)
 295                 schem->slice_probs[i] = MTSCHEM_PROB_ALWAYS;
 296
 297         lua_getfield(L, index, "yslice_prob");
 298         if (lua_istable(L, -1)) {
 299                 for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1)) {
 300                         u16 ypos;
 301                         if (!getintfield(L, -1, "ypos", ypos) || (ypos >= size.Y) ||
 302                                 !getintfield(L, -1, "prob", schem->slice_probs[ypos]))
 303                                 continue;
 304
 305                         schem->slice_probs[ypos] >>= 1;
 306                 }
 307         }
 308
 309         return true;
 310 }
 311
 312
 313 void read_schematic_replacements(lua_State *L, int index, StringMap *replace_names)
 314 {
 315         if (index < 0)
 316                 index = lua_gettop(L) + 1 + index;
 317
 318         lua_pushnil(L);
 319         while (lua_next(L, index)) {
 320                 std::string replace_from;
 321                 std::string replace_to;
 322
 323                 if (lua_istable(L, -1)) { // Old {{"x", "y"}, ...} format
 324                         lua_rawgeti(L, -1, 1);
 325                         if (!lua_isstring(L, -1))
 326                                 throw LuaError("schematics: replace_from field is not a string");
 327                         replace_from = lua_tostring(L, -1);
 328                         lua_pop(L, 1);
 329
 330                         lua_rawgeti(L, -1, 2);
 331                         if (!lua_isstring(L, -1))
 332                                 throw LuaError("schematics: replace_to field is not a string");
 333                         replace_to = lua_tostring(L, -1);
 334                         lua_pop(L, 1);
 335                 } else { // New {x = "y", ...} format
 336                         if (!lua_isstring(L, -2))
 337                                 throw LuaError("schematics: replace_from field is not a string");
 338                         replace_from = lua_tostring(L, -2);
 339                         if (!lua_isstring(L, -1))
 340                                 throw LuaError("schematics: replace_to field is not a string");
 341                         replace_to = lua_tostring(L, -1);
 342                 }
 343
 344                 replace_names->insert(std::make_pair(replace_from, replace_to));
 345                 lua_pop(L, 1);
 346         }
 347 }
 348
 349 ///////////////////////////////////////////////////////////////////////////////
 350
 351 Biome *get_or_load_biome(lua_State *L, int index, BiomeManager *biomemgr)
 352 {
 353         if (index < 0)
 354                 index = lua_gettop(L) + 1 + index;
 355
 356         Biome *biome = (Biome *)get_objdef(L, index, biomemgr);
 357         if (biome)
 358                 return biome;
 359
 360         biome = read_biome_def(L, index, biomemgr->getNodeDef());
 361         if (!biome)
 362                 return NULL;
 363
 364         if (biomemgr->add(biome) == OBJDEF_INVALID_HANDLE) {
 365                 delete biome;
 366                 return NULL;
 367         }
 368
 369         return biome;
 370 }
 371
 372
 373 Biome *read_biome_def(lua_State *L, int index, const NodeDefManager *ndef)
 374 {
 375         if (!lua_istable(L, index))
 376                 return NULL;
 377
 378         BiomeType biometype = (BiomeType)getenumfield(L, index, "type",
 379                 ModApiMapgen::es_BiomeTerrainType, BIOMETYPE_NORMAL);
 380         Biome *b = BiomeManager::create(biometype);
 381
 382         b->name            = getstringfield_default(L, index, "name", "");
 383         b->depth_top       = getintfield_default(L,    index, "depth_top",       0);
 384         b->depth_filler    = getintfield_default(L,    index, "depth_filler",    -31000);
 385         b->depth_water_top = getintfield_default(L,    index, "depth_water_top", 0);
 386         b->depth_riverbed  = getintfield_default(L,    index, "depth_riverbed",  0);
 387         b->heat_point      = getfloatfield_default(L,  index, "heat_point",      0.f);
 388         b->humidity_point  = getfloatfield_default(L,  index, "humidity_point",  0.f);
 389         b->vertical_blend  = getintfield_default(L,    index, "vertical_blend",  0);
 390         b->flags           = 0; // reserved
 391
 392         b->min_pos = getv3s16field_default(
 393                 L, index, "min_pos", v3s16(-31000, -31000, -31000));
 394         getintfield(L, index, "y_min", b->min_pos.Y);
 395         b->max_pos = getv3s16field_default(
 396                 L, index, "max_pos", v3s16(31000, 31000, 31000));
 397         getintfield(L, index, "y_max", b->max_pos.Y);
 398
 399         std::vector<std::string> &nn = b->m_nodenames;
 400         nn.push_back(getstringfield_default(L, index, "node_top",           ""));
 401         nn.push_back(getstringfield_default(L, index, "node_filler",        ""));
 402         nn.push_back(getstringfield_default(L, index, "node_stone",         ""));
 403         nn.push_back(getstringfield_default(L, index, "node_water_top",     ""));
 404         nn.push_back(getstringfield_default(L, index, "node_water",         ""));
 405         nn.push_back(getstringfield_default(L, index, "node_river_water",   ""));
 406         nn.push_back(getstringfield_default(L, index, "node_riverbed",      ""));
 407         nn.push_back(getstringfield_default(L, index, "node_dust",          ""));
 408
 409         size_t nnames = getstringlistfield(L, index, "node_cave_liquid", &nn);
 410         // If no cave liquids defined, set list to "ignore" to trigger old hardcoded
 411         // cave liquid behaviour.
 412         if (nnames == 0) {
 413                 nn.emplace_back("ignore");
 414                 nnames = 1;
 415         }
 416         b->m_nnlistsizes.push_back(nnames);
 417
 418         nn.push_back(getstringfield_default(L, index, "node_dungeon",       ""));
 419         nn.push_back(getstringfield_default(L, index, "node_dungeon_alt",   ""));
 420         nn.push_back(getstringfield_default(L, index, "node_dungeon_stair", ""));
 421         ndef->pendNodeResolve(b);
 422
 423         return b;
 424 }
 425
 426
 427 size_t get_biome_list(lua_State *L, int index,
 428         BiomeManager *biomemgr, std::unordered_set<biome_t> *biome_id_list)
 429 {
 430         if (index < 0)
 431                 index = lua_gettop(L) + 1 + index;
 432
 433         if (lua_isnil(L, index))
 434                 return 0;
 435
 436         bool is_single = true;
 437         if (lua_istable(L, index)) {
 438                 lua_getfield(L, index, "name");
 439                 is_single = !lua_isnil(L, -1);
 440                 lua_pop(L, 1);
 441         }
 442
 443         if (is_single) {
 444                 Biome *biome = get_or_load_biome(L, index, biomemgr);
 445                 if (!biome) {
 446                         infostream << "get_biome_list: failed to get biome '"
 447                                 << (lua_isstring(L, index) ? lua_tostring(L, index) : "")
 448                                 << "'." << std::endl;
 449                         return 1;
 450                 }
 451
 452                 biome_id_list->insert(biome->index);
 453                 return 0;
 454         }
 455
 456         // returns number of failed resolutions
 457         size_t fail_count = 0;
 458         size_t count = 0;
 459
 460         for (lua_pushnil(L); lua_next(L, index); lua_pop(L, 1)) {
 461                 count++;
 462                 Biome *biome = get_or_load_biome(L, -1, biomemgr);
 463                 if (!biome) {
 464                         fail_count++;
 465                         infostream << "get_biome_list: failed to get biome '"
 466                                 << (lua_isstring(L, -1) ? lua_tostring(L, -1) : "")
 467                                 << "'" << std::endl;
 468                         continue;
 469                 }
 470
 471                 biome_id_list->insert(biome->index);
 472         }
 473
 474         return fail_count;
 475 }
 476
 477 ///////////////////////////////////////////////////////////////////////////////
 478
 479 // get_biome_id(biomename)
 480 // returns the biome id as used in biomemap and returned by 'get_biome_data()'
 481 int ModApiMapgen::l_get_biome_id(lua_State *L)
 482 {
 483         NO_MAP_LOCK_REQUIRED;
 484
 485         const char *biome_str = lua_tostring(L, 1);
 486         if (!biome_str)
 487                 return 0;
 488
 489         const BiomeManager *bmgr = getServer(L)->getEmergeManager()->getBiomeManager();
 490         if (!bmgr)
 491                 return 0;
 492
 493         const Biome *biome = (Biome *)bmgr->getByName(biome_str);
 494         if (!biome || biome->index == OBJDEF_INVALID_INDEX)
 495                 return 0;
 496
 497         lua_pushinteger(L, biome->index);
 498
 499         return 1;
 500 }
 501
 502
 503 // get_biome_name(biome_id)
 504 // returns the biome name string
 505 int ModApiMapgen::l_get_biome_name(lua_State *L)
 506 {
 507         NO_MAP_LOCK_REQUIRED;
 508
 509         int biome_id = luaL_checkinteger(L, 1);
 510
 511         const BiomeManager *bmgr = getServer(L)->getEmergeManager()->getBiomeManager();
 512         if (!bmgr)
 513                 return 0;
 514
 515         const Biome *b = (Biome *)bmgr->getRaw(biome_id);
 516         lua_pushstring(L, b->name.c_str());
 517
 518         return 1;
 519 }
 520
 521
 522 // get_heat(pos)
 523 // returns the heat at the position
 524 int ModApiMapgen::l_get_heat(lua_State *L)
 525 {
 526         NO_MAP_LOCK_REQUIRED;
 527
 528         v3s16 pos = read_v3s16(L, 1);
 529
 530         NoiseParams np_heat;
 531         NoiseParams np_heat_blend;
 532
 533         MapSettingsManager *settingsmgr =
 534                 getServer(L)->getEmergeManager()->map_settings_mgr;
 535
 536         if (!settingsmgr->getMapSettingNoiseParams("mg_biome_np_heat",
 537                         &np_heat) ||
 538                         !settingsmgr->getMapSettingNoiseParams("mg_biome_np_heat_blend",
 539                         &np_heat_blend))
 540                 return 0;
 541
 542         std::string value;
 543         if (!settingsmgr->getMapSetting("seed", &value))
 544                 return 0;
 545         std::istringstream ss(value);
 546         u64 seed;
 547         ss >> seed;
 548
 549         const BiomeManager *bmgr = getServer(L)->getEmergeManager()->getBiomeManager();
 550         if (!bmgr)
 551                 return 0;
 552
 553         float heat = bmgr->getHeatAtPosOriginal(pos, np_heat, np_heat_blend, seed);
 554
 555         lua_pushnumber(L, heat);
 556
 557         return 1;
 558 }
 559
 560
 561 // get_humidity(pos)
 562 // returns the humidity at the position
 563 int ModApiMapgen::l_get_humidity(lua_State *L)
 564 {
 565         NO_MAP_LOCK_REQUIRED;
 566
 567         v3s16 pos = read_v3s16(L, 1);
 568
 569         NoiseParams np_humidity;
 570         NoiseParams np_humidity_blend;
 571
 572         MapSettingsManager *settingsmgr =
 573                 getServer(L)->getEmergeManager()->map_settings_mgr;
 574
 575         if (!settingsmgr->getMapSettingNoiseParams("mg_biome_np_humidity",
 576                         &np_humidity) ||
 577                         !settingsmgr->getMapSettingNoiseParams("mg_biome_np_humidity_blend",
 578                         &np_humidity_blend))
 579                 return 0;
 580
 581         std::string value;
 582         if (!settingsmgr->getMapSetting("seed", &value))
 583                 return 0;
 584         std::istringstream ss(value);
 585         u64 seed;
 586         ss >> seed;
 587
 588         const BiomeManager *bmgr = getServer(L)->getEmergeManager()->getBiomeManager();
 589         if (!bmgr)
 590                 return 0;
 591
 592         float humidity = bmgr->getHumidityAtPosOriginal(pos, np_humidity,
 593                 np_humidity_blend, seed);
 594
 595         lua_pushnumber(L, humidity);
 596
 597         return 1;
 598 }
 599
 600
 601 // get_biome_data(pos)
 602 // returns a table containing the biome id, heat and humidity at the position
 603 int ModApiMapgen::l_get_biome_data(lua_State *L)
 604 {
 605         NO_MAP_LOCK_REQUIRED;
 606
 607         v3s16 pos = read_v3s16(L, 1);
 608
 609         NoiseParams np_heat;
 610         NoiseParams np_heat_blend;
 611         NoiseParams np_humidity;
 612         NoiseParams np_humidity_blend;
 613
 614         MapSettingsManager *settingsmgr =
 615                 getServer(L)->getEmergeManager()->map_settings_mgr;
 616
 617         if (!settingsmgr->getMapSettingNoiseParams("mg_biome_np_heat",
 618                         &np_heat) ||
 619                         !settingsmgr->getMapSettingNoiseParams("mg_biome_np_heat_blend",
 620                         &np_heat_blend) ||
 621                         !settingsmgr->getMapSettingNoiseParams("mg_biome_np_humidity",
 622                         &np_humidity) ||
 623                         !settingsmgr->getMapSettingNoiseParams("mg_biome_np_humidity_blend",
 624                         &np_humidity_blend))
 625                 return 0;
 626
 627         std::string value;
 628         if (!settingsmgr->getMapSetting("seed", &value))
 629                 return 0;
 630         std::istringstream ss(value);
 631         u64 seed;
 632         ss >> seed;
 633
 634         const BiomeManager *bmgr = getServer(L)->getEmergeManager()->getBiomeManager();
 635         if (!bmgr)
 636                 return 0;
 637
 638         float heat = bmgr->getHeatAtPosOriginal(pos, np_heat, np_heat_blend, seed);
 639         if (!heat)
 640                 return 0;
 641
 642         float humidity = bmgr->getHumidityAtPosOriginal(pos, np_humidity,
 643                 np_humidity_blend, seed);
 644         if (!humidity)
 645                 return 0;
 646
 647         const Biome *biome = bmgr->getBiomeFromNoiseOriginal(heat, humidity, pos);
 648         if (!biome || biome->index == OBJDEF_INVALID_INDEX)
 649                 return 0;
 650
 651         lua_newtable(L);
 652
 653         lua_pushinteger(L, biome->index);
 654         lua_setfield(L, -2, "biome");
 655
 656         lua_pushnumber(L, heat);
 657         lua_setfield(L, -2, "heat");
 658
 659         lua_pushnumber(L, humidity);
 660         lua_setfield(L, -2, "humidity");
 661
 662         return 1;
 663 }
 664
 665
 666 // get_mapgen_object(objectname)
 667 // returns the requested object used during map generation
 668 int ModApiMapgen::l_get_mapgen_object(lua_State *L)
 669 {
 670         NO_MAP_LOCK_REQUIRED;
 671
 672         const char *mgobjstr = lua_tostring(L, 1);
 673
 674         int mgobjint;
 675         if (!string_to_enum(es_MapgenObject, mgobjint, mgobjstr ? mgobjstr : ""))
 676                 return 0;
 677
 678         enum MapgenObject mgobj = (MapgenObject)mgobjint;
 679
 680         EmergeManager *emerge = getServer(L)->getEmergeManager();
 681         Mapgen *mg = emerge->getCurrentMapgen();
 682         if (!mg)
 683                 throw LuaError("Must only be called in a mapgen thread!");
 684
 685         size_t maplen = mg->csize.X * mg->csize.Z;
 686
 687         switch (mgobj) {
 688         case MGOBJ_VMANIP: {
 689                 MMVManip *vm = mg->vm;
 690
 691                 // VoxelManip object
 692                 LuaVoxelManip *o = new LuaVoxelManip(vm, true);
 693                 *(void **)(lua_newuserdata(L, sizeof(void *))) = o;
 694                 luaL_getmetatable(L, "VoxelManip");
 695                 lua_setmetatable(L, -2);
 696
 697                 // emerged min pos
 698                 push_v3s16(L, vm->m_area.MinEdge);
 699
 700                 // emerged max pos
 701                 push_v3s16(L, vm->m_area.MaxEdge);
 702
 703                 return 3;
 704         }
 705         case MGOBJ_HEIGHTMAP: {
 706                 if (!mg->heightmap)
 707                         return 0;
 708
 709                 lua_createtable(L, maplen, 0);
 710                 for (size_t i = 0; i != maplen; i++) {
 711                         lua_pushinteger(L, mg->heightmap[i]);
 712                         lua_rawseti(L, -2, i + 1);
 713                 }
 714
 715                 return 1;
 716         }
 717         case MGOBJ_BIOMEMAP: {
 718                 if (!mg->biomegen)
 719                         return 0;
 720
 721                 lua_createtable(L, maplen, 0);
 722                 for (size_t i = 0; i != maplen; i++) {
 723                         lua_pushinteger(L, mg->biomegen->biomemap[i]);
 724                         lua_rawseti(L, -2, i + 1);
 725                 }
 726
 727                 return 1;
 728         }
 729         case MGOBJ_HEATMAP: {
 730                 if (!mg->biomegen || mg->biomegen->getType() != BIOMEGEN_ORIGINAL)
 731                         return 0;
 732
 733                 BiomeGenOriginal *bg = (BiomeGenOriginal *)mg->biomegen;
 734
 735                 lua_createtable(L, maplen, 0);
 736                 for (size_t i = 0; i != maplen; i++) {
 737                         lua_pushnumber(L, bg->heatmap[i]);
 738                         lua_rawseti(L, -2, i + 1);
 739                 }
 740
 741                 return 1;
 742         }
 743
 744         case MGOBJ_HUMIDMAP: {
 745                 if (!mg->biomegen || mg->biomegen->getType() != BIOMEGEN_ORIGINAL)
 746                         return 0;
 747
 748                 BiomeGenOriginal *bg = (BiomeGenOriginal *)mg->biomegen;
 749
 750                 lua_createtable(L, maplen, 0);
 751                 for (size_t i = 0; i != maplen; i++) {
 752                         lua_pushnumber(L, bg->humidmap[i]);
 753                         lua_rawseti(L, -2, i + 1);
 754                 }
 755
 756                 return 1;
 757         }
 758         case MGOBJ_GENNOTIFY: {
 759                 std::map<std::string, std::vector<v3s16> >event_map;
 760
 761                 mg->gennotify.getEvents(event_map);
 762
 763                 lua_createtable(L, 0, event_map.size());
 764                 for (auto it = event_map.begin(); it != event_map.end(); ++it) {
 765                         lua_createtable(L, it->second.size(), 0);
 766
 767                         for (size_t j = 0; j != it->second.size(); j++) {
 768                                 push_v3s16(L, it->second[j]);
 769                                 lua_rawseti(L, -2, j + 1);
 770                         }
 771
 772                         lua_setfield(L, -2, it->first.c_str());
 773                 }
 774
 775                 return 1;
 776         }
 777         }
 778
 779         return 0;
 780 }
 781
 782
 783 // get_spawn_level(x = num, z = num)
 784 int ModApiMapgen::l_get_spawn_level(lua_State *L)
 785 {
 786         NO_MAP_LOCK_REQUIRED;
 787
 788         s16 x = luaL_checkinteger(L, 1);
 789         s16 z = luaL_checkinteger(L, 2);
 790
 791         EmergeManager *emerge = getServer(L)->getEmergeManager();
 792         int spawn_level = emerge->getSpawnLevelAtPoint(v2s16(x, z));
 793         // Unsuitable spawn point
 794         if (spawn_level == MAX_MAP_GENERATION_LIMIT)
 795                 return 0;
 796
 797         // 'findSpawnPos()' in server.cpp adds at least 1
 798         lua_pushinteger(L, spawn_level + 1);
 799
 800         return 1;
 801 }
 802
 803
 804 int ModApiMapgen::l_get_mapgen_params(lua_State *L)
 805 {
 806         NO_MAP_LOCK_REQUIRED;
 807
 808         log_deprecated(L, "get_mapgen_params is deprecated; "
 809                 "use get_mapgen_setting instead");
 810
 811         std::string value;
 812
 813         MapSettingsManager *settingsmgr =
 814                 getServer(L)->getEmergeManager()->map_settings_mgr;
 815
 816         lua_newtable(L);
 817
 818         settingsmgr->getMapSetting("mg_name", &value);
 819         lua_pushstring(L, value.c_str());
 820         lua_setfield(L, -2, "mgname");
 821
 822         settingsmgr->getMapSetting("seed", &value);
 823         std::istringstream ss(value);
 824         u64 seed;
 825         ss >> seed;
 826         lua_pushinteger(L, seed);
 827         lua_setfield(L, -2, "seed");
 828
 829         settingsmgr->getMapSetting("water_level", &value);
 830         lua_pushinteger(L, stoi(value, -32768, 32767));
 831         lua_setfield(L, -2, "water_level");
 832
 833         settingsmgr->getMapSetting("chunksize", &value);
 834         lua_pushinteger(L, stoi(value, -32768, 32767));
 835         lua_setfield(L, -2, "chunksize");
 836
 837         settingsmgr->getMapSetting("mg_flags", &value);
 838         lua_pushstring(L, value.c_str());
 839         lua_setfield(L, -2, "flags");
 840
 841         return 1;
 842 }
 843
 844
 845 // set_mapgen_params(params)
 846 // set mapgen parameters
 847 int ModApiMapgen::l_set_mapgen_params(lua_State *L)
 848 {
 849         NO_MAP_LOCK_REQUIRED;
 850
 851         log_deprecated(L, "set_mapgen_params is deprecated; "
 852                 "use set_mapgen_setting instead");
 853
 854         if (!lua_istable(L, 1))
 855                 return 0;
 856
 857         MapSettingsManager *settingsmgr =
 858                 getServer(L)->getEmergeManager()->map_settings_mgr;
 859
 860         lua_getfield(L, 1, "mgname");
 861         if (lua_isstring(L, -1))
 862                 settingsmgr->setMapSetting("mg_name", readParam<std::string>(L, -1), true);
 863
 864         lua_getfield(L, 1, "seed");
 865         if (lua_isnumber(L, -1))
 866                 settingsmgr->setMapSetting("seed", readParam<std::string>(L, -1), true);
 867
 868         lua_getfield(L, 1, "water_level");
 869         if (lua_isnumber(L, -1))
 870                 settingsmgr->setMapSetting("water_level", readParam<std::string>(L, -1), true);
 871
 872         lua_getfield(L, 1, "chunksize");
 873         if (lua_isnumber(L, -1))
 874                 settingsmgr->setMapSetting("chunksize", readParam<std::string>(L, -1), true);
 875
 876         warn_if_field_exists(L, 1, "flagmask",
 877                 "Obsolete: flags field now includes unset flags.");
 878
 879         lua_getfield(L, 1, "flags");
 880         if (lua_isstring(L, -1))
 881                 settingsmgr->setMapSetting("mg_flags", readParam<std::string>(L, -1), true);
 882
 883         return 0;
 884 }
 885
 886 // get_mapgen_setting(name)
 887 int ModApiMapgen::l_get_mapgen_setting(lua_State *L)
 888 {
 889         NO_MAP_LOCK_REQUIRED;
 890
 891         std::string value;
 892         MapSettingsManager *settingsmgr =
 893                 getServer(L)->getEmergeManager()->map_settings_mgr;
 894
 895         const char *name = luaL_checkstring(L, 1);
 896         if (!settingsmgr->getMapSetting(name, &value))
 897                 return 0;
 898
 899         lua_pushstring(L, value.c_str());
 900         return 1;
 901 }
 902
 903 // get_mapgen_setting_noiseparams(name)
 904 int ModApiMapgen::l_get_mapgen_setting_noiseparams(lua_State *L)
 905 {
 906         NO_MAP_LOCK_REQUIRED;
 907
 908         NoiseParams np;
 909         MapSettingsManager *settingsmgr =
 910                 getServer(L)->getEmergeManager()->map_settings_mgr;
 911
 912         const char *name = luaL_checkstring(L, 1);
 913         if (!settingsmgr->getMapSettingNoiseParams(name, &np))
 914                 return 0;
 915
 916         push_noiseparams(L, &np);
 917         return 1;
 918 }
 919
 920 // set_mapgen_setting(name, value, override_meta)
 921 // set mapgen config values
 922 int ModApiMapgen::l_set_mapgen_setting(lua_State *L)
 923 {
 924         NO_MAP_LOCK_REQUIRED;
 925
 926         MapSettingsManager *settingsmgr =
 927                 getServer(L)->getEmergeManager()->map_settings_mgr;
 928
 929         const char *name   = luaL_checkstring(L, 1);
 930         const char *value  = luaL_checkstring(L, 2);
 931         bool override_meta = readParam<bool>(L, 3, false);
 932
 933         if (!settingsmgr->setMapSetting(name, value, override_meta)) {
 934                 errorstream << "set_mapgen_setting: cannot set '"
 935                         << name << "' after initialization" << std::endl;
 936         }
 937
 938         return 0;
 939 }
 940
 941
 942 // set_mapgen_setting_noiseparams(name, noiseparams, set_default)
 943 // set mapgen config values for noise parameters
 944 int ModApiMapgen::l_set_mapgen_setting_noiseparams(lua_State *L)
 945 {
 946         NO_MAP_LOCK_REQUIRED;
 947
 948         MapSettingsManager *settingsmgr =
 949                 getServer(L)->getEmergeManager()->map_settings_mgr;
 950
 951         const char *name = luaL_checkstring(L, 1);
 952
 953         NoiseParams np;
 954         if (!read_noiseparams(L, 2, &np)) {
 955                 errorstream << "set_mapgen_setting_noiseparams: cannot set '" << name
 956                         << "'; invalid noiseparams table" << std::endl;
 957                 return 0;
 958         }
 959
 960         bool override_meta = readParam<bool>(L, 3, false);
 961
 962         if (!settingsmgr->setMapSettingNoiseParams(name, &np, override_meta)) {
 963                 errorstream << "set_mapgen_setting_noiseparams: cannot set '"
 964                         << name << "' after initialization" << std::endl;
 965         }
 966
 967         return 0;
 968 }
 969
 970
 971 // set_noiseparams(name, noiseparams, set_default)
 972 // set global config values for noise parameters
 973 int ModApiMapgen::l_set_noiseparams(lua_State *L)
 974 {
 975         NO_MAP_LOCK_REQUIRED;
 976
 977         const char *name = luaL_checkstring(L, 1);
 978
 979         NoiseParams np;
 980         if (!read_noiseparams(L, 2, &np)) {
 981                 errorstream << "set_noiseparams: cannot set '" << name
 982                         << "'; invalid noiseparams table" << std::endl;
 983                 return 0;
 984         }
 985
 986         bool set_default = !lua_isboolean(L, 3) || readParam<bool>(L, 3);
 987
 988         g_settings->setNoiseParams(name, np, set_default);
 989
 990         return 0;
 991 }
 992
 993
 994 // get_noiseparams(name)
 995 int ModApiMapgen::l_get_noiseparams(lua_State *L)
 996 {
 997         NO_MAP_LOCK_REQUIRED;
 998
 999         std::string name = luaL_checkstring(L, 1);
1000
1001         NoiseParams np;
1002         if (!g_settings->getNoiseParams(name, np))
1003                 return 0;
1004
1005         push_noiseparams(L, &np);
1006         return 1;
1007 }
1008
1009
1010 // set_gen_notify(flags, {deco_id_table})
1011 int ModApiMapgen::l_set_gen_notify(lua_State *L)
1012 {
1013         NO_MAP_LOCK_REQUIRED;
1014
1015         u32 flags = 0, flagmask = 0;
1016         EmergeManager *emerge = getServer(L)->getEmergeManager();
1017
1018         if (read_flags(L, 1, flagdesc_gennotify, &flags, &flagmask)) {
1019                 emerge->gen_notify_on &= ~flagmask;
1020                 emerge->gen_notify_on |= flags;
1021         }
1022
1023         if (lua_istable(L, 2)) {
1024                 lua_pushnil(L);
1025                 while (lua_next(L, 2)) {
1026                         if (lua_isnumber(L, -1))
1027                                 emerge->gen_notify_on_deco_ids.insert((u32)lua_tonumber(L, -1));
1028                         lua_pop(L, 1);
1029                 }
1030         }
1031
1032         return 0;
1033 }
1034
1035
1036 // get_gen_notify()
1037 int ModApiMapgen::l_get_gen_notify(lua_State *L)
1038 {
1039         NO_MAP_LOCK_REQUIRED;
1040
1041         EmergeManager *emerge = getServer(L)->getEmergeManager();
1042         push_flags_string(L, flagdesc_gennotify, emerge->gen_notify_on,
1043                 emerge->gen_notify_on);
1044
1045         lua_newtable(L);
1046         int i = 1;
1047         for (u32 gen_notify_on_deco_id : emerge->gen_notify_on_deco_ids) {
1048                 lua_pushnumber(L, gen_notify_on_deco_id);
1049                 lua_rawseti(L, -2, i++);
1050         }
1051         return 2;
1052 }
1053
1054
1055 // get_decoration_id(decoration_name)
1056 // returns the decoration ID as used in gennotify
1057 int ModApiMapgen::l_get_decoration_id(lua_State *L)
1058 {
1059         NO_MAP_LOCK_REQUIRED;
1060
1061         const char *deco_str = luaL_checkstring(L, 1);
1062         if (!deco_str)
1063                 return 0;
1064
1065         const DecorationManager *dmgr =
1066                 getServer(L)->getEmergeManager()->getDecorationManager();
1067
1068         if (!dmgr)
1069                 return 0;
1070
1071         Decoration *deco = (Decoration *)dmgr->getByName(deco_str);
1072
1073         if (!deco)
1074                 return 0;
1075
1076         lua_pushinteger(L, deco->index);
1077
1078         return 1;
1079 }
1080
1081
1082 // register_biome({lots of stuff})
1083 int ModApiMapgen::l_register_biome(lua_State *L)
1084 {
1085         NO_MAP_LOCK_REQUIRED;
1086
1087         int index = 1;
1088         luaL_checktype(L, index, LUA_TTABLE);
1089
1090         const NodeDefManager *ndef = getServer(L)->getNodeDefManager();
1091         BiomeManager *bmgr = getServer(L)->getEmergeManager()->getWritableBiomeManager();
1092
1093         Biome *biome = read_biome_def(L, index, ndef);
1094         if (!biome)
1095                 return 0;
1096
1097         ObjDefHandle handle = bmgr->add(biome);
1098         if (handle == OBJDEF_INVALID_HANDLE) {
1099                 delete biome;
1100                 return 0;
1101         }
1102
1103         lua_pushinteger(L, handle);
1104         return 1;
1105 }
1106
1107
1108 // register_decoration({lots of stuff})
1109 int ModApiMapgen::l_register_decoration(lua_State *L)
1110 {
1111         NO_MAP_LOCK_REQUIRED;
1112
1113         int index = 1;
1114         luaL_checktype(L, index, LUA_TTABLE);
1115
1116         const NodeDefManager *ndef      = getServer(L)->getNodeDefManager();
1117         EmergeManager *emerge = getServer(L)->getEmergeManager();
1118         DecorationManager *decomgr = emerge->getWritableDecorationManager();
1119         BiomeManager *biomemgr     = emerge->getWritableBiomeManager();
1120         SchematicManager *schemmgr = emerge->getWritableSchematicManager();
1121
1122         enum DecorationType decotype = (DecorationType)getenumfield(L, index,
1123                                 "deco_type", es_DecorationType, -1);
1124
1125         Decoration *deco = decomgr->create(decotype);
1126         if (!deco) {
1127                 errorstream << "register_decoration: decoration placement type "
1128                         << decotype << " not implemented" << std::endl;
1129                 return 0;
1130         }
1131
1132         deco->name           = getstringfield_default(L, index, "name", "");
1133         deco->fill_ratio     = getfloatfield_default(L, index, "fill_ratio", 0.02);
1134         deco->y_min          = getintfield_default(L, index, "y_min", -31000);
1135         deco->y_max          = getintfield_default(L, index, "y_max", 31000);
1136         deco->nspawnby       = getintfield_default(L, index, "num_spawn_by", -1);
1137         deco->place_offset_y = getintfield_default(L, index, "place_offset_y", 0);
1138         deco->sidelen        = getintfield_default(L, index, "sidelen", 8);
1139         if (deco->sidelen <= 0) {
1140                 errorstream << "register_decoration: sidelen must be "
1141                         "greater than 0" << std::endl;
1142                 delete deco;
1143                 return 0;
1144         }
1145
1146         //// Get node name(s) to place decoration on
1147         size_t nread = getstringlistfield(L, index, "place_on", &deco->m_nodenames);
1148         deco->m_nnlistsizes.push_back(nread);
1149
1150         //// Get decoration flags
1151         getflagsfield(L, index, "flags", flagdesc_deco, &deco->flags, NULL);
1152
1153         //// Get NoiseParams to define how decoration is placed
1154         lua_getfield(L, index, "noise_params");
1155         if (read_noiseparams(L, -1, &deco->np))
1156                 deco->flags |= DECO_USE_NOISE;
1157         lua_pop(L, 1);
1158
1159         //// Get biomes associated with this decoration (if any)
1160         lua_getfield(L, index, "biomes");
1161         if (get_biome_list(L, -1, biomemgr, &deco->biomes))
1162                 infostream << "register_decoration: couldn't get all biomes " << std::endl;
1163         lua_pop(L, 1);
1164
1165         //// Get node name(s) to 'spawn by'
1166         size_t nnames = getstringlistfield(L, index, "spawn_by", &deco->m_nodenames);
1167         deco->m_nnlistsizes.push_back(nnames);
1168         if (nnames == 0 && deco->nspawnby != -1) {
1169                 errorstream << "register_decoration: no spawn_by nodes defined,"
1170                         " but num_spawn_by specified" << std::endl;
1171         }
1172
1173         //// Handle decoration type-specific parameters
1174         bool success = false;
1175         switch (decotype) {
1176         case DECO_SIMPLE:
1177                 success = read_deco_simple(L, (DecoSimple *)deco);
1178                 break;
1179         case DECO_SCHEMATIC:
1180                 success = read_deco_schematic(L, schemmgr, (DecoSchematic *)deco);
1181                 break;
1182         case DECO_LSYSTEM:
1183                 break;
1184         }
1185
1186         if (!success) {
1187                 delete deco;
1188                 return 0;
1189         }
1190
1191         ndef->pendNodeResolve(deco);
1192
1193         ObjDefHandle handle = decomgr->add(deco);
1194         if (handle == OBJDEF_INVALID_HANDLE) {
1195                 delete deco;
1196                 return 0;
1197         }
1198
1199         lua_pushinteger(L, handle);
1200         return 1;
1201 }
1202
1203
1204 bool read_deco_simple(lua_State *L, DecoSimple *deco)
1205 {
1206         int index = 1;
1207         int param2;
1208         int param2_max;
1209
1210         deco->deco_height     = getintfield_default(L, index, "height", 1);
1211         deco->deco_height_max = getintfield_default(L, index, "height_max", 0);
1212
1213         if (deco->deco_height <= 0) {
1214                 errorstream << "register_decoration: simple decoration height"
1215                         " must be greater than 0" << std::endl;
1216                 return false;
1217         }
1218
1219         size_t nnames = getstringlistfield(L, index, "decoration", &deco->m_nodenames);
1220         deco->m_nnlistsizes.push_back(nnames);
1221
1222         if (nnames == 0) {
1223                 errorstream << "register_decoration: no decoration nodes "
1224                         "defined" << std::endl;
1225                 return false;
1226         }
1227
1228         param2 = getintfield_default(L, index, "param2", 0);
1229         param2_max = getintfield_default(L, index, "param2_max", 0);
1230
1231         if (param2 < 0 || param2 > 255 || param2_max < 0 || param2_max > 255) {
1232                 errorstream << "register_decoration: param2 or param2_max out of bounds (0-255)"
1233                         << std::endl;
1234                 return false;
1235         }
1236
1237         deco->deco_param2 = (u8)param2;
1238         deco->deco_param2_max = (u8)param2_max;
1239
1240         return true;
1241 }
1242
1243
1244 bool read_deco_schematic(lua_State *L, SchematicManager *schemmgr, DecoSchematic *deco)
1245 {
1246         int index = 1;
1247
1248         deco->rotation = (Rotation)getenumfield(L, index, "rotation",
1249                 ModApiMapgen::es_Rotation, ROTATE_0);
1250
1251         StringMap replace_names;
1252         lua_getfield(L, index, "replacements");
1253         if (lua_istable(L, -1))
1254                 read_schematic_replacements(L, -1, &replace_names);
1255         lua_pop(L, 1);
1256
1257         lua_getfield(L, index, "schematic");
1258         Schematic *schem = get_or_load_schematic(L, -1, schemmgr, &replace_names);
1259         lua_pop(L, 1);
1260
1261         deco->schematic = schem;
1262         return schem != NULL;
1263 }
1264
1265
1266 // register_ore({lots of stuff})
1267 int ModApiMapgen::l_register_ore(lua_State *L)
1268 {
1269         NO_MAP_LOCK_REQUIRED;
1270
1271         int index = 1;
1272         luaL_checktype(L, index, LUA_TTABLE);
1273
1274         const NodeDefManager *ndef = getServer(L)->getNodeDefManager();
1275         EmergeManager *emerge = getServer(L)->getEmergeManager();
1276         BiomeManager *bmgr    = emerge->getWritableBiomeManager();
1277         OreManager *oremgr    = emerge->getWritableOreManager();
1278
1279         enum OreType oretype = (OreType)getenumfield(L, index,
1280                                 "ore_type", es_OreType, ORE_SCATTER);
1281         Ore *ore = oremgr->create(oretype);
1282         if (!ore) {
1283                 errorstream << "register_ore: ore_type " << oretype << " not implemented\n";
1284                 return 0;
1285         }
1286
1287         ore->name           = getstringfield_default(L, index, "name", "");
1288         ore->ore_param2     = (u8)getintfield_default(L, index, "ore_param2", 0);
1289         ore->clust_scarcity = getintfield_default(L, index, "clust_scarcity", 1);
1290         ore->clust_num_ores = getintfield_default(L, index, "clust_num_ores", 1);
1291         ore->clust_size     = getintfield_default(L, index, "clust_size", 0);
1292         ore->noise          = NULL;
1293         ore->flags          = 0;
1294
1295         //// Get noise_threshold
1296         warn_if_field_exists(L, index, "noise_threshhold",
1297                 "Deprecated: new name is \"noise_threshold\".");
1298
1299         float nthresh;
1300         if (!getfloatfield(L, index, "noise_threshold", nthresh) &&
1301                         !getfloatfield(L, index, "noise_threshhold", nthresh))
1302                 nthresh = 0;
1303         ore->nthresh = nthresh;
1304
1305         //// Get y_min/y_max
1306         warn_if_field_exists(L, index, "height_min",
1307                 "Deprecated: new name is \"y_min\".");
1308         warn_if_field_exists(L, index, "height_max",
1309                 "Deprecated: new name is \"y_max\".");
1310
1311         int ymin, ymax;
1312         if (!getintfield(L, index, "y_min", ymin) &&
1313                 !getintfield(L, index, "height_min", ymin))
1314                 ymin = -31000;
1315         if (!getintfield(L, index, "y_max", ymax) &&
1316                 !getintfield(L, index, "height_max", ymax))
1317                 ymax = 31000;
1318         ore->y_min = ymin;
1319         ore->y_max = ymax;
1320
1321         if (ore->clust_scarcity <= 0 || ore->clust_num_ores <= 0) {
1322                 errorstream << "register_ore: clust_scarcity and clust_num_ores"
1323                         "must be greater than 0" << std::endl;
1324                 delete ore;
1325                 return 0;
1326         }
1327
1328         //// Get flags
1329         getflagsfield(L, index, "flags", flagdesc_ore, &ore->flags, NULL);
1330
1331         //// Get biomes associated with this decoration (if any)
1332         lua_getfield(L, index, "biomes");
1333         if (get_biome_list(L, -1, bmgr, &ore->biomes))
1334                 infostream << "register_ore: couldn't get all biomes " << std::endl;
1335         lua_pop(L, 1);
1336
1337         //// Get noise parameters if needed
1338         lua_getfield(L, index, "noise_params");
1339         if (read_noiseparams(L, -1, &ore->np)) {
1340                 ore->flags |= OREFLAG_USE_NOISE;
1341         } else if (ore->NEEDS_NOISE) {
1342                 errorstream << "register_ore: specified ore type requires valid "
1343                         "'noise_params' parameter" << std::endl;
1344                 delete ore;
1345                 return 0;
1346         }
1347         lua_pop(L, 1);
1348
1349         //// Get type-specific parameters
1350         switch (oretype) {
1351                 case ORE_SHEET: {
1352                         OreSheet *oresheet = (OreSheet *)ore;
1353
1354                         oresheet->column_height_min = getintfield_default(L, index,
1355                                 "column_height_min", 1);
1356                         oresheet->column_height_max = getintfield_default(L, index,
1357                                 "column_height_max", ore->clust_size);
1358                         oresheet->column_midpoint_factor = getfloatfield_default(L, index,
1359                                 "column_midpoint_factor", 0.5f);
1360
1361                         break;
1362                 }
1363                 case ORE_PUFF: {
1364                         OrePuff *orepuff = (OrePuff *)ore;
1365
1366                         lua_getfield(L, index, "np_puff_top");
1367                         read_noiseparams(L, -1, &orepuff->np_puff_top);
1368                         lua_pop(L, 1);
1369
1370                         lua_getfield(L, index, "np_puff_bottom");
1371                         read_noiseparams(L, -1, &orepuff->np_puff_bottom);
1372                         lua_pop(L, 1);
1373
1374                         break;
1375                 }
1376                 case ORE_VEIN: {
1377                         OreVein *orevein = (OreVein *)ore;
1378
1379                         orevein->random_factor = getfloatfield_default(L, index,
1380                                 "random_factor", 1.f);
1381
1382                         break;
1383                 }
1384                 case ORE_STRATUM: {
1385                         OreStratum *orestratum = (OreStratum *)ore;
1386
1387                         lua_getfield(L, index, "np_stratum_thickness");
1388                         if (read_noiseparams(L, -1, &orestratum->np_stratum_thickness))
1389                                 ore->flags |= OREFLAG_USE_NOISE2;
1390                         lua_pop(L, 1);
1391
1392                         orestratum->stratum_thickness = getintfield_default(L, index,
1393                                 "stratum_thickness", 8);
1394
1395                         break;
1396                 }
1397                 default:
1398                         break;
1399         }
1400
1401         ObjDefHandle handle = oremgr->add(ore);
1402         if (handle == OBJDEF_INVALID_HANDLE) {
1403                 delete ore;
1404                 return 0;
1405         }
1406
1407         ore->m_nodenames.push_back(getstringfield_default(L, index, "ore", ""));
1408
1409         size_t nnames = getstringlistfield(L, index, "wherein", &ore->m_nodenames);
1410         ore->m_nnlistsizes.push_back(nnames);
1411
1412         ndef->pendNodeResolve(ore);
1413
1414         lua_pushinteger(L, handle);
1415         return 1;
1416 }
1417
1418
1419 // register_schematic({schematic}, replacements={})
1420 int ModApiMapgen::l_register_schematic(lua_State *L)
1421 {
1422         NO_MAP_LOCK_REQUIRED;
1423
1424         SchematicManager *schemmgr =
1425                 getServer(L)->getEmergeManager()->getWritableSchematicManager();
1426
1427         StringMap replace_names;
1428         if (lua_istable(L, 2))
1429                 read_schematic_replacements(L, 2, &replace_names);
1430
1431         Schematic *schem = load_schematic(L, 1, schemmgr->getNodeDef(),
1432                 &replace_names);
1433         if (!schem)
1434                 return 0;
1435
1436         ObjDefHandle handle = schemmgr->add(schem);
1437         if (handle == OBJDEF_INVALID_HANDLE) {
1438                 delete schem;
1439                 return 0;
1440         }
1441
1442         lua_pushinteger(L, handle);
1443         return 1;
1444 }
1445
1446
1447 // clear_registered_biomes()
1448 int ModApiMapgen::l_clear_registered_biomes(lua_State *L)
1449 {
1450         NO_MAP_LOCK_REQUIRED;
1451
1452         BiomeManager *bmgr =
1453                 getServer(L)->getEmergeManager()->getWritableBiomeManager();
1454         bmgr->clear();
1455         return 0;
1456 }
1457
1458
1459 // clear_registered_decorations()
1460 int ModApiMapgen::l_clear_registered_decorations(lua_State *L)
1461 {
1462         NO_MAP_LOCK_REQUIRED;
1463
1464         DecorationManager *dmgr =
1465                 getServer(L)->getEmergeManager()->getWritableDecorationManager();
1466         dmgr->clear();
1467         return 0;
1468 }
1469
1470
1471 // clear_registered_ores()
1472 int ModApiMapgen::l_clear_registered_ores(lua_State *L)
1473 {
1474         NO_MAP_LOCK_REQUIRED;
1475
1476         OreManager *omgr =
1477                 getServer(L)->getEmergeManager()->getWritableOreManager();
1478         omgr->clear();
1479         return 0;
1480 }
1481
1482
1483 // clear_registered_schematics()
1484 int ModApiMapgen::l_clear_registered_schematics(lua_State *L)
1485 {
1486         NO_MAP_LOCK_REQUIRED;
1487
1488         SchematicManager *smgr =
1489                 getServer(L)->getEmergeManager()->getWritableSchematicManager();
1490         smgr->clear();
1491         return 0;
1492 }
1493
1494
1495 // generate_ores(vm, p1, p2, [ore_id])
1496 int ModApiMapgen::l_generate_ores(lua_State *L)
1497 {
1498         NO_MAP_LOCK_REQUIRED;
1499
1500         EmergeManager *emerge = getServer(L)->getEmergeManager();
1501
1502         Mapgen mg;
1503         mg.seed = emerge->mgparams->seed;
1504         mg.vm   = LuaVoxelManip::checkobject(L, 1)->vm;
1505         mg.ndef = getServer(L)->getNodeDefManager();
1506
1507         v3s16 pmin = lua_istable(L, 2) ? check_v3s16(L, 2) :
1508                         mg.vm->m_area.MinEdge + v3s16(1,1,1) * MAP_BLOCKSIZE;
1509         v3s16 pmax = lua_istable(L, 3) ? check_v3s16(L, 3) :
1510                         mg.vm->m_area.MaxEdge - v3s16(1,1,1) * MAP_BLOCKSIZE;
1511         sortBoxVerticies(pmin, pmax);
1512
1513         u32 blockseed = Mapgen::getBlockSeed(pmin, mg.seed);
1514
1515         emerge->oremgr->placeAllOres(&mg, blockseed, pmin, pmax);
1516
1517         return 0;
1518 }
1519
1520
1521 // generate_decorations(vm, p1, p2, [deco_id])
1522 int ModApiMapgen::l_generate_decorations(lua_State *L)
1523 {
1524         NO_MAP_LOCK_REQUIRED;
1525
1526         EmergeManager *emerge = getServer(L)->getEmergeManager();
1527
1528         Mapgen mg;
1529         mg.seed = emerge->mgparams->seed;
1530         mg.vm   = LuaVoxelManip::checkobject(L, 1)->vm;
1531         mg.ndef = getServer(L)->getNodeDefManager();
1532
1533         v3s16 pmin = lua_istable(L, 2) ? check_v3s16(L, 2) :
1534                         mg.vm->m_area.MinEdge + v3s16(1,1,1) * MAP_BLOCKSIZE;
1535         v3s16 pmax = lua_istable(L, 3) ? check_v3s16(L, 3) :
1536                         mg.vm->m_area.MaxEdge - v3s16(1,1,1) * MAP_BLOCKSIZE;
1537         sortBoxVerticies(pmin, pmax);
1538
1539         u32 blockseed = Mapgen::getBlockSeed(pmin, mg.seed);
1540
1541         emerge->decomgr->placeAllDecos(&mg, blockseed, pmin, pmax);
1542
1543         return 0;
1544 }
1545
1546
1547 // create_schematic(p1, p2, probability_list, filename, y_slice_prob_list)
1548 int ModApiMapgen::l_create_schematic(lua_State *L)
1549 {
1550         MAP_LOCK_REQUIRED;
1551
1552         const NodeDefManager *ndef = getServer(L)->getNodeDefManager();
1553
1554         const char *filename = luaL_checkstring(L, 4);
1555         CHECK_SECURE_PATH(L, filename, true);
1556
1557         Map *map = &(getEnv(L)->getMap());
1558         Schematic schem;
1559
1560         v3s16 p1 = check_v3s16(L, 1);
1561         v3s16 p2 = check_v3s16(L, 2);
1562         sortBoxVerticies(p1, p2);
1563
1564         std::vector<std::pair<v3s16, u8> > prob_list;
1565         if (lua_istable(L, 3)) {
1566                 lua_pushnil(L);
1567                 while (lua_next(L, 3)) {
1568                         if (lua_istable(L, -1)) {
1569                                 lua_getfield(L, -1, "pos");
1570                                 v3s16 pos = check_v3s16(L, -1);
1571                                 lua_pop(L, 1);
1572
1573                                 u8 prob = getintfield_default(L, -1, "prob", MTSCHEM_PROB_ALWAYS);
1574                                 prob_list.emplace_back(pos, prob);
1575                         }
1576
1577                         lua_pop(L, 1);
1578                 }
1579         }
1580
1581         std::vector<std::pair<s16, u8> > slice_prob_list;
1582         if (lua_istable(L, 5)) {
1583                 lua_pushnil(L);
1584                 while (lua_next(L, 5)) {
1585                         if (lua_istable(L, -1)) {
1586                                 s16 ypos = getintfield_default(L, -1, "ypos", 0);
1587                                 u8 prob  = getintfield_default(L, -1, "prob", MTSCHEM_PROB_ALWAYS);
1588                                 slice_prob_list.emplace_back(ypos, prob);
1589                         }
1590
1591                         lua_pop(L, 1);
1592                 }
1593         }
1594
1595         if (!schem.getSchematicFromMap(map, p1, p2)) {
1596                 errorstream << "create_schematic: failed to get schematic "
1597                         "from map" << std::endl;
1598                 return 0;
1599         }
1600
1601         schem.applyProbabilities(p1, &prob_list, &slice_prob_list);
1602
1603         schem.saveSchematicToFile(filename, ndef);
1604         actionstream << "create_schematic: saved schematic file '"
1605                 << filename << "'." << std::endl;
1606
1607         lua_pushboolean(L, true);
1608         return 1;
1609 }
1610
1611
1612 // place_schematic(p, schematic, rotation,
1613 //     replacements, force_placement, flagstring)
1614 int ModApiMapgen::l_place_schematic(lua_State *L)
1615 {
1616         MAP_LOCK_REQUIRED;
1617
1618         GET_ENV_PTR;
1619
1620         ServerMap *map = &(env->getServerMap());
1621         SchematicManager *schemmgr = getServer(L)->getEmergeManager()->schemmgr;
1622
1623         //// Read position
1624         v3s16 p = check_v3s16(L, 1);
1625
1626         //// Read rotation
1627         int rot = ROTATE_0;
1628         std::string enumstr = readParam<std::string>(L, 3, "");
1629         if (!enumstr.empty())
1630                 string_to_enum(es_Rotation, rot, enumstr);
1631
1632         //// Read force placement
1633         bool force_placement = true;
1634         if (lua_isboolean(L, 5))
1635                 force_placement = readParam<bool>(L, 5);
1636
1637         //// Read node replacements
1638         StringMap replace_names;
1639         if (lua_istable(L, 4))
1640                 read_schematic_replacements(L, 4, &replace_names);
1641
1642         //// Read schematic
1643         Schematic *schem = get_or_load_schematic(L, 2, schemmgr, &replace_names);
1644         if (!schem) {
1645                 errorstream << "place_schematic: failed to get schematic" << std::endl;
1646                 return 0;
1647         }
1648
1649         //// Read flags
1650         u32 flags = 0;
1651         read_flags(L, 6, flagdesc_deco, &flags, NULL);
1652
1653         schem->placeOnMap(map, p, flags, (Rotation)rot, force_placement);
1654
1655         lua_pushboolean(L, true);
1656         return 1;
1657 }
1658
1659
1660 // place_schematic_on_vmanip(vm, p, schematic, rotation,
1661 //     replacements, force_placement, flagstring)
1662 int ModApiMapgen::l_place_schematic_on_vmanip(lua_State *L)
1663 {
1664         NO_MAP_LOCK_REQUIRED;
1665
1666         SchematicManager *schemmgr = getServer(L)->getEmergeManager()->schemmgr;
1667
1668         //// Read VoxelManip object
1669         MMVManip *vm = LuaVoxelManip::checkobject(L, 1)->vm;
1670
1671         //// Read position
1672         v3s16 p = check_v3s16(L, 2);
1673
1674         //// Read rotation
1675         int rot = ROTATE_0;
1676         std::string enumstr = readParam<std::string>(L, 4, "");
1677         if (!enumstr.empty())
1678                 string_to_enum(es_Rotation, rot, std::string(enumstr));
1679
1680         //// Read force placement
1681         bool force_placement = true;
1682         if (lua_isboolean(L, 6))
1683                 force_placement = readParam<bool>(L, 6);
1684
1685         //// Read node replacements
1686         StringMap replace_names;
1687         if (lua_istable(L, 5))
1688                 read_schematic_replacements(L, 5, &replace_names);
1689
1690         //// Read schematic
1691         Schematic *schem = get_or_load_schematic(L, 3, schemmgr, &replace_names);
1692         if (!schem) {
1693                 errorstream << "place_schematic: failed to get schematic" << std::endl;
1694                 return 0;
1695         }
1696
1697         //// Read flags
1698         u32 flags = 0;
1699         read_flags(L, 7, flagdesc_deco, &flags, NULL);
1700
1701         bool schematic_did_fit = schem->placeOnVManip(
1702                 vm, p, flags, (Rotation)rot, force_placement);
1703
1704         lua_pushboolean(L, schematic_did_fit);
1705         return 1;
1706 }
1707
1708
1709 // serialize_schematic(schematic, format, options={...})
1710 int ModApiMapgen::l_serialize_schematic(lua_State *L)
1711 {
1712         NO_MAP_LOCK_REQUIRED;
1713
1714         const SchematicManager *schemmgr = getServer(L)->getEmergeManager()->getSchematicManager();
1715
1716         //// Read options
1717         bool use_comments = getboolfield_default(L, 3, "lua_use_comments", false);
1718         u32 indent_spaces = getintfield_default(L, 3, "lua_num_indent_spaces", 0);
1719
1720         //// Get schematic
1721         bool was_loaded = false;
1722         const Schematic *schem = (Schematic *)get_objdef(L, 1, schemmgr);
1723         if (!schem) {
1724                 schem = load_schematic(L, 1, NULL, NULL);
1725                 was_loaded = true;
1726         }
1727         if (!schem) {
1728                 errorstream << "serialize_schematic: failed to get schematic" << std::endl;
1729                 return 0;
1730         }
1731
1732         //// Read format of definition to save as
1733         int schem_format = SCHEM_FMT_MTS;
1734         std::string enumstr = readParam<std::string>(L, 2, "");
1735         if (!enumstr.empty())
1736                 string_to_enum(es_SchematicFormatType, schem_format, enumstr);
1737
1738         //// Serialize to binary string
1739         std::ostringstream os(std::ios_base::binary);
1740         switch (schem_format) {
1741         case SCHEM_FMT_MTS:
1742                 schem->serializeToMts(&os, schem->m_nodenames);
1743                 break;
1744         case SCHEM_FMT_LUA:
1745                 schem->serializeToLua(&os, schem->m_nodenames,
1746                         use_comments, indent_spaces);
1747                 break;
1748         default:
1749                 return 0;
1750         }
1751
1752         if (was_loaded)
1753                 delete schem;
1754
1755         std::string ser = os.str();
1756         lua_pushlstring(L, ser.c_str(), ser.length());
1757         return 1;
1758 }
1759
1760 // read_schematic(schematic, options={...})
1761 int ModApiMapgen::l_read_schematic(lua_State *L)
1762 {
1763         NO_MAP_LOCK_REQUIRED;
1764
1765         const SchematicManager *schemmgr =
1766                 getServer(L)->getEmergeManager()->getSchematicManager();
1767
1768         //// Read options
1769         std::string write_yslice = getstringfield_default(L, 2, "write_yslice_prob", "all");
1770
1771         //// Get schematic
1772         bool was_loaded = false;
1773         Schematic *schem = (Schematic *)get_objdef(L, 1, schemmgr);
1774         if (!schem) {
1775                 schem = load_schematic(L, 1, NULL, NULL);
1776                 was_loaded = true;
1777         }
1778         if (!schem) {
1779                 errorstream << "read_schematic: failed to get schematic" << std::endl;
1780                 return 0;
1781         }
1782         lua_pop(L, 2);
1783
1784         //// Create the Lua table
1785         u32 numnodes = schem->size.X * schem->size.Y * schem->size.Z;
1786         const std::vector<std::string> &names = schem->m_nodenames;
1787
1788         lua_createtable(L, 0, (write_yslice == "none") ? 2 : 3);
1789
1790         // Create the size field
1791         push_v3s16(L, schem->size);
1792         lua_setfield(L, 1, "size");
1793
1794         // Create the yslice_prob field
1795         if (write_yslice != "none") {
1796                 lua_createtable(L, schem->size.Y, 0);
1797                 for (u16 y = 0; y != schem->size.Y; ++y) {
1798                         u8 probability = schem->slice_probs[y] & MTSCHEM_PROB_MASK;
1799                         if (probability < MTSCHEM_PROB_ALWAYS || write_yslice != "low") {
1800                                 lua_createtable(L, 0, 2);
1801                                 lua_pushinteger(L, y);
1802                                 lua_setfield(L, 3, "ypos");
1803                                 lua_pushinteger(L, probability * 2);
1804                                 lua_setfield(L, 3, "prob");
1805                                 lua_rawseti(L, 2, y + 1);
1806                         }
1807                 }
1808                 lua_setfield(L, 1, "yslice_prob");
1809         }
1810
1811         // Create the data field
1812         lua_createtable(L, numnodes, 0); // data table
1813         for (u32 i = 0; i < numnodes; ++i) {
1814                 MapNode node = schem->schemdata[i];
1815                 u8 probability   = node.param1 & MTSCHEM_PROB_MASK;
1816                 bool force_place = node.param1 & MTSCHEM_FORCE_PLACE;
1817                 lua_createtable(L, 0, force_place ? 4 : 3);
1818                 lua_pushstring(L, names[schem->schemdata[i].getContent()].c_str());
1819                 lua_setfield(L, 3, "name");
1820                 lua_pushinteger(L, probability * 2);
1821                 lua_setfield(L, 3, "prob");
1822                 lua_pushinteger(L, node.param2);
1823                 lua_setfield(L, 3, "param2");
1824                 if (force_place) {
1825                         lua_pushboolean(L, 1);
1826                         lua_setfield(L, 3, "force_place");
1827                 }
1828                 lua_rawseti(L, 2, i + 1);
1829         }
1830         lua_setfield(L, 1, "data");
1831
1832         if (was_loaded)
1833                 delete schem;
1834
1835         return 1;
1836 }
1837
1838
1839 void ModApiMapgen::Initialize(lua_State *L, int top)
1840 {
1841         API_FCT(get_biome_id);
1842         API_FCT(get_biome_name);
1843         API_FCT(get_heat);
1844         API_FCT(get_humidity);
1845         API_FCT(get_biome_data);
1846         API_FCT(get_mapgen_object);
1847         API_FCT(get_spawn_level);
1848
1849         API_FCT(get_mapgen_params);
1850         API_FCT(set_mapgen_params);
1851         API_FCT(get_mapgen_setting);
1852         API_FCT(set_mapgen_setting);
1853         API_FCT(get_mapgen_setting_noiseparams);
1854         API_FCT(set_mapgen_setting_noiseparams);
1855         API_FCT(set_noiseparams);
1856         API_FCT(get_noiseparams);
1857         API_FCT(set_gen_notify);
1858         API_FCT(get_gen_notify);
1859         API_FCT(get_decoration_id);
1860
1861         API_FCT(register_biome);
1862         API_FCT(register_decoration);
1863         API_FCT(register_ore);
1864         API_FCT(register_schematic);
1865
1866         API_FCT(clear_registered_biomes);
1867         API_FCT(clear_registered_decorations);
1868         API_FCT(clear_registered_ores);
1869         API_FCT(clear_registered_schematics);
1870
1871         API_FCT(generate_ores);
1872         API_FCT(generate_decorations);
1873         API_FCT(create_schematic);
1874         API_FCT(place_schematic);
1875         API_FCT(place_schematic_on_vmanip);
1876         API_FCT(serialize_schematic);
1877         API_FCT(read_schematic);
1878 }