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<u8> *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<u8> *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         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         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         if (!heat)
 555                 return 0;
 556
 557         lua_pushnumber(L, heat);
 558
 559         return 1;
 560 }
 561
 562
 563 // get_humidity(pos)
 564 // returns the humidity at the position
 565 int ModApiMapgen::l_get_humidity(lua_State *L)
 566 {
 567         NO_MAP_LOCK_REQUIRED;
 568
 569         v3s16 pos = read_v3s16(L, 1);
 570
 571         NoiseParams np_humidity;
 572         NoiseParams np_humidity_blend;
 573
 574         MapSettingsManager *settingsmgr =
 575                 getServer(L)->getEmergeManager()->map_settings_mgr;
 576
 577         if (!settingsmgr->getMapSettingNoiseParams("mg_biome_np_humidity",
 578                         &np_humidity) ||
 579                         !settingsmgr->getMapSettingNoiseParams("mg_biome_np_humidity_blend",
 580                         &np_humidity_blend))
 581                 return 0;
 582
 583         std::string value;
 584         if (!settingsmgr->getMapSetting("seed", &value))
 585                 return 0;
 586         std::istringstream ss(value);
 587         u64 seed;
 588         ss >> seed;
 589
 590         const BiomeManager *bmgr = getServer(L)->getEmergeManager()->getBiomeManager();
 591         if (!bmgr)
 592                 return 0;
 593
 594         float humidity = bmgr->getHumidityAtPosOriginal(pos, np_humidity,
 595                 np_humidity_blend, seed);
 596         if (!humidity)
 597                 return 0;
 598
 599         lua_pushnumber(L, humidity);
 600
 601         return 1;
 602 }
 603
 604
 605 // get_biome_data(pos)
 606 // returns a table containing the biome id, heat and humidity at the position
 607 int ModApiMapgen::l_get_biome_data(lua_State *L)
 608 {
 609         NO_MAP_LOCK_REQUIRED;
 610
 611         v3s16 pos = read_v3s16(L, 1);
 612
 613         NoiseParams np_heat;
 614         NoiseParams np_heat_blend;
 615         NoiseParams np_humidity;
 616         NoiseParams np_humidity_blend;
 617
 618         MapSettingsManager *settingsmgr =
 619                 getServer(L)->getEmergeManager()->map_settings_mgr;
 620
 621         if (!settingsmgr->getMapSettingNoiseParams("mg_biome_np_heat",
 622                         &np_heat) ||
 623                         !settingsmgr->getMapSettingNoiseParams("mg_biome_np_heat_blend",
 624                         &np_heat_blend) ||
 625                         !settingsmgr->getMapSettingNoiseParams("mg_biome_np_humidity",
 626                         &np_humidity) ||
 627                         !settingsmgr->getMapSettingNoiseParams("mg_biome_np_humidity_blend",
 628                         &np_humidity_blend))
 629                 return 0;
 630
 631         std::string value;
 632         if (!settingsmgr->getMapSetting("seed", &value))
 633                 return 0;
 634         std::istringstream ss(value);
 635         u64 seed;
 636         ss >> seed;
 637
 638         const BiomeManager *bmgr = getServer(L)->getEmergeManager()->getBiomeManager();
 639         if (!bmgr)
 640                 return 0;
 641
 642         float heat = bmgr->getHeatAtPosOriginal(pos, np_heat, np_heat_blend, seed);
 643         if (!heat)
 644                 return 0;
 645
 646         float humidity = bmgr->getHumidityAtPosOriginal(pos, np_humidity,
 647                 np_humidity_blend, seed);
 648         if (!humidity)
 649                 return 0;
 650
 651         Biome *biome = (Biome *)bmgr->getBiomeFromNoiseOriginal(heat, humidity, pos);
 652         if (!biome || biome->index == OBJDEF_INVALID_INDEX)
 653                 return 0;
 654
 655         lua_newtable(L);
 656
 657         lua_pushinteger(L, biome->index);
 658         lua_setfield(L, -2, "biome");
 659
 660         lua_pushnumber(L, heat);
 661         lua_setfield(L, -2, "heat");
 662
 663         lua_pushnumber(L, humidity);
 664         lua_setfield(L, -2, "humidity");
 665
 666         return 1;
 667 }
 668
 669
 670 // get_mapgen_object(objectname)
 671 // returns the requested object used during map generation
 672 int ModApiMapgen::l_get_mapgen_object(lua_State *L)
 673 {
 674         NO_MAP_LOCK_REQUIRED;
 675
 676         const char *mgobjstr = lua_tostring(L, 1);
 677
 678         int mgobjint;
 679         if (!string_to_enum(es_MapgenObject, mgobjint, mgobjstr ? mgobjstr : ""))
 680                 return 0;
 681
 682         enum MapgenObject mgobj = (MapgenObject)mgobjint;
 683
 684         EmergeManager *emerge = getServer(L)->getEmergeManager();
 685         Mapgen *mg = emerge->getCurrentMapgen();
 686         if (!mg)
 687                 throw LuaError("Must only be called in a mapgen thread!");
 688
 689         size_t maplen = mg->csize.X * mg->csize.Z;
 690
 691         switch (mgobj) {
 692         case MGOBJ_VMANIP: {
 693                 MMVManip *vm = mg->vm;
 694
 695                 // VoxelManip object
 696                 LuaVoxelManip *o = new LuaVoxelManip(vm, true);
 697                 *(void **)(lua_newuserdata(L, sizeof(void *))) = o;
 698                 luaL_getmetatable(L, "VoxelManip");
 699                 lua_setmetatable(L, -2);
 700
 701                 // emerged min pos
 702                 push_v3s16(L, vm->m_area.MinEdge);
 703
 704                 // emerged max pos
 705                 push_v3s16(L, vm->m_area.MaxEdge);
 706
 707                 return 3;
 708         }
 709         case MGOBJ_HEIGHTMAP: {
 710                 if (!mg->heightmap)
 711                         return 0;
 712
 713                 lua_createtable(L, maplen, 0);
 714                 for (size_t i = 0; i != maplen; i++) {
 715                         lua_pushinteger(L, mg->heightmap[i]);
 716                         lua_rawseti(L, -2, i + 1);
 717                 }
 718
 719                 return 1;
 720         }
 721         case MGOBJ_BIOMEMAP: {
 722                 if (!mg->biomegen)
 723                         return 0;
 724
 725                 lua_createtable(L, maplen, 0);
 726                 for (size_t i = 0; i != maplen; i++) {
 727                         lua_pushinteger(L, mg->biomegen->biomemap[i]);
 728                         lua_rawseti(L, -2, i + 1);
 729                 }
 730
 731                 return 1;
 732         }
 733         case MGOBJ_HEATMAP: {
 734                 if (!mg->biomegen || mg->biomegen->getType() != BIOMEGEN_ORIGINAL)
 735                         return 0;
 736
 737                 BiomeGenOriginal *bg = (BiomeGenOriginal *)mg->biomegen;
 738
 739                 lua_createtable(L, maplen, 0);
 740                 for (size_t i = 0; i != maplen; i++) {
 741                         lua_pushnumber(L, bg->heatmap[i]);
 742                         lua_rawseti(L, -2, i + 1);
 743                 }
 744
 745                 return 1;
 746         }
 747
 748         case MGOBJ_HUMIDMAP: {
 749                 if (!mg->biomegen || mg->biomegen->getType() != BIOMEGEN_ORIGINAL)
 750                         return 0;
 751
 752                 BiomeGenOriginal *bg = (BiomeGenOriginal *)mg->biomegen;
 753
 754                 lua_createtable(L, maplen, 0);
 755                 for (size_t i = 0; i != maplen; i++) {
 756                         lua_pushnumber(L, bg->humidmap[i]);
 757                         lua_rawseti(L, -2, i + 1);
 758                 }
 759
 760                 return 1;
 761         }
 762         case MGOBJ_GENNOTIFY: {
 763                 std::map<std::string, std::vector<v3s16> >event_map;
 764
 765                 mg->gennotify.getEvents(event_map);
 766
 767                 lua_createtable(L, 0, event_map.size());
 768                 for (auto it = event_map.begin(); it != event_map.end(); ++it) {
 769                         lua_createtable(L, it->second.size(), 0);
 770
 771                         for (size_t j = 0; j != it->second.size(); j++) {
 772                                 push_v3s16(L, it->second[j]);
 773                                 lua_rawseti(L, -2, j + 1);
 774                         }
 775
 776                         lua_setfield(L, -2, it->first.c_str());
 777                 }
 778
 779                 return 1;
 780         }
 781         }
 782
 783         return 0;
 784 }
 785
 786
 787 // get_spawn_level(x = num, z = num)
 788 int ModApiMapgen::l_get_spawn_level(lua_State *L)
 789 {
 790         NO_MAP_LOCK_REQUIRED;
 791
 792         s16 x = luaL_checkinteger(L, 1);
 793         s16 z = luaL_checkinteger(L, 2);
 794
 795         EmergeManager *emerge = getServer(L)->getEmergeManager();
 796         int spawn_level = emerge->getSpawnLevelAtPoint(v2s16(x, z));
 797         // Unsuitable spawn point
 798         if (spawn_level == MAX_MAP_GENERATION_LIMIT)
 799                 return 0;
 800
 801         // 'findSpawnPos()' in server.cpp adds at least 1
 802         lua_pushinteger(L, spawn_level + 1);
 803
 804         return 1;
 805 }
 806
 807
 808 int ModApiMapgen::l_get_mapgen_params(lua_State *L)
 809 {
 810         NO_MAP_LOCK_REQUIRED;
 811
 812         log_deprecated(L, "get_mapgen_params is deprecated; "
 813                 "use get_mapgen_setting instead");
 814
 815         std::string value;
 816
 817         MapSettingsManager *settingsmgr =
 818                 getServer(L)->getEmergeManager()->map_settings_mgr;
 819
 820         lua_newtable(L);
 821
 822         settingsmgr->getMapSetting("mg_name", &value);
 823         lua_pushstring(L, value.c_str());
 824         lua_setfield(L, -2, "mgname");
 825
 826         settingsmgr->getMapSetting("seed", &value);
 827         std::istringstream ss(value);
 828         u64 seed;
 829         ss >> seed;
 830         lua_pushinteger(L, seed);
 831         lua_setfield(L, -2, "seed");
 832
 833         settingsmgr->getMapSetting("water_level", &value);
 834         lua_pushinteger(L, stoi(value, -32768, 32767));
 835         lua_setfield(L, -2, "water_level");
 836
 837         settingsmgr->getMapSetting("chunksize", &value);
 838         lua_pushinteger(L, stoi(value, -32768, 32767));
 839         lua_setfield(L, -2, "chunksize");
 840
 841         settingsmgr->getMapSetting("mg_flags", &value);
 842         lua_pushstring(L, value.c_str());
 843         lua_setfield(L, -2, "flags");
 844
 845         return 1;
 846 }
 847
 848
 849 // set_mapgen_params(params)
 850 // set mapgen parameters
 851 int ModApiMapgen::l_set_mapgen_params(lua_State *L)
 852 {
 853         NO_MAP_LOCK_REQUIRED;
 854
 855         log_deprecated(L, "set_mapgen_params is deprecated; "
 856                 "use set_mapgen_setting instead");
 857
 858         if (!lua_istable(L, 1))
 859                 return 0;
 860
 861         MapSettingsManager *settingsmgr =
 862                 getServer(L)->getEmergeManager()->map_settings_mgr;
 863
 864         lua_getfield(L, 1, "mgname");
 865         if (lua_isstring(L, -1))
 866                 settingsmgr->setMapSetting("mg_name", readParam<std::string>(L, -1), true);
 867
 868         lua_getfield(L, 1, "seed");
 869         if (lua_isnumber(L, -1))
 870                 settingsmgr->setMapSetting("seed", readParam<std::string>(L, -1), true);
 871
 872         lua_getfield(L, 1, "water_level");
 873         if (lua_isnumber(L, -1))
 874                 settingsmgr->setMapSetting("water_level", readParam<std::string>(L, -1), true);
 875
 876         lua_getfield(L, 1, "chunksize");
 877         if (lua_isnumber(L, -1))
 878                 settingsmgr->setMapSetting("chunksize", readParam<std::string>(L, -1), true);
 879
 880         warn_if_field_exists(L, 1, "flagmask",
 881                 "Obsolete: flags field now includes unset flags.");
 882
 883         lua_getfield(L, 1, "flags");
 884         if (lua_isstring(L, -1))
 885                 settingsmgr->setMapSetting("mg_flags", readParam<std::string>(L, -1), true);
 886
 887         return 0;
 888 }
 889
 890 // get_mapgen_setting(name)
 891 int ModApiMapgen::l_get_mapgen_setting(lua_State *L)
 892 {
 893         NO_MAP_LOCK_REQUIRED;
 894
 895         std::string value;
 896         MapSettingsManager *settingsmgr =
 897                 getServer(L)->getEmergeManager()->map_settings_mgr;
 898
 899         const char *name = luaL_checkstring(L, 1);
 900         if (!settingsmgr->getMapSetting(name, &value))
 901                 return 0;
 902
 903         lua_pushstring(L, value.c_str());
 904         return 1;
 905 }
 906
 907 // get_mapgen_setting_noiseparams(name)
 908 int ModApiMapgen::l_get_mapgen_setting_noiseparams(lua_State *L)
 909 {
 910         NO_MAP_LOCK_REQUIRED;
 911
 912         NoiseParams np;
 913         MapSettingsManager *settingsmgr =
 914                 getServer(L)->getEmergeManager()->map_settings_mgr;
 915
 916         const char *name = luaL_checkstring(L, 1);
 917         if (!settingsmgr->getMapSettingNoiseParams(name, &np))
 918                 return 0;
 919
 920         push_noiseparams(L, &np);
 921         return 1;
 922 }
 923
 924 // set_mapgen_setting(name, value, override_meta)
 925 // set mapgen config values
 926 int ModApiMapgen::l_set_mapgen_setting(lua_State *L)
 927 {
 928         NO_MAP_LOCK_REQUIRED;
 929
 930         MapSettingsManager *settingsmgr =
 931                 getServer(L)->getEmergeManager()->map_settings_mgr;
 932
 933         const char *name   = luaL_checkstring(L, 1);
 934         const char *value  = luaL_checkstring(L, 2);
 935         bool override_meta = readParam<bool>(L, 3, false);
 936
 937         if (!settingsmgr->setMapSetting(name, value, override_meta)) {
 938                 errorstream << "set_mapgen_setting: cannot set '"
 939                         << name << "' after initialization" << std::endl;
 940         }
 941
 942         return 0;
 943 }
 944
 945
 946 // set_mapgen_setting_noiseparams(name, noiseparams, set_default)
 947 // set mapgen config values for noise parameters
 948 int ModApiMapgen::l_set_mapgen_setting_noiseparams(lua_State *L)
 949 {
 950         NO_MAP_LOCK_REQUIRED;
 951
 952         MapSettingsManager *settingsmgr =
 953                 getServer(L)->getEmergeManager()->map_settings_mgr;
 954
 955         const char *name = luaL_checkstring(L, 1);
 956
 957         NoiseParams np;
 958         if (!read_noiseparams(L, 2, &np)) {
 959                 errorstream << "set_mapgen_setting_noiseparams: cannot set '" << name
 960                         << "'; invalid noiseparams table" << std::endl;
 961                 return 0;
 962         }
 963
 964         bool override_meta = readParam<bool>(L, 3, false);
 965
 966         if (!settingsmgr->setMapSettingNoiseParams(name, &np, override_meta)) {
 967                 errorstream << "set_mapgen_setting_noiseparams: cannot set '"
 968                         << name << "' after initialization" << std::endl;
 969         }
 970
 971         return 0;
 972 }
 973
 974
 975 // set_noiseparams(name, noiseparams, set_default)
 976 // set global config values for noise parameters
 977 int ModApiMapgen::l_set_noiseparams(lua_State *L)
 978 {
 979         NO_MAP_LOCK_REQUIRED;
 980
 981         const char *name = luaL_checkstring(L, 1);
 982
 983         NoiseParams np;
 984         if (!read_noiseparams(L, 2, &np)) {
 985                 errorstream << "set_noiseparams: cannot set '" << name
 986                         << "'; invalid noiseparams table" << std::endl;
 987                 return 0;
 988         }
 989
 990         bool set_default = !lua_isboolean(L, 3) || readParam<bool>(L, 3);
 991
 992         g_settings->setNoiseParams(name, np, set_default);
 993
 994         return 0;
 995 }
 996
 997
 998 // get_noiseparams(name)
 999 int ModApiMapgen::l_get_noiseparams(lua_State *L)
1000 {
1001         NO_MAP_LOCK_REQUIRED;
1002
1003         std::string name = luaL_checkstring(L, 1);
1004
1005         NoiseParams np;
1006         if (!g_settings->getNoiseParams(name, np))
1007                 return 0;
1008
1009         push_noiseparams(L, &np);
1010         return 1;
1011 }
1012
1013
1014 // set_gen_notify(flags, {deco_id_table})
1015 int ModApiMapgen::l_set_gen_notify(lua_State *L)
1016 {
1017         NO_MAP_LOCK_REQUIRED;
1018
1019         u32 flags = 0, flagmask = 0;
1020         EmergeManager *emerge = getServer(L)->getEmergeManager();
1021
1022         if (read_flags(L, 1, flagdesc_gennotify, &flags, &flagmask)) {
1023                 emerge->gen_notify_on &= ~flagmask;
1024                 emerge->gen_notify_on |= flags;
1025         }
1026
1027         if (lua_istable(L, 2)) {
1028                 lua_pushnil(L);
1029                 while (lua_next(L, 2)) {
1030                         if (lua_isnumber(L, -1))
1031                                 emerge->gen_notify_on_deco_ids.insert((u32)lua_tonumber(L, -1));
1032                         lua_pop(L, 1);
1033                 }
1034         }
1035
1036         return 0;
1037 }
1038
1039
1040 // get_gen_notify()
1041 int ModApiMapgen::l_get_gen_notify(lua_State *L)
1042 {
1043         NO_MAP_LOCK_REQUIRED;
1044
1045         EmergeManager *emerge = getServer(L)->getEmergeManager();
1046         push_flags_string(L, flagdesc_gennotify, emerge->gen_notify_on,
1047                 emerge->gen_notify_on);
1048
1049         lua_newtable(L);
1050         int i = 1;
1051         for (u32 gen_notify_on_deco_id : emerge->gen_notify_on_deco_ids) {
1052                 lua_pushnumber(L, gen_notify_on_deco_id);
1053                 lua_rawseti(L, -2, i++);
1054         }
1055         return 2;
1056 }
1057
1058
1059 // get_decoration_id(decoration_name)
1060 // returns the decoration ID as used in gennotify
1061 int ModApiMapgen::l_get_decoration_id(lua_State *L)
1062 {
1063         NO_MAP_LOCK_REQUIRED;
1064
1065         const char *deco_str = luaL_checkstring(L, 1);
1066         if (!deco_str)
1067                 return 0;
1068
1069         const DecorationManager *dmgr =
1070                 getServer(L)->getEmergeManager()->getDecorationManager();
1071
1072         if (!dmgr)
1073                 return 0;
1074
1075         Decoration *deco = (Decoration *)dmgr->getByName(deco_str);
1076
1077         if (!deco)
1078                 return 0;
1079
1080         lua_pushinteger(L, deco->index);
1081
1082         return 1;
1083 }
1084
1085
1086 // register_biome({lots of stuff})
1087 int ModApiMapgen::l_register_biome(lua_State *L)
1088 {
1089         NO_MAP_LOCK_REQUIRED;
1090
1091         int index = 1;
1092         luaL_checktype(L, index, LUA_TTABLE);
1093
1094         const NodeDefManager *ndef = getServer(L)->getNodeDefManager();
1095         BiomeManager *bmgr = getServer(L)->getEmergeManager()->getWritableBiomeManager();
1096
1097         Biome *biome = read_biome_def(L, index, ndef);
1098         if (!biome)
1099                 return 0;
1100
1101         ObjDefHandle handle = bmgr->add(biome);
1102         if (handle == OBJDEF_INVALID_HANDLE) {
1103                 delete biome;
1104                 return 0;
1105         }
1106
1107         lua_pushinteger(L, handle);
1108         return 1;
1109 }
1110
1111
1112 // register_decoration({lots of stuff})
1113 int ModApiMapgen::l_register_decoration(lua_State *L)
1114 {
1115         NO_MAP_LOCK_REQUIRED;
1116
1117         int index = 1;
1118         luaL_checktype(L, index, LUA_TTABLE);
1119
1120         const NodeDefManager *ndef      = getServer(L)->getNodeDefManager();
1121         EmergeManager *emerge = getServer(L)->getEmergeManager();
1122         DecorationManager *decomgr = emerge->getWritableDecorationManager();
1123         BiomeManager *biomemgr     = emerge->getWritableBiomeManager();
1124         SchematicManager *schemmgr = emerge->getWritableSchematicManager();
1125
1126         enum DecorationType decotype = (DecorationType)getenumfield(L, index,
1127                                 "deco_type", es_DecorationType, -1);
1128
1129         Decoration *deco = decomgr->create(decotype);
1130         if (!deco) {
1131                 errorstream << "register_decoration: decoration placement type "
1132                         << decotype << " not implemented" << std::endl;
1133                 return 0;
1134         }
1135
1136         deco->name           = getstringfield_default(L, index, "name", "");
1137         deco->fill_ratio     = getfloatfield_default(L, index, "fill_ratio", 0.02);
1138         deco->y_min          = getintfield_default(L, index, "y_min", -31000);
1139         deco->y_max          = getintfield_default(L, index, "y_max", 31000);
1140         deco->nspawnby       = getintfield_default(L, index, "num_spawn_by", -1);
1141         deco->place_offset_y = getintfield_default(L, index, "place_offset_y", 0);
1142         deco->sidelen        = getintfield_default(L, index, "sidelen", 8);
1143         if (deco->sidelen <= 0) {
1144                 errorstream << "register_decoration: sidelen must be "
1145                         "greater than 0" << std::endl;
1146                 delete deco;
1147                 return 0;
1148         }
1149
1150         //// Get node name(s) to place decoration on
1151         size_t nread = getstringlistfield(L, index, "place_on", &deco->m_nodenames);
1152         deco->m_nnlistsizes.push_back(nread);
1153
1154         //// Get decoration flags
1155         getflagsfield(L, index, "flags", flagdesc_deco, &deco->flags, NULL);
1156
1157         //// Get NoiseParams to define how decoration is placed
1158         lua_getfield(L, index, "noise_params");
1159         if (read_noiseparams(L, -1, &deco->np))
1160                 deco->flags |= DECO_USE_NOISE;
1161         lua_pop(L, 1);
1162
1163         //// Get biomes associated with this decoration (if any)
1164         lua_getfield(L, index, "biomes");
1165         if (get_biome_list(L, -1, biomemgr, &deco->biomes))
1166                 infostream << "register_decoration: couldn't get all biomes " << std::endl;
1167         lua_pop(L, 1);
1168
1169         //// Get node name(s) to 'spawn by'
1170         size_t nnames = getstringlistfield(L, index, "spawn_by", &deco->m_nodenames);
1171         deco->m_nnlistsizes.push_back(nnames);
1172         if (nnames == 0 && deco->nspawnby != -1) {
1173                 errorstream << "register_decoration: no spawn_by nodes defined,"
1174                         " but num_spawn_by specified" << std::endl;
1175         }
1176
1177         //// Handle decoration type-specific parameters
1178         bool success = false;
1179         switch (decotype) {
1180         case DECO_SIMPLE:
1181                 success = read_deco_simple(L, (DecoSimple *)deco);
1182                 break;
1183         case DECO_SCHEMATIC:
1184                 success = read_deco_schematic(L, schemmgr, (DecoSchematic *)deco);
1185                 break;
1186         case DECO_LSYSTEM:
1187                 break;
1188         }
1189
1190         if (!success) {
1191                 delete deco;
1192                 return 0;
1193         }
1194
1195         ndef->pendNodeResolve(deco);
1196
1197         ObjDefHandle handle = decomgr->add(deco);
1198         if (handle == OBJDEF_INVALID_HANDLE) {
1199                 delete deco;
1200                 return 0;
1201         }
1202
1203         lua_pushinteger(L, handle);
1204         return 1;
1205 }
1206
1207
1208 bool read_deco_simple(lua_State *L, DecoSimple *deco)
1209 {
1210         int index = 1;
1211         int param2;
1212         int param2_max;
1213
1214         deco->deco_height     = getintfield_default(L, index, "height", 1);
1215         deco->deco_height_max = getintfield_default(L, index, "height_max", 0);
1216
1217         if (deco->deco_height <= 0) {
1218                 errorstream << "register_decoration: simple decoration height"
1219                         " must be greater than 0" << std::endl;
1220                 return false;
1221         }
1222
1223         size_t nnames = getstringlistfield(L, index, "decoration", &deco->m_nodenames);
1224         deco->m_nnlistsizes.push_back(nnames);
1225
1226         if (nnames == 0) {
1227                 errorstream << "register_decoration: no decoration nodes "
1228                         "defined" << std::endl;
1229                 return false;
1230         }
1231
1232         param2 = getintfield_default(L, index, "param2", 0);
1233         param2_max = getintfield_default(L, index, "param2_max", 0);
1234
1235         if (param2 < 0 || param2 > 255 || param2_max < 0 || param2_max > 255) {
1236                 errorstream << "register_decoration: param2 or param2_max out of bounds (0-255)"
1237                         << std::endl;
1238                 return false;
1239         }
1240
1241         deco->deco_param2 = (u8)param2;
1242         deco->deco_param2_max = (u8)param2_max;
1243
1244         return true;
1245 }
1246
1247
1248 bool read_deco_schematic(lua_State *L, SchematicManager *schemmgr, DecoSchematic *deco)
1249 {
1250         int index = 1;
1251
1252         deco->rotation = (Rotation)getenumfield(L, index, "rotation",
1253                 ModApiMapgen::es_Rotation, ROTATE_0);
1254
1255         StringMap replace_names;
1256         lua_getfield(L, index, "replacements");
1257         if (lua_istable(L, -1))
1258                 read_schematic_replacements(L, -1, &replace_names);
1259         lua_pop(L, 1);
1260
1261         lua_getfield(L, index, "schematic");
1262         Schematic *schem = get_or_load_schematic(L, -1, schemmgr, &replace_names);
1263         lua_pop(L, 1);
1264
1265         deco->schematic = schem;
1266         return schem != NULL;
1267 }
1268
1269
1270 // register_ore({lots of stuff})
1271 int ModApiMapgen::l_register_ore(lua_State *L)
1272 {
1273         NO_MAP_LOCK_REQUIRED;
1274
1275         int index = 1;
1276         luaL_checktype(L, index, LUA_TTABLE);
1277
1278         const NodeDefManager *ndef = getServer(L)->getNodeDefManager();
1279         EmergeManager *emerge = getServer(L)->getEmergeManager();
1280         BiomeManager *bmgr    = emerge->getWritableBiomeManager();
1281         OreManager *oremgr    = emerge->getWritableOreManager();
1282
1283         enum OreType oretype = (OreType)getenumfield(L, index,
1284                                 "ore_type", es_OreType, ORE_SCATTER);
1285         Ore *ore = oremgr->create(oretype);
1286         if (!ore) {
1287                 errorstream << "register_ore: ore_type " << oretype << " not implemented\n";
1288                 return 0;
1289         }
1290
1291         ore->name           = getstringfield_default(L, index, "name", "");
1292         ore->ore_param2     = (u8)getintfield_default(L, index, "ore_param2", 0);
1293         ore->clust_scarcity = getintfield_default(L, index, "clust_scarcity", 1);
1294         ore->clust_num_ores = getintfield_default(L, index, "clust_num_ores", 1);
1295         ore->clust_size     = getintfield_default(L, index, "clust_size", 0);
1296         ore->noise          = NULL;
1297         ore->flags          = 0;
1298
1299         //// Get noise_threshold
1300         warn_if_field_exists(L, index, "noise_threshhold",
1301                 "Deprecated: new name is \"noise_threshold\".");
1302
1303         float nthresh;
1304         if (!getfloatfield(L, index, "noise_threshold", nthresh) &&
1305                         !getfloatfield(L, index, "noise_threshhold", nthresh))
1306                 nthresh = 0;
1307         ore->nthresh = nthresh;
1308
1309         //// Get y_min/y_max
1310         warn_if_field_exists(L, index, "height_min",
1311                 "Deprecated: new name is \"y_min\".");
1312         warn_if_field_exists(L, index, "height_max",
1313                 "Deprecated: new name is \"y_max\".");
1314
1315         int ymin, ymax;
1316         if (!getintfield(L, index, "y_min", ymin) &&
1317                 !getintfield(L, index, "height_min", ymin))
1318                 ymin = -31000;
1319         if (!getintfield(L, index, "y_max", ymax) &&
1320                 !getintfield(L, index, "height_max", ymax))
1321                 ymax = 31000;
1322         ore->y_min = ymin;
1323         ore->y_max = ymax;
1324
1325         if (ore->clust_scarcity <= 0 || ore->clust_num_ores <= 0) {
1326                 errorstream << "register_ore: clust_scarcity and clust_num_ores"
1327                         "must be greater than 0" << std::endl;
1328                 delete ore;
1329                 return 0;
1330         }
1331
1332         //// Get flags
1333         getflagsfield(L, index, "flags", flagdesc_ore, &ore->flags, NULL);
1334
1335         //// Get biomes associated with this decoration (if any)
1336         lua_getfield(L, index, "biomes");
1337         if (get_biome_list(L, -1, bmgr, &ore->biomes))
1338                 infostream << "register_ore: couldn't get all biomes " << std::endl;
1339         lua_pop(L, 1);
1340
1341         //// Get noise parameters if needed
1342         lua_getfield(L, index, "noise_params");
1343         if (read_noiseparams(L, -1, &ore->np)) {
1344                 ore->flags |= OREFLAG_USE_NOISE;
1345         } else if (ore->NEEDS_NOISE) {
1346                 errorstream << "register_ore: specified ore type requires valid "
1347                         "'noise_params' parameter" << std::endl;
1348                 delete ore;
1349                 return 0;
1350         }
1351         lua_pop(L, 1);
1352
1353         //// Get type-specific parameters
1354         switch (oretype) {
1355                 case ORE_SHEET: {
1356                         OreSheet *oresheet = (OreSheet *)ore;
1357
1358                         oresheet->column_height_min = getintfield_default(L, index,
1359                                 "column_height_min", 1);
1360                         oresheet->column_height_max = getintfield_default(L, index,
1361                                 "column_height_max", ore->clust_size);
1362                         oresheet->column_midpoint_factor = getfloatfield_default(L, index,
1363                                 "column_midpoint_factor", 0.5f);
1364
1365                         break;
1366                 }
1367                 case ORE_PUFF: {
1368                         OrePuff *orepuff = (OrePuff *)ore;
1369
1370                         lua_getfield(L, index, "np_puff_top");
1371                         read_noiseparams(L, -1, &orepuff->np_puff_top);
1372                         lua_pop(L, 1);
1373
1374                         lua_getfield(L, index, "np_puff_bottom");
1375                         read_noiseparams(L, -1, &orepuff->np_puff_bottom);
1376                         lua_pop(L, 1);
1377
1378                         break;
1379                 }
1380                 case ORE_VEIN: {
1381                         OreVein *orevein = (OreVein *)ore;
1382
1383                         orevein->random_factor = getfloatfield_default(L, index,
1384                                 "random_factor", 1.f);
1385
1386                         break;
1387                 }
1388                 case ORE_STRATUM: {
1389                         OreStratum *orestratum = (OreStratum *)ore;
1390
1391                         lua_getfield(L, index, "np_stratum_thickness");
1392                         if (read_noiseparams(L, -1, &orestratum->np_stratum_thickness))
1393                                 ore->flags |= OREFLAG_USE_NOISE2;
1394                         lua_pop(L, 1);
1395
1396                         orestratum->stratum_thickness = getintfield_default(L, index,
1397                                 "stratum_thickness", 8);
1398
1399                         break;
1400                 }
1401                 default:
1402                         break;
1403         }
1404
1405         ObjDefHandle handle = oremgr->add(ore);
1406         if (handle == OBJDEF_INVALID_HANDLE) {
1407                 delete ore;
1408                 return 0;
1409         }
1410
1411         ore->m_nodenames.push_back(getstringfield_default(L, index, "ore", ""));
1412
1413         size_t nnames = getstringlistfield(L, index, "wherein", &ore->m_nodenames);
1414         ore->m_nnlistsizes.push_back(nnames);
1415
1416         ndef->pendNodeResolve(ore);
1417
1418         lua_pushinteger(L, handle);
1419         return 1;
1420 }
1421
1422
1423 // register_schematic({schematic}, replacements={})
1424 int ModApiMapgen::l_register_schematic(lua_State *L)
1425 {
1426         NO_MAP_LOCK_REQUIRED;
1427
1428         SchematicManager *schemmgr =
1429                 getServer(L)->getEmergeManager()->getWritableSchematicManager();
1430
1431         StringMap replace_names;
1432         if (lua_istable(L, 2))
1433                 read_schematic_replacements(L, 2, &replace_names);
1434
1435         Schematic *schem = load_schematic(L, 1, schemmgr->getNodeDef(),
1436                 &replace_names);
1437         if (!schem)
1438                 return 0;
1439
1440         ObjDefHandle handle = schemmgr->add(schem);
1441         if (handle == OBJDEF_INVALID_HANDLE) {
1442                 delete schem;
1443                 return 0;
1444         }
1445
1446         lua_pushinteger(L, handle);
1447         return 1;
1448 }
1449
1450
1451 // clear_registered_biomes()
1452 int ModApiMapgen::l_clear_registered_biomes(lua_State *L)
1453 {
1454         NO_MAP_LOCK_REQUIRED;
1455
1456         BiomeManager *bmgr =
1457                 getServer(L)->getEmergeManager()->getWritableBiomeManager();
1458         bmgr->clear();
1459         return 0;
1460 }
1461
1462
1463 // clear_registered_decorations()
1464 int ModApiMapgen::l_clear_registered_decorations(lua_State *L)
1465 {
1466         NO_MAP_LOCK_REQUIRED;
1467
1468         DecorationManager *dmgr =
1469                 getServer(L)->getEmergeManager()->getWritableDecorationManager();
1470         dmgr->clear();
1471         return 0;
1472 }
1473
1474
1475 // clear_registered_ores()
1476 int ModApiMapgen::l_clear_registered_ores(lua_State *L)
1477 {
1478         NO_MAP_LOCK_REQUIRED;
1479
1480         OreManager *omgr =
1481                 getServer(L)->getEmergeManager()->getWritableOreManager();
1482         omgr->clear();
1483         return 0;
1484 }
1485
1486
1487 // clear_registered_schematics()
1488 int ModApiMapgen::l_clear_registered_schematics(lua_State *L)
1489 {
1490         NO_MAP_LOCK_REQUIRED;
1491
1492         SchematicManager *smgr =
1493                 getServer(L)->getEmergeManager()->getWritableSchematicManager();
1494         smgr->clear();
1495         return 0;
1496 }
1497
1498
1499 // generate_ores(vm, p1, p2, [ore_id])
1500 int ModApiMapgen::l_generate_ores(lua_State *L)
1501 {
1502         NO_MAP_LOCK_REQUIRED;
1503
1504         EmergeManager *emerge = getServer(L)->getEmergeManager();
1505
1506         Mapgen mg;
1507         mg.seed = emerge->mgparams->seed;
1508         mg.vm   = LuaVoxelManip::checkobject(L, 1)->vm;
1509         mg.ndef = getServer(L)->getNodeDefManager();
1510
1511         v3s16 pmin = lua_istable(L, 2) ? check_v3s16(L, 2) :
1512                         mg.vm->m_area.MinEdge + v3s16(1,1,1) * MAP_BLOCKSIZE;
1513         v3s16 pmax = lua_istable(L, 3) ? check_v3s16(L, 3) :
1514                         mg.vm->m_area.MaxEdge - v3s16(1,1,1) * MAP_BLOCKSIZE;
1515         sortBoxVerticies(pmin, pmax);
1516
1517         u32 blockseed = Mapgen::getBlockSeed(pmin, mg.seed);
1518
1519         OreManager *oremgr = (OreManager*) emerge->getOreManager(); // FIXME FIXME
1520         oremgr->placeAllOres(&mg, blockseed, pmin, pmax);
1521
1522         return 0;
1523 }
1524
1525
1526 // generate_decorations(vm, p1, p2, [deco_id])
1527 int ModApiMapgen::l_generate_decorations(lua_State *L)
1528 {
1529         NO_MAP_LOCK_REQUIRED;
1530
1531         EmergeManager *emerge = getServer(L)->getEmergeManager();
1532
1533         Mapgen mg;
1534         mg.seed = emerge->mgparams->seed;
1535         mg.vm   = LuaVoxelManip::checkobject(L, 1)->vm;
1536         mg.ndef = getServer(L)->getNodeDefManager();
1537
1538         v3s16 pmin = lua_istable(L, 2) ? check_v3s16(L, 2) :
1539                         mg.vm->m_area.MinEdge + v3s16(1,1,1) * MAP_BLOCKSIZE;
1540         v3s16 pmax = lua_istable(L, 3) ? check_v3s16(L, 3) :
1541                         mg.vm->m_area.MaxEdge - v3s16(1,1,1) * MAP_BLOCKSIZE;
1542         sortBoxVerticies(pmin, pmax);
1543
1544         u32 blockseed = Mapgen::getBlockSeed(pmin, mg.seed);
1545
1546         DecorationManager *decomgr = (DecorationManager*) emerge->getDecorationManager(); // FIXME FIXME
1547         decomgr->placeAllDecos(&mg, blockseed, pmin, pmax);
1548
1549         return 0;
1550 }
1551
1552
1553 // create_schematic(p1, p2, probability_list, filename, y_slice_prob_list)
1554 int ModApiMapgen::l_create_schematic(lua_State *L)
1555 {
1556         MAP_LOCK_REQUIRED;
1557
1558         const NodeDefManager *ndef = getServer(L)->getNodeDefManager();
1559
1560         const char *filename = luaL_checkstring(L, 4);
1561         CHECK_SECURE_PATH(L, filename, true);
1562
1563         Map *map = &(getEnv(L)->getMap());
1564         Schematic schem;
1565
1566         v3s16 p1 = check_v3s16(L, 1);
1567         v3s16 p2 = check_v3s16(L, 2);
1568         sortBoxVerticies(p1, p2);
1569
1570         std::vector<std::pair<v3s16, u8> > prob_list;
1571         if (lua_istable(L, 3)) {
1572                 lua_pushnil(L);
1573                 while (lua_next(L, 3)) {
1574                         if (lua_istable(L, -1)) {
1575                                 lua_getfield(L, -1, "pos");
1576                                 v3s16 pos = check_v3s16(L, -1);
1577                                 lua_pop(L, 1);
1578
1579                                 u8 prob = getintfield_default(L, -1, "prob", MTSCHEM_PROB_ALWAYS);
1580                                 prob_list.emplace_back(pos, prob);
1581                         }
1582
1583                         lua_pop(L, 1);
1584                 }
1585         }
1586
1587         std::vector<std::pair<s16, u8> > slice_prob_list;
1588         if (lua_istable(L, 5)) {
1589                 lua_pushnil(L);
1590                 while (lua_next(L, 5)) {
1591                         if (lua_istable(L, -1)) {
1592                                 s16 ypos = getintfield_default(L, -1, "ypos", 0);
1593                                 u8 prob  = getintfield_default(L, -1, "prob", MTSCHEM_PROB_ALWAYS);
1594                                 slice_prob_list.emplace_back(ypos, prob);
1595                         }
1596
1597                         lua_pop(L, 1);
1598                 }
1599         }
1600
1601         if (!schem.getSchematicFromMap(map, p1, p2)) {
1602                 errorstream << "create_schematic: failed to get schematic "
1603                         "from map" << std::endl;
1604                 return 0;
1605         }
1606
1607         schem.applyProbabilities(p1, &prob_list, &slice_prob_list);
1608
1609         schem.saveSchematicToFile(filename, ndef);
1610         actionstream << "create_schematic: saved schematic file '"
1611                 << filename << "'." << std::endl;
1612
1613         lua_pushboolean(L, true);
1614         return 1;
1615 }
1616
1617
1618 // place_schematic(p, schematic, rotation,
1619 //     replacements, force_placement, flagstring)
1620 int ModApiMapgen::l_place_schematic(lua_State *L)
1621 {
1622         MAP_LOCK_REQUIRED;
1623
1624         GET_ENV_PTR;
1625
1626         ServerMap *map = &(env->getServerMap());
1627         SchematicManager *schemmgr = (SchematicManager*)
1628                 getServer(L)->getEmergeManager()->getSchematicManager(); // FIXME FIXME
1629
1630         //// Read position
1631         v3s16 p = check_v3s16(L, 1);
1632
1633         //// Read rotation
1634         int rot = ROTATE_0;
1635         std::string enumstr = readParam<std::string>(L, 3, "");
1636         if (!enumstr.empty())
1637                 string_to_enum(es_Rotation, rot, enumstr);
1638
1639         //// Read force placement
1640         bool force_placement = true;
1641         if (lua_isboolean(L, 5))
1642                 force_placement = readParam<bool>(L, 5);
1643
1644         //// Read node replacements
1645         StringMap replace_names;
1646         if (lua_istable(L, 4))
1647                 read_schematic_replacements(L, 4, &replace_names);
1648
1649         //// Read schematic
1650         Schematic *schem = get_or_load_schematic(L, 2, schemmgr, &replace_names);
1651         if (!schem) {
1652                 errorstream << "place_schematic: failed to get schematic" << std::endl;
1653                 return 0;
1654         }
1655
1656         //// Read flags
1657         u32 flags = 0;
1658         read_flags(L, 6, flagdesc_deco, &flags, NULL);
1659
1660         schem->placeOnMap(map, p, flags, (Rotation)rot, force_placement);
1661
1662         lua_pushboolean(L, true);
1663         return 1;
1664 }
1665
1666
1667 // place_schematic_on_vmanip(vm, p, schematic, rotation,
1668 //     replacements, force_placement, flagstring)
1669 int ModApiMapgen::l_place_schematic_on_vmanip(lua_State *L)
1670 {
1671         NO_MAP_LOCK_REQUIRED;
1672
1673         SchematicManager *schemmgr = (SchematicManager*)
1674                 getServer(L)->getEmergeManager()->getSchematicManager(); // FIXME FIXME
1675
1676         //// Read VoxelManip object
1677         MMVManip *vm = LuaVoxelManip::checkobject(L, 1)->vm;
1678
1679         //// Read position
1680         v3s16 p = check_v3s16(L, 2);
1681
1682         //// Read rotation
1683         int rot = ROTATE_0;
1684         std::string enumstr = readParam<std::string>(L, 4, "");
1685         if (!enumstr.empty())
1686                 string_to_enum(es_Rotation, rot, std::string(enumstr));
1687
1688         //// Read force placement
1689         bool force_placement = true;
1690         if (lua_isboolean(L, 6))
1691                 force_placement = readParam<bool>(L, 6);
1692
1693         //// Read node replacements
1694         StringMap replace_names;
1695         if (lua_istable(L, 5))
1696                 read_schematic_replacements(L, 5, &replace_names);
1697
1698         //// Read schematic
1699         Schematic *schem = get_or_load_schematic(L, 3, schemmgr, &replace_names);
1700         if (!schem) {
1701                 errorstream << "place_schematic: failed to get schematic" << std::endl;
1702                 return 0;
1703         }
1704
1705         //// Read flags
1706         u32 flags = 0;
1707         read_flags(L, 7, flagdesc_deco, &flags, NULL);
1708
1709         bool schematic_did_fit = schem->placeOnVManip(
1710                 vm, p, flags, (Rotation)rot, force_placement);
1711
1712         lua_pushboolean(L, schematic_did_fit);
1713         return 1;
1714 }
1715
1716
1717 // serialize_schematic(schematic, format, options={...})
1718 int ModApiMapgen::l_serialize_schematic(lua_State *L)
1719 {
1720         NO_MAP_LOCK_REQUIRED;
1721
1722         const SchematicManager *schemmgr = getServer(L)->getEmergeManager()->getSchematicManager();
1723
1724         //// Read options
1725         bool use_comments = getboolfield_default(L, 3, "lua_use_comments", false);
1726         u32 indent_spaces = getintfield_default(L, 3, "lua_num_indent_spaces", 0);
1727
1728         //// Get schematic
1729         bool was_loaded = false;
1730         Schematic *schem = (Schematic *)get_objdef(L, 1, schemmgr);
1731         if (!schem) {
1732                 schem = load_schematic(L, 1, NULL, NULL);
1733                 was_loaded = true;
1734         }
1735         if (!schem) {
1736                 errorstream << "serialize_schematic: failed to get schematic" << std::endl;
1737                 return 0;
1738         }
1739
1740         //// Read format of definition to save as
1741         int schem_format = SCHEM_FMT_MTS;
1742         std::string enumstr = readParam<std::string>(L, 2, "");
1743         if (!enumstr.empty())
1744                 string_to_enum(es_SchematicFormatType, schem_format, enumstr);
1745
1746         //// Serialize to binary string
1747         std::ostringstream os(std::ios_base::binary);
1748         switch (schem_format) {
1749         case SCHEM_FMT_MTS:
1750                 schem->serializeToMts(&os, schem->m_nodenames);
1751                 break;
1752         case SCHEM_FMT_LUA:
1753                 schem->serializeToLua(&os, schem->m_nodenames,
1754                         use_comments, indent_spaces);
1755                 break;
1756         default:
1757                 return 0;
1758         }
1759
1760         if (was_loaded)
1761                 delete schem;
1762
1763         std::string ser = os.str();
1764         lua_pushlstring(L, ser.c_str(), ser.length());
1765         return 1;
1766 }
1767
1768 // read_schematic(schematic, options={...})
1769 int ModApiMapgen::l_read_schematic(lua_State *L)
1770 {
1771         NO_MAP_LOCK_REQUIRED;
1772
1773         const SchematicManager *schemmgr =
1774                 getServer(L)->getEmergeManager()->getSchematicManager();
1775
1776         //// Read options
1777         std::string write_yslice = getstringfield_default(L, 2, "write_yslice_prob", "all");
1778
1779         //// Get schematic
1780         bool was_loaded = false;
1781         Schematic *schem = (Schematic *)get_objdef(L, 1, schemmgr);
1782         if (!schem) {
1783                 schem = load_schematic(L, 1, NULL, NULL);
1784                 was_loaded = true;
1785         }
1786         if (!schem) {
1787                 errorstream << "read_schematic: failed to get schematic" << std::endl;
1788                 return 0;
1789         }
1790         lua_pop(L, 2);
1791
1792         //// Create the Lua table
1793         u32 numnodes = schem->size.X * schem->size.Y * schem->size.Z;
1794         const std::vector<std::string> &names = schem->m_nodenames;
1795
1796         lua_createtable(L, 0, (write_yslice == "none") ? 2 : 3);
1797
1798         // Create the size field
1799         push_v3s16(L, schem->size);
1800         lua_setfield(L, 1, "size");
1801
1802         // Create the yslice_prob field
1803         if (write_yslice != "none") {
1804                 lua_createtable(L, schem->size.Y, 0);
1805                 for (u16 y = 0; y != schem->size.Y; ++y) {
1806                         u8 probability = schem->slice_probs[y] & MTSCHEM_PROB_MASK;
1807                         if (probability < MTSCHEM_PROB_ALWAYS || write_yslice != "low") {
1808                                 lua_createtable(L, 0, 2);
1809                                 lua_pushinteger(L, y);
1810                                 lua_setfield(L, 3, "ypos");
1811                                 lua_pushinteger(L, probability * 2);
1812                                 lua_setfield(L, 3, "prob");
1813                                 lua_rawseti(L, 2, y + 1);
1814                         }
1815                 }
1816                 lua_setfield(L, 1, "yslice_prob");
1817         }
1818
1819         // Create the data field
1820         lua_createtable(L, numnodes, 0); // data table
1821         for (u32 i = 0; i < numnodes; ++i) {
1822                 MapNode node = schem->schemdata[i];
1823                 u8 probability   = node.param1 & MTSCHEM_PROB_MASK;
1824                 bool force_place = node.param1 & MTSCHEM_FORCE_PLACE;
1825                 lua_createtable(L, 0, force_place ? 4 : 3);
1826                 lua_pushstring(L, names[schem->schemdata[i].getContent()].c_str());
1827                 lua_setfield(L, 3, "name");
1828                 lua_pushinteger(L, probability * 2);
1829                 lua_setfield(L, 3, "prob");
1830                 lua_pushinteger(L, node.param2);
1831                 lua_setfield(L, 3, "param2");
1832                 if (force_place) {
1833                         lua_pushboolean(L, 1);
1834                         lua_setfield(L, 3, "force_place");
1835                 }
1836                 lua_rawseti(L, 2, i + 1);
1837         }
1838         lua_setfield(L, 1, "data");
1839
1840         if (was_loaded)
1841                 delete schem;
1842
1843         return 1;
1844 }
1845
1846
1847 void ModApiMapgen::Initialize(lua_State *L, int top)
1848 {
1849         API_FCT(get_biome_id);
1850         API_FCT(get_biome_name);
1851         API_FCT(get_heat);
1852         API_FCT(get_humidity);
1853         API_FCT(get_biome_data);
1854         API_FCT(get_mapgen_object);
1855         API_FCT(get_spawn_level);
1856
1857         API_FCT(get_mapgen_params);
1858         API_FCT(set_mapgen_params);
1859         API_FCT(get_mapgen_setting);
1860         API_FCT(set_mapgen_setting);
1861         API_FCT(get_mapgen_setting_noiseparams);
1862         API_FCT(set_mapgen_setting_noiseparams);
1863         API_FCT(set_noiseparams);
1864         API_FCT(get_noiseparams);
1865         API_FCT(set_gen_notify);
1866         API_FCT(get_gen_notify);
1867         API_FCT(get_decoration_id);
1868
1869         API_FCT(register_biome);
1870         API_FCT(register_decoration);
1871         API_FCT(register_ore);
1872         API_FCT(register_schematic);
1873
1874         API_FCT(clear_registered_biomes);
1875         API_FCT(clear_registered_decorations);
1876         API_FCT(clear_registered_ores);
1877         API_FCT(clear_registered_schematics);
1878
1879         API_FCT(generate_ores);
1880         API_FCT(generate_decorations);
1881         API_FCT(create_schematic);
1882         API_FCT(place_schematic);
1883         API_FCT(place_schematic_on_vmanip);
1884         API_FCT(serialize_schematic);
1885         API_FCT(read_schematic);
1886 }