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         lua_getfield(L, 1, "flags");
 877         if (lua_isstring(L, -1))
 878                 settingsmgr->setMapSetting("mg_flags", readParam<std::string>(L, -1), true);
 879
 880         return 0;
 881 }
 882
 883 // get_mapgen_setting(name)
 884 int ModApiMapgen::l_get_mapgen_setting(lua_State *L)
 885 {
 886         NO_MAP_LOCK_REQUIRED;
 887
 888         std::string value;
 889         MapSettingsManager *settingsmgr =
 890                 getServer(L)->getEmergeManager()->map_settings_mgr;
 891
 892         const char *name = luaL_checkstring(L, 1);
 893         if (!settingsmgr->getMapSetting(name, &value))
 894                 return 0;
 895
 896         lua_pushstring(L, value.c_str());
 897         return 1;
 898 }
 899
 900 // get_mapgen_setting_noiseparams(name)
 901 int ModApiMapgen::l_get_mapgen_setting_noiseparams(lua_State *L)
 902 {
 903         NO_MAP_LOCK_REQUIRED;
 904
 905         NoiseParams np;
 906         MapSettingsManager *settingsmgr =
 907                 getServer(L)->getEmergeManager()->map_settings_mgr;
 908
 909         const char *name = luaL_checkstring(L, 1);
 910         if (!settingsmgr->getMapSettingNoiseParams(name, &np))
 911                 return 0;
 912
 913         push_noiseparams(L, &np);
 914         return 1;
 915 }
 916
 917 // set_mapgen_setting(name, value, override_meta)
 918 // set mapgen config values
 919 int ModApiMapgen::l_set_mapgen_setting(lua_State *L)
 920 {
 921         NO_MAP_LOCK_REQUIRED;
 922
 923         MapSettingsManager *settingsmgr =
 924                 getServer(L)->getEmergeManager()->map_settings_mgr;
 925
 926         const char *name   = luaL_checkstring(L, 1);
 927         const char *value  = luaL_checkstring(L, 2);
 928         bool override_meta = readParam<bool>(L, 3, false);
 929
 930         if (!settingsmgr->setMapSetting(name, value, override_meta)) {
 931                 errorstream << "set_mapgen_setting: cannot set '"
 932                         << name << "' after initialization" << std::endl;
 933         }
 934
 935         return 0;
 936 }
 937
 938
 939 // set_mapgen_setting_noiseparams(name, noiseparams, set_default)
 940 // set mapgen config values for noise parameters
 941 int ModApiMapgen::l_set_mapgen_setting_noiseparams(lua_State *L)
 942 {
 943         NO_MAP_LOCK_REQUIRED;
 944
 945         MapSettingsManager *settingsmgr =
 946                 getServer(L)->getEmergeManager()->map_settings_mgr;
 947
 948         const char *name = luaL_checkstring(L, 1);
 949
 950         NoiseParams np;
 951         if (!read_noiseparams(L, 2, &np)) {
 952                 errorstream << "set_mapgen_setting_noiseparams: cannot set '" << name
 953                         << "'; invalid noiseparams table" << std::endl;
 954                 return 0;
 955         }
 956
 957         bool override_meta = readParam<bool>(L, 3, false);
 958
 959         if (!settingsmgr->setMapSettingNoiseParams(name, &np, override_meta)) {
 960                 errorstream << "set_mapgen_setting_noiseparams: cannot set '"
 961                         << name << "' after initialization" << std::endl;
 962         }
 963
 964         return 0;
 965 }
 966
 967
 968 // set_noiseparams(name, noiseparams, set_default)
 969 // set global config values for noise parameters
 970 int ModApiMapgen::l_set_noiseparams(lua_State *L)
 971 {
 972         NO_MAP_LOCK_REQUIRED;
 973
 974         const char *name = luaL_checkstring(L, 1);
 975
 976         NoiseParams np;
 977         if (!read_noiseparams(L, 2, &np)) {
 978                 errorstream << "set_noiseparams: cannot set '" << name
 979                         << "'; invalid noiseparams table" << std::endl;
 980                 return 0;
 981         }
 982
 983         bool set_default = !lua_isboolean(L, 3) || readParam<bool>(L, 3);
 984
 985         g_settings->setNoiseParams(name, np, set_default);
 986
 987         return 0;
 988 }
 989
 990
 991 // get_noiseparams(name)
 992 int ModApiMapgen::l_get_noiseparams(lua_State *L)
 993 {
 994         NO_MAP_LOCK_REQUIRED;
 995
 996         std::string name = luaL_checkstring(L, 1);
 997
 998         NoiseParams np;
 999         if (!g_settings->getNoiseParams(name, np))
1000                 return 0;
1001
1002         push_noiseparams(L, &np);
1003         return 1;
1004 }
1005
1006
1007 // set_gen_notify(flags, {deco_id_table})
1008 int ModApiMapgen::l_set_gen_notify(lua_State *L)
1009 {
1010         NO_MAP_LOCK_REQUIRED;
1011
1012         u32 flags = 0, flagmask = 0;
1013         EmergeManager *emerge = getServer(L)->getEmergeManager();
1014
1015         if (read_flags(L, 1, flagdesc_gennotify, &flags, &flagmask)) {
1016                 emerge->gen_notify_on &= ~flagmask;
1017                 emerge->gen_notify_on |= flags;
1018         }
1019
1020         if (lua_istable(L, 2)) {
1021                 lua_pushnil(L);
1022                 while (lua_next(L, 2)) {
1023                         if (lua_isnumber(L, -1))
1024                                 emerge->gen_notify_on_deco_ids.insert((u32)lua_tonumber(L, -1));
1025                         lua_pop(L, 1);
1026                 }
1027         }
1028
1029         return 0;
1030 }
1031
1032
1033 // get_gen_notify()
1034 int ModApiMapgen::l_get_gen_notify(lua_State *L)
1035 {
1036         NO_MAP_LOCK_REQUIRED;
1037
1038         EmergeManager *emerge = getServer(L)->getEmergeManager();
1039         push_flags_string(L, flagdesc_gennotify, emerge->gen_notify_on,
1040                 emerge->gen_notify_on);
1041
1042         lua_newtable(L);
1043         int i = 1;
1044         for (u32 gen_notify_on_deco_id : emerge->gen_notify_on_deco_ids) {
1045                 lua_pushnumber(L, gen_notify_on_deco_id);
1046                 lua_rawseti(L, -2, i++);
1047         }
1048         return 2;
1049 }
1050
1051
1052 // get_decoration_id(decoration_name)
1053 // returns the decoration ID as used in gennotify
1054 int ModApiMapgen::l_get_decoration_id(lua_State *L)
1055 {
1056         NO_MAP_LOCK_REQUIRED;
1057
1058         const char *deco_str = luaL_checkstring(L, 1);
1059         if (!deco_str)
1060                 return 0;
1061
1062         const DecorationManager *dmgr =
1063                 getServer(L)->getEmergeManager()->getDecorationManager();
1064
1065         if (!dmgr)
1066                 return 0;
1067
1068         Decoration *deco = (Decoration *)dmgr->getByName(deco_str);
1069
1070         if (!deco)
1071                 return 0;
1072
1073         lua_pushinteger(L, deco->index);
1074
1075         return 1;
1076 }
1077
1078
1079 // register_biome({lots of stuff})
1080 int ModApiMapgen::l_register_biome(lua_State *L)
1081 {
1082         NO_MAP_LOCK_REQUIRED;
1083
1084         int index = 1;
1085         luaL_checktype(L, index, LUA_TTABLE);
1086
1087         const NodeDefManager *ndef = getServer(L)->getNodeDefManager();
1088         BiomeManager *bmgr = getServer(L)->getEmergeManager()->getWritableBiomeManager();
1089
1090         Biome *biome = read_biome_def(L, index, ndef);
1091         if (!biome)
1092                 return 0;
1093
1094         ObjDefHandle handle = bmgr->add(biome);
1095         if (handle == OBJDEF_INVALID_HANDLE) {
1096                 delete biome;
1097                 return 0;
1098         }
1099
1100         lua_pushinteger(L, handle);
1101         return 1;
1102 }
1103
1104
1105 // register_decoration({lots of stuff})
1106 int ModApiMapgen::l_register_decoration(lua_State *L)
1107 {
1108         NO_MAP_LOCK_REQUIRED;
1109
1110         int index = 1;
1111         luaL_checktype(L, index, LUA_TTABLE);
1112
1113         const NodeDefManager *ndef      = getServer(L)->getNodeDefManager();
1114         EmergeManager *emerge = getServer(L)->getEmergeManager();
1115         DecorationManager *decomgr = emerge->getWritableDecorationManager();
1116         BiomeManager *biomemgr     = emerge->getWritableBiomeManager();
1117         SchematicManager *schemmgr = emerge->getWritableSchematicManager();
1118
1119         enum DecorationType decotype = (DecorationType)getenumfield(L, index,
1120                                 "deco_type", es_DecorationType, -1);
1121
1122         Decoration *deco = decomgr->create(decotype);
1123         if (!deco) {
1124                 errorstream << "register_decoration: decoration placement type "
1125                         << decotype << " not implemented" << std::endl;
1126                 return 0;
1127         }
1128
1129         deco->name           = getstringfield_default(L, index, "name", "");
1130         deco->fill_ratio     = getfloatfield_default(L, index, "fill_ratio", 0.02);
1131         deco->y_min          = getintfield_default(L, index, "y_min", -31000);
1132         deco->y_max          = getintfield_default(L, index, "y_max", 31000);
1133         deco->nspawnby       = getintfield_default(L, index, "num_spawn_by", -1);
1134         deco->place_offset_y = getintfield_default(L, index, "place_offset_y", 0);
1135         deco->sidelen        = getintfield_default(L, index, "sidelen", 8);
1136         if (deco->sidelen <= 0) {
1137                 errorstream << "register_decoration: sidelen must be "
1138                         "greater than 0" << std::endl;
1139                 delete deco;
1140                 return 0;
1141         }
1142
1143         //// Get node name(s) to place decoration on
1144         size_t nread = getstringlistfield(L, index, "place_on", &deco->m_nodenames);
1145         deco->m_nnlistsizes.push_back(nread);
1146
1147         //// Get decoration flags
1148         getflagsfield(L, index, "flags", flagdesc_deco, &deco->flags, NULL);
1149
1150         //// Get NoiseParams to define how decoration is placed
1151         lua_getfield(L, index, "noise_params");
1152         if (read_noiseparams(L, -1, &deco->np))
1153                 deco->flags |= DECO_USE_NOISE;
1154         lua_pop(L, 1);
1155
1156         //// Get biomes associated with this decoration (if any)
1157         lua_getfield(L, index, "biomes");
1158         if (get_biome_list(L, -1, biomemgr, &deco->biomes))
1159                 infostream << "register_decoration: couldn't get all biomes " << std::endl;
1160         lua_pop(L, 1);
1161
1162         //// Get node name(s) to 'spawn by'
1163         size_t nnames = getstringlistfield(L, index, "spawn_by", &deco->m_nodenames);
1164         deco->m_nnlistsizes.push_back(nnames);
1165         if (nnames == 0 && deco->nspawnby != -1) {
1166                 errorstream << "register_decoration: no spawn_by nodes defined,"
1167                         " but num_spawn_by specified" << std::endl;
1168         }
1169
1170         //// Handle decoration type-specific parameters
1171         bool success = false;
1172         switch (decotype) {
1173         case DECO_SIMPLE:
1174                 success = read_deco_simple(L, (DecoSimple *)deco);
1175                 break;
1176         case DECO_SCHEMATIC:
1177                 success = read_deco_schematic(L, schemmgr, (DecoSchematic *)deco);
1178                 break;
1179         case DECO_LSYSTEM:
1180                 break;
1181         }
1182
1183         if (!success) {
1184                 delete deco;
1185                 return 0;
1186         }
1187
1188         ndef->pendNodeResolve(deco);
1189
1190         ObjDefHandle handle = decomgr->add(deco);
1191         if (handle == OBJDEF_INVALID_HANDLE) {
1192                 delete deco;
1193                 return 0;
1194         }
1195
1196         lua_pushinteger(L, handle);
1197         return 1;
1198 }
1199
1200
1201 bool read_deco_simple(lua_State *L, DecoSimple *deco)
1202 {
1203         int index = 1;
1204         int param2;
1205         int param2_max;
1206
1207         deco->deco_height     = getintfield_default(L, index, "height", 1);
1208         deco->deco_height_max = getintfield_default(L, index, "height_max", 0);
1209
1210         if (deco->deco_height <= 0) {
1211                 errorstream << "register_decoration: simple decoration height"
1212                         " must be greater than 0" << std::endl;
1213                 return false;
1214         }
1215
1216         size_t nnames = getstringlistfield(L, index, "decoration", &deco->m_nodenames);
1217         deco->m_nnlistsizes.push_back(nnames);
1218
1219         if (nnames == 0) {
1220                 errorstream << "register_decoration: no decoration nodes "
1221                         "defined" << std::endl;
1222                 return false;
1223         }
1224
1225         param2 = getintfield_default(L, index, "param2", 0);
1226         param2_max = getintfield_default(L, index, "param2_max", 0);
1227
1228         if (param2 < 0 || param2 > 255 || param2_max < 0 || param2_max > 255) {
1229                 errorstream << "register_decoration: param2 or param2_max out of bounds (0-255)"
1230                         << std::endl;
1231                 return false;
1232         }
1233
1234         deco->deco_param2 = (u8)param2;
1235         deco->deco_param2_max = (u8)param2_max;
1236
1237         return true;
1238 }
1239
1240
1241 bool read_deco_schematic(lua_State *L, SchematicManager *schemmgr, DecoSchematic *deco)
1242 {
1243         int index = 1;
1244
1245         deco->rotation = (Rotation)getenumfield(L, index, "rotation",
1246                 ModApiMapgen::es_Rotation, ROTATE_0);
1247
1248         StringMap replace_names;
1249         lua_getfield(L, index, "replacements");
1250         if (lua_istable(L, -1))
1251                 read_schematic_replacements(L, -1, &replace_names);
1252         lua_pop(L, 1);
1253
1254         lua_getfield(L, index, "schematic");
1255         Schematic *schem = get_or_load_schematic(L, -1, schemmgr, &replace_names);
1256         lua_pop(L, 1);
1257
1258         deco->schematic = schem;
1259         return schem != NULL;
1260 }
1261
1262
1263 // register_ore({lots of stuff})
1264 int ModApiMapgen::l_register_ore(lua_State *L)
1265 {
1266         NO_MAP_LOCK_REQUIRED;
1267
1268         int index = 1;
1269         luaL_checktype(L, index, LUA_TTABLE);
1270
1271         const NodeDefManager *ndef = getServer(L)->getNodeDefManager();
1272         EmergeManager *emerge = getServer(L)->getEmergeManager();
1273         BiomeManager *bmgr    = emerge->getWritableBiomeManager();
1274         OreManager *oremgr    = emerge->getWritableOreManager();
1275
1276         enum OreType oretype = (OreType)getenumfield(L, index,
1277                                 "ore_type", es_OreType, ORE_SCATTER);
1278         Ore *ore = oremgr->create(oretype);
1279         if (!ore) {
1280                 errorstream << "register_ore: ore_type " << oretype << " not implemented\n";
1281                 return 0;
1282         }
1283
1284         ore->name           = getstringfield_default(L, index, "name", "");
1285         ore->ore_param2     = (u8)getintfield_default(L, index, "ore_param2", 0);
1286         ore->clust_scarcity = getintfield_default(L, index, "clust_scarcity", 1);
1287         ore->clust_num_ores = getintfield_default(L, index, "clust_num_ores", 1);
1288         ore->clust_size     = getintfield_default(L, index, "clust_size", 0);
1289         ore->noise          = NULL;
1290         ore->flags          = 0;
1291
1292         //// Get noise_threshold
1293         warn_if_field_exists(L, index, "noise_threshhold",
1294                 "Deprecated: new name is \"noise_threshold\".");
1295
1296         float nthresh;
1297         if (!getfloatfield(L, index, "noise_threshold", nthresh) &&
1298                         !getfloatfield(L, index, "noise_threshhold", nthresh))
1299                 nthresh = 0;
1300         ore->nthresh = nthresh;
1301
1302         //// Get y_min/y_max
1303         warn_if_field_exists(L, index, "height_min",
1304                 "Deprecated: new name is \"y_min\".");
1305         warn_if_field_exists(L, index, "height_max",
1306                 "Deprecated: new name is \"y_max\".");
1307
1308         int ymin, ymax;
1309         if (!getintfield(L, index, "y_min", ymin) &&
1310                 !getintfield(L, index, "height_min", ymin))
1311                 ymin = -31000;
1312         if (!getintfield(L, index, "y_max", ymax) &&
1313                 !getintfield(L, index, "height_max", ymax))
1314                 ymax = 31000;
1315         ore->y_min = ymin;
1316         ore->y_max = ymax;
1317
1318         if (ore->clust_scarcity <= 0 || ore->clust_num_ores <= 0) {
1319                 errorstream << "register_ore: clust_scarcity and clust_num_ores"
1320                         "must be greater than 0" << std::endl;
1321                 delete ore;
1322                 return 0;
1323         }
1324
1325         //// Get flags
1326         getflagsfield(L, index, "flags", flagdesc_ore, &ore->flags, NULL);
1327
1328         //// Get biomes associated with this decoration (if any)
1329         lua_getfield(L, index, "biomes");
1330         if (get_biome_list(L, -1, bmgr, &ore->biomes))
1331                 infostream << "register_ore: couldn't get all biomes " << std::endl;
1332         lua_pop(L, 1);
1333
1334         //// Get noise parameters if needed
1335         lua_getfield(L, index, "noise_params");
1336         if (read_noiseparams(L, -1, &ore->np)) {
1337                 ore->flags |= OREFLAG_USE_NOISE;
1338         } else if (ore->needs_noise) {
1339                 errorstream << "register_ore: specified ore type requires valid "
1340                         "'noise_params' parameter" << std::endl;
1341                 delete ore;
1342                 return 0;
1343         }
1344         lua_pop(L, 1);
1345
1346         //// Get type-specific parameters
1347         switch (oretype) {
1348                 case ORE_SHEET: {
1349                         OreSheet *oresheet = (OreSheet *)ore;
1350
1351                         oresheet->column_height_min = getintfield_default(L, index,
1352                                 "column_height_min", 1);
1353                         oresheet->column_height_max = getintfield_default(L, index,
1354                                 "column_height_max", ore->clust_size);
1355                         oresheet->column_midpoint_factor = getfloatfield_default(L, index,
1356                                 "column_midpoint_factor", 0.5f);
1357
1358                         break;
1359                 }
1360                 case ORE_PUFF: {
1361                         OrePuff *orepuff = (OrePuff *)ore;
1362
1363                         lua_getfield(L, index, "np_puff_top");
1364                         read_noiseparams(L, -1, &orepuff->np_puff_top);
1365                         lua_pop(L, 1);
1366
1367                         lua_getfield(L, index, "np_puff_bottom");
1368                         read_noiseparams(L, -1, &orepuff->np_puff_bottom);
1369                         lua_pop(L, 1);
1370
1371                         break;
1372                 }
1373                 case ORE_VEIN: {
1374                         OreVein *orevein = (OreVein *)ore;
1375
1376                         orevein->random_factor = getfloatfield_default(L, index,
1377                                 "random_factor", 1.f);
1378
1379                         break;
1380                 }
1381                 case ORE_STRATUM: {
1382                         OreStratum *orestratum = (OreStratum *)ore;
1383
1384                         lua_getfield(L, index, "np_stratum_thickness");
1385                         if (read_noiseparams(L, -1, &orestratum->np_stratum_thickness))
1386                                 ore->flags |= OREFLAG_USE_NOISE2;
1387                         lua_pop(L, 1);
1388
1389                         orestratum->stratum_thickness = getintfield_default(L, index,
1390                                 "stratum_thickness", 8);
1391
1392                         break;
1393                 }
1394                 default:
1395                         break;
1396         }
1397
1398         ObjDefHandle handle = oremgr->add(ore);
1399         if (handle == OBJDEF_INVALID_HANDLE) {
1400                 delete ore;
1401                 return 0;
1402         }
1403
1404         ore->m_nodenames.push_back(getstringfield_default(L, index, "ore", ""));
1405
1406         size_t nnames = getstringlistfield(L, index, "wherein", &ore->m_nodenames);
1407         ore->m_nnlistsizes.push_back(nnames);
1408
1409         ndef->pendNodeResolve(ore);
1410
1411         lua_pushinteger(L, handle);
1412         return 1;
1413 }
1414
1415
1416 // register_schematic({schematic}, replacements={})
1417 int ModApiMapgen::l_register_schematic(lua_State *L)
1418 {
1419         NO_MAP_LOCK_REQUIRED;
1420
1421         SchematicManager *schemmgr =
1422                 getServer(L)->getEmergeManager()->getWritableSchematicManager();
1423
1424         StringMap replace_names;
1425         if (lua_istable(L, 2))
1426                 read_schematic_replacements(L, 2, &replace_names);
1427
1428         Schematic *schem = load_schematic(L, 1, schemmgr->getNodeDef(),
1429                 &replace_names);
1430         if (!schem)
1431                 return 0;
1432
1433         ObjDefHandle handle = schemmgr->add(schem);
1434         if (handle == OBJDEF_INVALID_HANDLE) {
1435                 delete schem;
1436                 return 0;
1437         }
1438
1439         lua_pushinteger(L, handle);
1440         return 1;
1441 }
1442
1443
1444 // clear_registered_biomes()
1445 int ModApiMapgen::l_clear_registered_biomes(lua_State *L)
1446 {
1447         NO_MAP_LOCK_REQUIRED;
1448
1449         BiomeManager *bmgr =
1450                 getServer(L)->getEmergeManager()->getWritableBiomeManager();
1451         bmgr->clear();
1452         return 0;
1453 }
1454
1455
1456 // clear_registered_decorations()
1457 int ModApiMapgen::l_clear_registered_decorations(lua_State *L)
1458 {
1459         NO_MAP_LOCK_REQUIRED;
1460
1461         DecorationManager *dmgr =
1462                 getServer(L)->getEmergeManager()->getWritableDecorationManager();
1463         dmgr->clear();
1464         return 0;
1465 }
1466
1467
1468 // clear_registered_ores()
1469 int ModApiMapgen::l_clear_registered_ores(lua_State *L)
1470 {
1471         NO_MAP_LOCK_REQUIRED;
1472
1473         OreManager *omgr =
1474                 getServer(L)->getEmergeManager()->getWritableOreManager();
1475         omgr->clear();
1476         return 0;
1477 }
1478
1479
1480 // clear_registered_schematics()
1481 int ModApiMapgen::l_clear_registered_schematics(lua_State *L)
1482 {
1483         NO_MAP_LOCK_REQUIRED;
1484
1485         SchematicManager *smgr =
1486                 getServer(L)->getEmergeManager()->getWritableSchematicManager();
1487         smgr->clear();
1488         return 0;
1489 }
1490
1491
1492 // generate_ores(vm, p1, p2, [ore_id])
1493 int ModApiMapgen::l_generate_ores(lua_State *L)
1494 {
1495         NO_MAP_LOCK_REQUIRED;
1496
1497         EmergeManager *emerge = getServer(L)->getEmergeManager();
1498
1499         Mapgen mg;
1500         mg.seed = emerge->mgparams->seed;
1501         mg.vm   = LuaVoxelManip::checkobject(L, 1)->vm;
1502         mg.ndef = getServer(L)->getNodeDefManager();
1503
1504         v3s16 pmin = lua_istable(L, 2) ? check_v3s16(L, 2) :
1505                         mg.vm->m_area.MinEdge + v3s16(1,1,1) * MAP_BLOCKSIZE;
1506         v3s16 pmax = lua_istable(L, 3) ? check_v3s16(L, 3) :
1507                         mg.vm->m_area.MaxEdge - v3s16(1,1,1) * MAP_BLOCKSIZE;
1508         sortBoxVerticies(pmin, pmax);
1509
1510         u32 blockseed = Mapgen::getBlockSeed(pmin, mg.seed);
1511
1512         emerge->oremgr->placeAllOres(&mg, blockseed, pmin, pmax);
1513
1514         return 0;
1515 }
1516
1517
1518 // generate_decorations(vm, p1, p2, [deco_id])
1519 int ModApiMapgen::l_generate_decorations(lua_State *L)
1520 {
1521         NO_MAP_LOCK_REQUIRED;
1522
1523         EmergeManager *emerge = getServer(L)->getEmergeManager();
1524
1525         Mapgen mg;
1526         mg.seed = emerge->mgparams->seed;
1527         mg.vm   = LuaVoxelManip::checkobject(L, 1)->vm;
1528         mg.ndef = getServer(L)->getNodeDefManager();
1529
1530         v3s16 pmin = lua_istable(L, 2) ? check_v3s16(L, 2) :
1531                         mg.vm->m_area.MinEdge + v3s16(1,1,1) * MAP_BLOCKSIZE;
1532         v3s16 pmax = lua_istable(L, 3) ? check_v3s16(L, 3) :
1533                         mg.vm->m_area.MaxEdge - v3s16(1,1,1) * MAP_BLOCKSIZE;
1534         sortBoxVerticies(pmin, pmax);
1535
1536         u32 blockseed = Mapgen::getBlockSeed(pmin, mg.seed);
1537
1538         emerge->decomgr->placeAllDecos(&mg, blockseed, pmin, pmax);
1539
1540         return 0;
1541 }
1542
1543
1544 // create_schematic(p1, p2, probability_list, filename, y_slice_prob_list)
1545 int ModApiMapgen::l_create_schematic(lua_State *L)
1546 {
1547         MAP_LOCK_REQUIRED;
1548
1549         const NodeDefManager *ndef = getServer(L)->getNodeDefManager();
1550
1551         const char *filename = luaL_checkstring(L, 4);
1552         CHECK_SECURE_PATH(L, filename, true);
1553
1554         Map *map = &(getEnv(L)->getMap());
1555         Schematic schem;
1556
1557         v3s16 p1 = check_v3s16(L, 1);
1558         v3s16 p2 = check_v3s16(L, 2);
1559         sortBoxVerticies(p1, p2);
1560
1561         std::vector<std::pair<v3s16, u8> > prob_list;
1562         if (lua_istable(L, 3)) {
1563                 lua_pushnil(L);
1564                 while (lua_next(L, 3)) {
1565                         if (lua_istable(L, -1)) {
1566                                 lua_getfield(L, -1, "pos");
1567                                 v3s16 pos = check_v3s16(L, -1);
1568                                 lua_pop(L, 1);
1569
1570                                 u8 prob = getintfield_default(L, -1, "prob", MTSCHEM_PROB_ALWAYS);
1571                                 prob_list.emplace_back(pos, prob);
1572                         }
1573
1574                         lua_pop(L, 1);
1575                 }
1576         }
1577
1578         std::vector<std::pair<s16, u8> > slice_prob_list;
1579         if (lua_istable(L, 5)) {
1580                 lua_pushnil(L);
1581                 while (lua_next(L, 5)) {
1582                         if (lua_istable(L, -1)) {
1583                                 s16 ypos = getintfield_default(L, -1, "ypos", 0);
1584                                 u8 prob  = getintfield_default(L, -1, "prob", MTSCHEM_PROB_ALWAYS);
1585                                 slice_prob_list.emplace_back(ypos, prob);
1586                         }
1587
1588                         lua_pop(L, 1);
1589                 }
1590         }
1591
1592         if (!schem.getSchematicFromMap(map, p1, p2)) {
1593                 errorstream << "create_schematic: failed to get schematic "
1594                         "from map" << std::endl;
1595                 return 0;
1596         }
1597
1598         schem.applyProbabilities(p1, &prob_list, &slice_prob_list);
1599
1600         schem.saveSchematicToFile(filename, ndef);
1601         actionstream << "create_schematic: saved schematic file '"
1602                 << filename << "'." << std::endl;
1603
1604         lua_pushboolean(L, true);
1605         return 1;
1606 }
1607
1608
1609 // place_schematic(p, schematic, rotation,
1610 //     replacements, force_placement, flagstring)
1611 int ModApiMapgen::l_place_schematic(lua_State *L)
1612 {
1613         MAP_LOCK_REQUIRED;
1614
1615         GET_ENV_PTR;
1616
1617         ServerMap *map = &(env->getServerMap());
1618         SchematicManager *schemmgr = getServer(L)->getEmergeManager()->schemmgr;
1619
1620         //// Read position
1621         v3s16 p = check_v3s16(L, 1);
1622
1623         //// Read rotation
1624         int rot = ROTATE_0;
1625         std::string enumstr = readParam<std::string>(L, 3, "");
1626         if (!enumstr.empty())
1627                 string_to_enum(es_Rotation, rot, enumstr);
1628
1629         //// Read force placement
1630         bool force_placement = true;
1631         if (lua_isboolean(L, 5))
1632                 force_placement = readParam<bool>(L, 5);
1633
1634         //// Read node replacements
1635         StringMap replace_names;
1636         if (lua_istable(L, 4))
1637                 read_schematic_replacements(L, 4, &replace_names);
1638
1639         //// Read schematic
1640         Schematic *schem = get_or_load_schematic(L, 2, schemmgr, &replace_names);
1641         if (!schem) {
1642                 errorstream << "place_schematic: failed to get schematic" << std::endl;
1643                 return 0;
1644         }
1645
1646         //// Read flags
1647         u32 flags = 0;
1648         read_flags(L, 6, flagdesc_deco, &flags, NULL);
1649
1650         schem->placeOnMap(map, p, flags, (Rotation)rot, force_placement);
1651
1652         lua_pushboolean(L, true);
1653         return 1;
1654 }
1655
1656
1657 // place_schematic_on_vmanip(vm, p, schematic, rotation,
1658 //     replacements, force_placement, flagstring)
1659 int ModApiMapgen::l_place_schematic_on_vmanip(lua_State *L)
1660 {
1661         NO_MAP_LOCK_REQUIRED;
1662
1663         SchematicManager *schemmgr = getServer(L)->getEmergeManager()->schemmgr;
1664
1665         //// Read VoxelManip object
1666         MMVManip *vm = LuaVoxelManip::checkobject(L, 1)->vm;
1667
1668         //// Read position
1669         v3s16 p = check_v3s16(L, 2);
1670
1671         //// Read rotation
1672         int rot = ROTATE_0;
1673         std::string enumstr = readParam<std::string>(L, 4, "");
1674         if (!enumstr.empty())
1675                 string_to_enum(es_Rotation, rot, std::string(enumstr));
1676
1677         //// Read force placement
1678         bool force_placement = true;
1679         if (lua_isboolean(L, 6))
1680                 force_placement = readParam<bool>(L, 6);
1681
1682         //// Read node replacements
1683         StringMap replace_names;
1684         if (lua_istable(L, 5))
1685                 read_schematic_replacements(L, 5, &replace_names);
1686
1687         //// Read schematic
1688         Schematic *schem = get_or_load_schematic(L, 3, schemmgr, &replace_names);
1689         if (!schem) {
1690                 errorstream << "place_schematic: failed to get schematic" << std::endl;
1691                 return 0;
1692         }
1693
1694         //// Read flags
1695         u32 flags = 0;
1696         read_flags(L, 7, flagdesc_deco, &flags, NULL);
1697
1698         bool schematic_did_fit = schem->placeOnVManip(
1699                 vm, p, flags, (Rotation)rot, force_placement);
1700
1701         lua_pushboolean(L, schematic_did_fit);
1702         return 1;
1703 }
1704
1705
1706 // serialize_schematic(schematic, format, options={...})
1707 int ModApiMapgen::l_serialize_schematic(lua_State *L)
1708 {
1709         NO_MAP_LOCK_REQUIRED;
1710
1711         const SchematicManager *schemmgr = getServer(L)->getEmergeManager()->getSchematicManager();
1712
1713         //// Read options
1714         bool use_comments = getboolfield_default(L, 3, "lua_use_comments", false);
1715         u32 indent_spaces = getintfield_default(L, 3, "lua_num_indent_spaces", 0);
1716
1717         //// Get schematic
1718         bool was_loaded = false;
1719         const Schematic *schem = (Schematic *)get_objdef(L, 1, schemmgr);
1720         if (!schem) {
1721                 schem = load_schematic(L, 1, NULL, NULL);
1722                 was_loaded = true;
1723         }
1724         if (!schem) {
1725                 errorstream << "serialize_schematic: failed to get schematic" << std::endl;
1726                 return 0;
1727         }
1728
1729         //// Read format of definition to save as
1730         int schem_format = SCHEM_FMT_MTS;
1731         std::string enumstr = readParam<std::string>(L, 2, "");
1732         if (!enumstr.empty())
1733                 string_to_enum(es_SchematicFormatType, schem_format, enumstr);
1734
1735         //// Serialize to binary string
1736         std::ostringstream os(std::ios_base::binary);
1737         switch (schem_format) {
1738         case SCHEM_FMT_MTS:
1739                 schem->serializeToMts(&os, schem->m_nodenames);
1740                 break;
1741         case SCHEM_FMT_LUA:
1742                 schem->serializeToLua(&os, schem->m_nodenames,
1743                         use_comments, indent_spaces);
1744                 break;
1745         default:
1746                 return 0;
1747         }
1748
1749         if (was_loaded)
1750                 delete schem;
1751
1752         std::string ser = os.str();
1753         lua_pushlstring(L, ser.c_str(), ser.length());
1754         return 1;
1755 }
1756
1757 // read_schematic(schematic, options={...})
1758 int ModApiMapgen::l_read_schematic(lua_State *L)
1759 {
1760         NO_MAP_LOCK_REQUIRED;
1761
1762         const SchematicManager *schemmgr =
1763                 getServer(L)->getEmergeManager()->getSchematicManager();
1764
1765         //// Read options
1766         std::string write_yslice = getstringfield_default(L, 2, "write_yslice_prob", "all");
1767
1768         //// Get schematic
1769         bool was_loaded = false;
1770         Schematic *schem = (Schematic *)get_objdef(L, 1, schemmgr);
1771         if (!schem) {
1772                 schem = load_schematic(L, 1, NULL, NULL);
1773                 was_loaded = true;
1774         }
1775         if (!schem) {
1776                 errorstream << "read_schematic: failed to get schematic" << std::endl;
1777                 return 0;
1778         }
1779         lua_pop(L, 2);
1780
1781         //// Create the Lua table
1782         u32 numnodes = schem->size.X * schem->size.Y * schem->size.Z;
1783         const std::vector<std::string> &names = schem->m_nodenames;
1784
1785         lua_createtable(L, 0, (write_yslice == "none") ? 2 : 3);
1786
1787         // Create the size field
1788         push_v3s16(L, schem->size);
1789         lua_setfield(L, 1, "size");
1790
1791         // Create the yslice_prob field
1792         if (write_yslice != "none") {
1793                 lua_createtable(L, schem->size.Y, 0);
1794                 for (u16 y = 0; y != schem->size.Y; ++y) {
1795                         u8 probability = schem->slice_probs[y] & MTSCHEM_PROB_MASK;
1796                         if (probability < MTSCHEM_PROB_ALWAYS || write_yslice != "low") {
1797                                 lua_createtable(L, 0, 2);
1798                                 lua_pushinteger(L, y);
1799                                 lua_setfield(L, 3, "ypos");
1800                                 lua_pushinteger(L, probability * 2);
1801                                 lua_setfield(L, 3, "prob");
1802                                 lua_rawseti(L, 2, y + 1);
1803                         }
1804                 }
1805                 lua_setfield(L, 1, "yslice_prob");
1806         }
1807
1808         // Create the data field
1809         lua_createtable(L, numnodes, 0); // data table
1810         for (u32 i = 0; i < numnodes; ++i) {
1811                 MapNode node = schem->schemdata[i];
1812                 u8 probability   = node.param1 & MTSCHEM_PROB_MASK;
1813                 bool force_place = node.param1 & MTSCHEM_FORCE_PLACE;
1814                 lua_createtable(L, 0, force_place ? 4 : 3);
1815                 lua_pushstring(L, names[schem->schemdata[i].getContent()].c_str());
1816                 lua_setfield(L, 3, "name");
1817                 lua_pushinteger(L, probability * 2);
1818                 lua_setfield(L, 3, "prob");
1819                 lua_pushinteger(L, node.param2);
1820                 lua_setfield(L, 3, "param2");
1821                 if (force_place) {
1822                         lua_pushboolean(L, 1);
1823                         lua_setfield(L, 3, "force_place");
1824                 }
1825                 lua_rawseti(L, 2, i + 1);
1826         }
1827         lua_setfield(L, 1, "data");
1828
1829         if (was_loaded)
1830                 delete schem;
1831
1832         return 1;
1833 }
1834
1835
1836 void ModApiMapgen::Initialize(lua_State *L, int top)
1837 {
1838         API_FCT(get_biome_id);
1839         API_FCT(get_biome_name);
1840         API_FCT(get_heat);
1841         API_FCT(get_humidity);
1842         API_FCT(get_biome_data);
1843         API_FCT(get_mapgen_object);
1844         API_FCT(get_spawn_level);
1845
1846         API_FCT(get_mapgen_params);
1847         API_FCT(set_mapgen_params);
1848         API_FCT(get_mapgen_setting);
1849         API_FCT(set_mapgen_setting);
1850         API_FCT(get_mapgen_setting_noiseparams);
1851         API_FCT(set_mapgen_setting_noiseparams);
1852         API_FCT(set_noiseparams);
1853         API_FCT(get_noiseparams);
1854         API_FCT(set_gen_notify);
1855         API_FCT(get_gen_notify);
1856         API_FCT(get_decoration_id);
1857
1858         API_FCT(register_biome);
1859         API_FCT(register_decoration);
1860         API_FCT(register_ore);
1861         API_FCT(register_schematic);
1862
1863         API_FCT(clear_registered_biomes);
1864         API_FCT(clear_registered_decorations);
1865         API_FCT(clear_registered_ores);
1866         API_FCT(clear_registered_schematics);
1867
1868         API_FCT(generate_ores);
1869         API_FCT(generate_decorations);
1870         API_FCT(create_schematic);
1871         API_FCT(place_schematic);
1872         API_FCT(place_schematic_on_vmanip);
1873         API_FCT(serialize_schematic);
1874         API_FCT(read_schematic);
1875 }