src/script/common/c_content.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 #include "common/c_content.h"
  20 #include "common/c_converter.h"
  21 #include "common/c_types.h"
  22 #include "nodedef.h"
  23 #include "object_properties.h"
  24 #include "collision.h"
  25 #include "cpp_api/s_node.h"
  26 #include "lua_api/l_object.h"
  27 #include "lua_api/l_item.h"
  28 #include "common/c_internal.h"
  29 #include "server.h"
  30 #include "log.h"
  31 #include "tool.h"
  32 #include "porting.h"
  33 #include "mapgen/mg_schematic.h"
  34 #include "noise.h"
  35 #include "server/player_sao.h"
  36 #include "util/pointedthing.h"
  37 #include "debug.h" // For FATAL_ERROR
  38 #include <json/json.h>
  39
  40 struct EnumString es_TileAnimationType[] =
  41 {
  42         {TAT_NONE, "none"},
  43         {TAT_VERTICAL_FRAMES, "vertical_frames"},
  44         {TAT_SHEET_2D, "sheet_2d"},
  45         {0, NULL},
  46 };
  47
  48 /******************************************************************************/
  49 void read_item_definition(lua_State* L, int index,
  50                 const ItemDefinition &default_def, ItemDefinition &def)
  51 {
  52         if (index < 0)
  53                 index = lua_gettop(L) + 1 + index;
  54
  55         def.type = (ItemType)getenumfield(L, index, "type",
  56                         es_ItemType, ITEM_NONE);
  57         getstringfield(L, index, "name", def.name);
  58         getstringfield(L, index, "description", def.description);
  59         getstringfield(L, index, "short_description", def.short_description);
  60         getstringfield(L, index, "inventory_image", def.inventory_image);
  61         getstringfield(L, index, "inventory_overlay", def.inventory_overlay);
  62         getstringfield(L, index, "wield_image", def.wield_image);
  63         getstringfield(L, index, "wield_overlay", def.wield_overlay);
  64         getstringfield(L, index, "palette", def.palette_image);
  65
  66         // Read item color.
  67         lua_getfield(L, index, "color");
  68         read_color(L, -1, &def.color);
  69         lua_pop(L, 1);
  70
  71         lua_getfield(L, index, "wield_scale");
  72         if(lua_istable(L, -1)){
  73                 def.wield_scale = check_v3f(L, -1);
  74         }
  75         lua_pop(L, 1);
  76
  77         int stack_max = getintfield_default(L, index, "stack_max", def.stack_max);
  78         def.stack_max = rangelim(stack_max, 1, U16_MAX);
  79
  80         lua_getfield(L, index, "on_use");
  81         def.usable = lua_isfunction(L, -1);
  82         lua_pop(L, 1);
  83
  84         getboolfield(L, index, "liquids_pointable", def.liquids_pointable);
  85
  86         lua_getfield(L, index, "tool_capabilities");
  87         if(lua_istable(L, -1)){
  88                 def.tool_capabilities = new ToolCapabilities(
  89                                 read_tool_capabilities(L, -1));
  90         }
  91
  92         // If name is "" (hand), ensure there are ToolCapabilities
  93         // because it will be looked up there whenever any other item has
  94         // no ToolCapabilities
  95         if (def.name.empty() && def.tool_capabilities == NULL){
  96                 def.tool_capabilities = new ToolCapabilities();
  97         }
  98
  99         lua_getfield(L, index, "groups");
 100         read_groups(L, -1, def.groups);
 101         lua_pop(L, 1);
 102
 103         lua_getfield(L, index, "sounds");
 104         if (!lua_isnil(L, -1)) {
 105                 luaL_checktype(L, -1, LUA_TTABLE);
 106                 lua_getfield(L, -1, "place");
 107                 read_soundspec(L, -1, def.sound_place);
 108                 lua_pop(L, 1);
 109                 lua_getfield(L, -1, "place_failed");
 110                 read_soundspec(L, -1, def.sound_place_failed);
 111                 lua_pop(L, 1);
 112         }
 113         lua_pop(L, 1);
 114
 115         def.range = getfloatfield_default(L, index, "range", def.range);
 116
 117         // Client shall immediately place this node when player places the item.
 118         // Server will update the precise end result a moment later.
 119         // "" = no prediction
 120         getstringfield(L, index, "node_placement_prediction",
 121                         def.node_placement_prediction);
 122
 123         getintfield(L, index, "place_param2", def.place_param2);
 124 }
 125
 126 /******************************************************************************/
 127 void push_item_definition(lua_State *L, const ItemDefinition &i)
 128 {
 129         lua_newtable(L);
 130         lua_pushstring(L, i.name.c_str());
 131         lua_setfield(L, -2, "name");
 132         lua_pushstring(L, i.description.c_str());
 133         lua_setfield(L, -2, "description");
 134 }
 135
 136 void push_item_definition_full(lua_State *L, const ItemDefinition &i)
 137 {
 138         std::string type(es_ItemType[(int)i.type].str);
 139
 140         lua_newtable(L);
 141         lua_pushstring(L, i.name.c_str());
 142         lua_setfield(L, -2, "name");
 143         lua_pushstring(L, i.description.c_str());
 144         lua_setfield(L, -2, "description");
 145         if (!i.short_description.empty()) {
 146                 lua_pushstring(L, i.short_description.c_str());
 147                 lua_setfield(L, -2, "short_description");
 148         }
 149         lua_pushstring(L, type.c_str());
 150         lua_setfield(L, -2, "type");
 151         lua_pushstring(L, i.inventory_image.c_str());
 152         lua_setfield(L, -2, "inventory_image");
 153         lua_pushstring(L, i.inventory_overlay.c_str());
 154         lua_setfield(L, -2, "inventory_overlay");
 155         lua_pushstring(L, i.wield_image.c_str());
 156         lua_setfield(L, -2, "wield_image");
 157         lua_pushstring(L, i.wield_overlay.c_str());
 158         lua_setfield(L, -2, "wield_overlay");
 159         lua_pushstring(L, i.palette_image.c_str());
 160         lua_setfield(L, -2, "palette_image");
 161         push_ARGB8(L, i.color);
 162         lua_setfield(L, -2, "color");
 163         push_v3f(L, i.wield_scale);
 164         lua_setfield(L, -2, "wield_scale");
 165         lua_pushinteger(L, i.stack_max);
 166         lua_setfield(L, -2, "stack_max");
 167         lua_pushboolean(L, i.usable);
 168         lua_setfield(L, -2, "usable");
 169         lua_pushboolean(L, i.liquids_pointable);
 170         lua_setfield(L, -2, "liquids_pointable");
 171         if (i.tool_capabilities) {
 172                 push_tool_capabilities(L, *i.tool_capabilities);
 173                 lua_setfield(L, -2, "tool_capabilities");
 174         }
 175         push_groups(L, i.groups);
 176         lua_setfield(L, -2, "groups");
 177         push_soundspec(L, i.sound_place);
 178         lua_setfield(L, -2, "sound_place");
 179         push_soundspec(L, i.sound_place_failed);
 180         lua_setfield(L, -2, "sound_place_failed");
 181         lua_pushstring(L, i.node_placement_prediction.c_str());
 182         lua_setfield(L, -2, "node_placement_prediction");
 183 }
 184
 185 /******************************************************************************/
 186 void read_object_properties(lua_State *L, int index,
 187                 ServerActiveObject *sao, ObjectProperties *prop, IItemDefManager *idef)
 188 {
 189         if(index < 0)
 190                 index = lua_gettop(L) + 1 + index;
 191         if (lua_isnil(L, index))
 192                 return;
 193
 194         luaL_checktype(L, -1, LUA_TTABLE);
 195
 196         int hp_max = 0;
 197         if (getintfield(L, -1, "hp_max", hp_max)) {
 198                 prop->hp_max = (u16)rangelim(hp_max, 0, U16_MAX);
 199
 200                 if (prop->hp_max < sao->getHP()) {
 201                         PlayerHPChangeReason reason(PlayerHPChangeReason::SET_HP);
 202                         sao->setHP(prop->hp_max, reason);
 203                 }
 204         }
 205
 206         if (getintfield(L, -1, "breath_max", prop->breath_max)) {
 207                 if (sao->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
 208                         PlayerSAO *player = (PlayerSAO *)sao;
 209                         if (prop->breath_max < player->getBreath())
 210                                 player->setBreath(prop->breath_max);
 211                 }
 212         }
 213         getboolfield(L, -1, "physical", prop->physical);
 214         getboolfield(L, -1, "collide_with_objects", prop->collideWithObjects);
 215
 216         lua_getfield(L, -1, "collisionbox");
 217         bool collisionbox_defined = lua_istable(L, -1);
 218         if (collisionbox_defined)
 219                 prop->collisionbox = read_aabb3f(L, -1, 1.0);
 220         lua_pop(L, 1);
 221
 222         lua_getfield(L, -1, "selectionbox");
 223         if (lua_istable(L, -1))
 224                 prop->selectionbox = read_aabb3f(L, -1, 1.0);
 225         else if (collisionbox_defined)
 226                 prop->selectionbox = prop->collisionbox;
 227         lua_pop(L, 1);
 228
 229         getboolfield(L, -1, "pointable", prop->pointable);
 230         getstringfield(L, -1, "visual", prop->visual);
 231
 232         getstringfield(L, -1, "mesh", prop->mesh);
 233
 234         lua_getfield(L, -1, "visual_size");
 235         if (lua_istable(L, -1)) {
 236                 // Backwards compatibility: Also accept { x = ?, y = ? }
 237                 v2f scale_xy = read_v2f(L, -1);
 238
 239                 f32 scale_z = scale_xy.X;
 240                 lua_getfield(L, -1, "z");
 241                 if (lua_isnumber(L, -1))
 242                         scale_z = lua_tonumber(L, -1);
 243                 lua_pop(L, 1);
 244
 245                 prop->visual_size = v3f(scale_xy.X, scale_xy.Y, scale_z);
 246         }
 247         lua_pop(L, 1);
 248
 249         lua_getfield(L, -1, "textures");
 250         if(lua_istable(L, -1)){
 251                 prop->textures.clear();
 252                 int table = lua_gettop(L);
 253                 lua_pushnil(L);
 254                 while(lua_next(L, table) != 0){
 255                         // key at index -2 and value at index -1
 256                         if(lua_isstring(L, -1))
 257                                 prop->textures.emplace_back(lua_tostring(L, -1));
 258                         else
 259                                 prop->textures.emplace_back("");
 260                         // removes value, keeps key for next iteration
 261                         lua_pop(L, 1);
 262                 }
 263         }
 264         lua_pop(L, 1);
 265
 266         lua_getfield(L, -1, "colors");
 267         if (lua_istable(L, -1)) {
 268                 int table = lua_gettop(L);
 269                 prop->colors.clear();
 270                 for (lua_pushnil(L); lua_next(L, table); lua_pop(L, 1)) {
 271                         video::SColor color(255, 255, 255, 255);
 272                         read_color(L, -1, &color);
 273                         prop->colors.push_back(color);
 274                 }
 275         }
 276         lua_pop(L, 1);
 277
 278         lua_getfield(L, -1, "spritediv");
 279         if(lua_istable(L, -1))
 280                 prop->spritediv = read_v2s16(L, -1);
 281         lua_pop(L, 1);
 282
 283         lua_getfield(L, -1, "initial_sprite_basepos");
 284         if(lua_istable(L, -1))
 285                 prop->initial_sprite_basepos = read_v2s16(L, -1);
 286         lua_pop(L, 1);
 287
 288         getboolfield(L, -1, "is_visible", prop->is_visible);
 289         getboolfield(L, -1, "makes_footstep_sound", prop->makes_footstep_sound);
 290         if (getfloatfield(L, -1, "stepheight", prop->stepheight))
 291                 prop->stepheight *= BS;
 292         getfloatfield(L, -1, "eye_height", prop->eye_height);
 293
 294         getfloatfield(L, -1, "automatic_rotate", prop->automatic_rotate);
 295         lua_getfield(L, -1, "automatic_face_movement_dir");
 296         if (lua_isnumber(L, -1)) {
 297                 prop->automatic_face_movement_dir = true;
 298                 prop->automatic_face_movement_dir_offset = luaL_checknumber(L, -1);
 299         } else if (lua_isboolean(L, -1)) {
 300                 prop->automatic_face_movement_dir = lua_toboolean(L, -1);
 301                 prop->automatic_face_movement_dir_offset = 0.0;
 302         }
 303         lua_pop(L, 1);
 304         getboolfield(L, -1, "backface_culling", prop->backface_culling);
 305         getintfield(L, -1, "glow", prop->glow);
 306
 307         getstringfield(L, -1, "nametag", prop->nametag);
 308         lua_getfield(L, -1, "nametag_color");
 309         if (!lua_isnil(L, -1)) {
 310                 video::SColor color = prop->nametag_color;
 311                 if (read_color(L, -1, &color))
 312                         prop->nametag_color = color;
 313         }
 314         lua_pop(L, 1);
 315         lua_getfield(L, -1, "nametag_bgcolor");
 316         if (!lua_isnil(L, -1)) {
 317                 if (lua_toboolean(L, -1)) {
 318                         video::SColor color;
 319                         if (read_color(L, -1, &color))
 320                                 prop->nametag_bgcolor = color;
 321                 } else {
 322                         prop->nametag_bgcolor = nullopt;
 323                 }
 324         }
 325         lua_pop(L, 1);
 326
 327         lua_getfield(L, -1, "automatic_face_movement_max_rotation_per_sec");
 328         if (lua_isnumber(L, -1)) {
 329                 prop->automatic_face_movement_max_rotation_per_sec = luaL_checknumber(L, -1);
 330         }
 331         lua_pop(L, 1);
 332
 333         getstringfield(L, -1, "infotext", prop->infotext);
 334         getboolfield(L, -1, "static_save", prop->static_save);
 335
 336         lua_getfield(L, -1, "wield_item");
 337         if (!lua_isnil(L, -1))
 338                 prop->wield_item = read_item(L, -1, idef).getItemString();
 339         lua_pop(L, 1);
 340
 341         getfloatfield(L, -1, "zoom_fov", prop->zoom_fov);
 342         getboolfield(L, -1, "use_texture_alpha", prop->use_texture_alpha);
 343         getboolfield(L, -1, "shaded", prop->shaded);
 344         getboolfield(L, -1, "show_on_minimap", prop->show_on_minimap);
 345
 346         getstringfield(L, -1, "damage_texture_modifier", prop->damage_texture_modifier);
 347 }
 348
 349 /******************************************************************************/
 350 void push_object_properties(lua_State *L, ObjectProperties *prop)
 351 {
 352         lua_newtable(L);
 353         lua_pushnumber(L, prop->hp_max);
 354         lua_setfield(L, -2, "hp_max");
 355         lua_pushnumber(L, prop->breath_max);
 356         lua_setfield(L, -2, "breath_max");
 357         lua_pushboolean(L, prop->physical);
 358         lua_setfield(L, -2, "physical");
 359         lua_pushboolean(L, prop->collideWithObjects);
 360         lua_setfield(L, -2, "collide_with_objects");
 361         push_aabb3f(L, prop->collisionbox);
 362         lua_setfield(L, -2, "collisionbox");
 363         push_aabb3f(L, prop->selectionbox);
 364         lua_setfield(L, -2, "selectionbox");
 365         lua_pushboolean(L, prop->pointable);
 366         lua_setfield(L, -2, "pointable");
 367         lua_pushlstring(L, prop->visual.c_str(), prop->visual.size());
 368         lua_setfield(L, -2, "visual");
 369         lua_pushlstring(L, prop->mesh.c_str(), prop->mesh.size());
 370         lua_setfield(L, -2, "mesh");
 371         push_v3f(L, prop->visual_size);
 372         lua_setfield(L, -2, "visual_size");
 373
 374         lua_createtable(L, prop->textures.size(), 0);
 375         u16 i = 1;
 376         for (const std::string &texture : prop->textures) {
 377                 lua_pushlstring(L, texture.c_str(), texture.size());
 378                 lua_rawseti(L, -2, i++);
 379         }
 380         lua_setfield(L, -2, "textures");
 381
 382         lua_createtable(L, prop->colors.size(), 0);
 383         i = 1;
 384         for (const video::SColor &color : prop->colors) {
 385                 push_ARGB8(L, color);
 386                 lua_rawseti(L, -2, i++);
 387         }
 388         lua_setfield(L, -2, "colors");
 389
 390         push_v2s16(L, prop->spritediv);
 391         lua_setfield(L, -2, "spritediv");
 392         push_v2s16(L, prop->initial_sprite_basepos);
 393         lua_setfield(L, -2, "initial_sprite_basepos");
 394         lua_pushboolean(L, prop->is_visible);
 395         lua_setfield(L, -2, "is_visible");
 396         lua_pushboolean(L, prop->makes_footstep_sound);
 397         lua_setfield(L, -2, "makes_footstep_sound");
 398         lua_pushnumber(L, prop->stepheight / BS);
 399         lua_setfield(L, -2, "stepheight");
 400         lua_pushnumber(L, prop->eye_height);
 401         lua_setfield(L, -2, "eye_height");
 402         lua_pushnumber(L, prop->automatic_rotate);
 403         lua_setfield(L, -2, "automatic_rotate");
 404         if (prop->automatic_face_movement_dir)
 405                 lua_pushnumber(L, prop->automatic_face_movement_dir_offset);
 406         else
 407                 lua_pushboolean(L, false);
 408         lua_setfield(L, -2, "automatic_face_movement_dir");
 409         lua_pushboolean(L, prop->backface_culling);
 410         lua_setfield(L, -2, "backface_culling");
 411         lua_pushnumber(L, prop->glow);
 412         lua_setfield(L, -2, "glow");
 413         lua_pushlstring(L, prop->nametag.c_str(), prop->nametag.size());
 414         lua_setfield(L, -2, "nametag");
 415         push_ARGB8(L, prop->nametag_color);
 416         lua_setfield(L, -2, "nametag_color");
 417         if (prop->nametag_bgcolor) {
 418                 push_ARGB8(L, prop->nametag_bgcolor.value());
 419                 lua_setfield(L, -2, "nametag_bgcolor");
 420         } else {
 421                 lua_pushboolean(L, false);
 422                 lua_setfield(L, -2, "nametag_bgcolor");
 423         }
 424         lua_pushnumber(L, prop->automatic_face_movement_max_rotation_per_sec);
 425         lua_setfield(L, -2, "automatic_face_movement_max_rotation_per_sec");
 426         lua_pushlstring(L, prop->infotext.c_str(), prop->infotext.size());
 427         lua_setfield(L, -2, "infotext");
 428         lua_pushboolean(L, prop->static_save);
 429         lua_setfield(L, -2, "static_save");
 430         lua_pushlstring(L, prop->wield_item.c_str(), prop->wield_item.size());
 431         lua_setfield(L, -2, "wield_item");
 432         lua_pushnumber(L, prop->zoom_fov);
 433         lua_setfield(L, -2, "zoom_fov");
 434         lua_pushboolean(L, prop->use_texture_alpha);
 435         lua_setfield(L, -2, "use_texture_alpha");
 436         lua_pushboolean(L, prop->shaded);
 437         lua_setfield(L, -2, "shaded");
 438         lua_pushlstring(L, prop->damage_texture_modifier.c_str(), prop->damage_texture_modifier.size());
 439         lua_setfield(L, -2, "damage_texture_modifier");
 440         lua_pushboolean(L, prop->show_on_minimap);
 441         lua_setfield(L, -2, "show_on_minimap");
 442 }
 443
 444 /******************************************************************************/
 445 TileDef read_tiledef(lua_State *L, int index, u8 drawtype)
 446 {
 447         if(index < 0)
 448                 index = lua_gettop(L) + 1 + index;
 449
 450         TileDef tiledef;
 451
 452         bool default_tiling = true;
 453         bool default_culling = true;
 454         switch (drawtype) {
 455                 case NDT_PLANTLIKE:
 456                 case NDT_PLANTLIKE_ROOTED:
 457                 case NDT_FIRELIKE:
 458                         default_tiling = false;
 459                         // "break" is omitted here intentionaly, as PLANTLIKE
 460                         // FIRELIKE drawtype both should default to having
 461                         // backface_culling to false.
 462                 case NDT_MESH:
 463                 case NDT_LIQUID:
 464                         default_culling = false;
 465                         break;
 466                 default:
 467                         break;
 468         }
 469
 470         // key at index -2 and value at index
 471         if(lua_isstring(L, index)){
 472                 // "default_lava.png"
 473                 tiledef.name = lua_tostring(L, index);
 474                 tiledef.tileable_vertical = default_tiling;
 475                 tiledef.tileable_horizontal = default_tiling;
 476                 tiledef.backface_culling = default_culling;
 477         }
 478         else if(lua_istable(L, index))
 479         {
 480                 // name="default_lava.png"
 481                 tiledef.name = "";
 482                 getstringfield(L, index, "name", tiledef.name);
 483                 getstringfield(L, index, "image", tiledef.name); // MaterialSpec compat.
 484                 tiledef.backface_culling = getboolfield_default(
 485                         L, index, "backface_culling", default_culling);
 486                 tiledef.tileable_horizontal = getboolfield_default(
 487                         L, index, "tileable_horizontal", default_tiling);
 488                 tiledef.tileable_vertical = getboolfield_default(
 489                         L, index, "tileable_vertical", default_tiling);
 490                 std::string align_style;
 491                 if (getstringfield(L, index, "align_style", align_style)) {
 492                         if (align_style == "user")
 493                                 tiledef.align_style = ALIGN_STYLE_USER_DEFINED;
 494                         else if (align_style == "world")
 495                                 tiledef.align_style = ALIGN_STYLE_WORLD;
 496                         else
 497                                 tiledef.align_style = ALIGN_STYLE_NODE;
 498                 }
 499                 tiledef.scale = getintfield_default(L, index, "scale", 0);
 500                 // color = ...
 501                 lua_getfield(L, index, "color");
 502                 tiledef.has_color = read_color(L, -1, &tiledef.color);
 503                 lua_pop(L, 1);
 504                 // animation = {}
 505                 lua_getfield(L, index, "animation");
 506                 tiledef.animation = read_animation_definition(L, -1);
 507                 lua_pop(L, 1);
 508         }
 509
 510         return tiledef;
 511 }
 512
 513 /******************************************************************************/
 514 void read_content_features(lua_State *L, ContentFeatures &f, int index)
 515 {
 516         if(index < 0)
 517                 index = lua_gettop(L) + 1 + index;
 518
 519         /* Cache existence of some callbacks */
 520         lua_getfield(L, index, "on_construct");
 521         if(!lua_isnil(L, -1)) f.has_on_construct = true;
 522         lua_pop(L, 1);
 523         lua_getfield(L, index, "on_destruct");
 524         if(!lua_isnil(L, -1)) f.has_on_destruct = true;
 525         lua_pop(L, 1);
 526         lua_getfield(L, index, "after_destruct");
 527         if(!lua_isnil(L, -1)) f.has_after_destruct = true;
 528         lua_pop(L, 1);
 529
 530         lua_getfield(L, index, "on_rightclick");
 531         f.rightclickable = lua_isfunction(L, -1);
 532         lua_pop(L, 1);
 533
 534         /* Name */
 535         getstringfield(L, index, "name", f.name);
 536
 537         /* Groups */
 538         lua_getfield(L, index, "groups");
 539         read_groups(L, -1, f.groups);
 540         lua_pop(L, 1);
 541
 542         /* Visual definition */
 543
 544         f.drawtype = (NodeDrawType)getenumfield(L, index, "drawtype",
 545                         ScriptApiNode::es_DrawType,NDT_NORMAL);
 546         getfloatfield(L, index, "visual_scale", f.visual_scale);
 547
 548         /* Meshnode model filename */
 549         getstringfield(L, index, "mesh", f.mesh);
 550
 551         // tiles = {}
 552         lua_getfield(L, index, "tiles");
 553         // If nil, try the deprecated name "tile_images" instead
 554         if(lua_isnil(L, -1)){
 555                 lua_pop(L, 1);
 556                 warn_if_field_exists(L, index, "tile_images",
 557                                 "Deprecated; new name is \"tiles\".");
 558                 lua_getfield(L, index, "tile_images");
 559         }
 560         if(lua_istable(L, -1)){
 561                 int table = lua_gettop(L);
 562                 lua_pushnil(L);
 563                 int i = 0;
 564                 while(lua_next(L, table) != 0){
 565                         // Read tiledef from value
 566                         f.tiledef[i] = read_tiledef(L, -1, f.drawtype);
 567                         // removes value, keeps key for next iteration
 568                         lua_pop(L, 1);
 569                         i++;
 570                         if(i==6){
 571                                 lua_pop(L, 1);
 572                                 break;
 573                         }
 574                 }
 575                 // Copy last value to all remaining textures
 576                 if(i >= 1){
 577                         TileDef lasttile = f.tiledef[i-1];
 578                         while(i < 6){
 579                                 f.tiledef[i] = lasttile;
 580                                 i++;
 581                         }
 582                 }
 583         }
 584         lua_pop(L, 1);
 585
 586         // overlay_tiles = {}
 587         lua_getfield(L, index, "overlay_tiles");
 588         if (lua_istable(L, -1)) {
 589                 int table = lua_gettop(L);
 590                 lua_pushnil(L);
 591                 int i = 0;
 592                 while (lua_next(L, table) != 0) {
 593                         // Read tiledef from value
 594                         f.tiledef_overlay[i] = read_tiledef(L, -1, f.drawtype);
 595                         // removes value, keeps key for next iteration
 596                         lua_pop(L, 1);
 597                         i++;
 598                         if (i == 6) {
 599                                 lua_pop(L, 1);
 600                                 break;
 601                         }
 602                 }
 603                 // Copy last value to all remaining textures
 604                 if (i >= 1) {
 605                         TileDef lasttile = f.tiledef_overlay[i - 1];
 606                         while (i < 6) {
 607                                 f.tiledef_overlay[i] = lasttile;
 608                                 i++;
 609                         }
 610                 }
 611         }
 612         lua_pop(L, 1);
 613
 614         // special_tiles = {}
 615         lua_getfield(L, index, "special_tiles");
 616         // If nil, try the deprecated name "special_materials" instead
 617         if(lua_isnil(L, -1)){
 618                 lua_pop(L, 1);
 619                 warn_if_field_exists(L, index, "special_materials",
 620                                 "Deprecated; new name is \"special_tiles\".");
 621                 lua_getfield(L, index, "special_materials");
 622         }
 623         if(lua_istable(L, -1)){
 624                 int table = lua_gettop(L);
 625                 lua_pushnil(L);
 626                 int i = 0;
 627                 while(lua_next(L, table) != 0){
 628                         // Read tiledef from value
 629                         f.tiledef_special[i] = read_tiledef(L, -1, f.drawtype);
 630                         // removes value, keeps key for next iteration
 631                         lua_pop(L, 1);
 632                         i++;
 633                         if(i==CF_SPECIAL_COUNT){
 634                                 lua_pop(L, 1);
 635                                 break;
 636                         }
 637                 }
 638         }
 639         lua_pop(L, 1);
 640
 641         /* alpha & use_texture_alpha */
 642         // This is a bit complicated due to compatibility
 643
 644         f.setDefaultAlphaMode();
 645
 646         warn_if_field_exists(L, index, "alpha",
 647                 "Obsolete, only limited compatibility provided; "
 648                 "replaced by \"use_texture_alpha\"");
 649         if (getintfield_default(L, index, "alpha", 255) != 255)
 650                 f.alpha = ALPHAMODE_BLEND;
 651
 652         lua_getfield(L, index, "use_texture_alpha");
 653         if (lua_isboolean(L, -1)) {
 654                 warn_if_field_exists(L, index, "use_texture_alpha",
 655                         "Boolean values are deprecated; use the new choices");
 656                 if (lua_toboolean(L, -1))
 657                         f.alpha = (f.drawtype == NDT_NORMAL) ? ALPHAMODE_CLIP : ALPHAMODE_BLEND;
 658         } else if (check_field_or_nil(L, -1, LUA_TSTRING, "use_texture_alpha")) {
 659                 int result = f.alpha;
 660                 string_to_enum(ScriptApiNode::es_TextureAlphaMode, result,
 661                                 std::string(lua_tostring(L, -1)));
 662                 f.alpha = static_cast<enum AlphaMode>(result);
 663         }
 664         lua_pop(L, 1);
 665
 666         /* Other stuff */
 667
 668         lua_getfield(L, index, "color");
 669         read_color(L, -1, &f.color);
 670         lua_pop(L, 1);
 671
 672         getstringfield(L, index, "palette", f.palette_name);
 673
 674         lua_getfield(L, index, "post_effect_color");
 675         read_color(L, -1, &f.post_effect_color);
 676         lua_pop(L, 1);
 677
 678         f.param_type = (ContentParamType)getenumfield(L, index, "paramtype",
 679                         ScriptApiNode::es_ContentParamType, CPT_NONE);
 680         f.param_type_2 = (ContentParamType2)getenumfield(L, index, "paramtype2",
 681                         ScriptApiNode::es_ContentParamType2, CPT2_NONE);
 682
 683         if (!f.palette_name.empty() &&
 684                         !(f.param_type_2 == CPT2_COLOR ||
 685                         f.param_type_2 == CPT2_COLORED_FACEDIR ||
 686                         f.param_type_2 == CPT2_COLORED_WALLMOUNTED ||
 687                         f.param_type_2 == CPT2_COLORED_DEGROTATE))
 688                 warningstream << "Node " << f.name.c_str()
 689                         << " has a palette, but not a suitable paramtype2." << std::endl;
 690
 691         // True for all ground-like things like stone and mud, false for eg. trees
 692         getboolfield(L, index, "is_ground_content", f.is_ground_content);
 693         f.light_propagates = (f.param_type == CPT_LIGHT);
 694         getboolfield(L, index, "sunlight_propagates", f.sunlight_propagates);
 695         // This is used for collision detection.
 696         // Also for general solidness queries.
 697         getboolfield(L, index, "walkable", f.walkable);
 698         // Player can point to these
 699         getboolfield(L, index, "pointable", f.pointable);
 700         // Player can dig these
 701         getboolfield(L, index, "diggable", f.diggable);
 702         // Player can climb these
 703         getboolfield(L, index, "climbable", f.climbable);
 704         // Player can build on these
 705         getboolfield(L, index, "buildable_to", f.buildable_to);
 706         // Liquids flow into and replace node
 707         getboolfield(L, index, "floodable", f.floodable);
 708         // Whether the node is non-liquid, source liquid or flowing liquid
 709         f.liquid_type = (LiquidType)getenumfield(L, index, "liquidtype",
 710                         ScriptApiNode::es_LiquidType, LIQUID_NONE);
 711         // If the content is liquid, this is the flowing version of the liquid.
 712         getstringfield(L, index, "liquid_alternative_flowing",
 713                         f.liquid_alternative_flowing);
 714         // If the content is liquid, this is the source version of the liquid.
 715         getstringfield(L, index, "liquid_alternative_source",
 716                         f.liquid_alternative_source);
 717         // Viscosity for fluid flow, ranging from 1 to 7, with
 718         // 1 giving almost instantaneous propagation and 7 being
 719         // the slowest possible
 720         f.liquid_viscosity = getintfield_default(L, index,
 721                         "liquid_viscosity", f.liquid_viscosity);
 722         // If move_resistance is not set explicitly,
 723         // move_resistance is equal to liquid_viscosity
 724         f.move_resistance = f.liquid_viscosity;
 725         f.liquid_range = getintfield_default(L, index,
 726                         "liquid_range", f.liquid_range);
 727         f.leveled = getintfield_default(L, index, "leveled", f.leveled);
 728         f.leveled_max = getintfield_default(L, index,
 729                         "leveled_max", f.leveled_max);
 730
 731         getboolfield(L, index, "liquid_renewable", f.liquid_renewable);
 732         f.drowning = getintfield_default(L, index,
 733                         "drowning", f.drowning);
 734         // Amount of light the node emits
 735         f.light_source = getintfield_default(L, index,
 736                         "light_source", f.light_source);
 737         if (f.light_source > LIGHT_MAX) {
 738                 warningstream << "Node " << f.name.c_str()
 739                         << " had greater light_source than " << LIGHT_MAX
 740                         << ", it was reduced." << std::endl;
 741                 f.light_source = LIGHT_MAX;
 742         }
 743         f.damage_per_second = getintfield_default(L, index,
 744                         "damage_per_second", f.damage_per_second);
 745
 746         lua_getfield(L, index, "node_box");
 747         if(lua_istable(L, -1))
 748                 f.node_box = read_nodebox(L, -1);
 749         lua_pop(L, 1);
 750
 751         lua_getfield(L, index, "connects_to");
 752         if (lua_istable(L, -1)) {
 753                 int table = lua_gettop(L);
 754                 lua_pushnil(L);
 755                 while (lua_next(L, table) != 0) {
 756                         // Value at -1
 757                         f.connects_to.emplace_back(lua_tostring(L, -1));
 758                         lua_pop(L, 1);
 759                 }
 760         }
 761         lua_pop(L, 1);
 762
 763         lua_getfield(L, index, "connect_sides");
 764         if (lua_istable(L, -1)) {
 765                 int table = lua_gettop(L);
 766                 lua_pushnil(L);
 767                 while (lua_next(L, table) != 0) {
 768                         // Value at -1
 769                         std::string side(lua_tostring(L, -1));
 770                         // Note faces are flipped to make checking easier
 771                         if (side == "top")
 772                                 f.connect_sides |= 2;
 773                         else if (side == "bottom")
 774                                 f.connect_sides |= 1;
 775                         else if (side == "front")
 776                                 f.connect_sides |= 16;
 777                         else if (side == "left")
 778                                 f.connect_sides |= 32;
 779                         else if (side == "back")
 780                                 f.connect_sides |= 4;
 781                         else if (side == "right")
 782                                 f.connect_sides |= 8;
 783                         else
 784                                 warningstream << "Unknown value for \"connect_sides\": "
 785                                         << side << std::endl;
 786                         lua_pop(L, 1);
 787                 }
 788         }
 789         lua_pop(L, 1);
 790
 791         lua_getfield(L, index, "selection_box");
 792         if(lua_istable(L, -1))
 793                 f.selection_box = read_nodebox(L, -1);
 794         lua_pop(L, 1);
 795
 796         lua_getfield(L, index, "collision_box");
 797         if(lua_istable(L, -1))
 798                 f.collision_box = read_nodebox(L, -1);
 799         lua_pop(L, 1);
 800
 801         f.waving = getintfield_default(L, index,
 802                         "waving", f.waving);
 803
 804         // Set to true if paramtype used to be 'facedir_simple'
 805         getboolfield(L, index, "legacy_facedir_simple", f.legacy_facedir_simple);
 806         // Set to true if wall_mounted used to be set to true
 807         getboolfield(L, index, "legacy_wallmounted", f.legacy_wallmounted);
 808
 809         // Sound table
 810         lua_getfield(L, index, "sounds");
 811         if(lua_istable(L, -1)){
 812                 lua_getfield(L, -1, "footstep");
 813                 read_soundspec(L, -1, f.sound_footstep);
 814                 lua_pop(L, 1);
 815                 lua_getfield(L, -1, "dig");
 816                 read_soundspec(L, -1, f.sound_dig);
 817                 lua_pop(L, 1);
 818                 lua_getfield(L, -1, "dug");
 819                 read_soundspec(L, -1, f.sound_dug);
 820                 lua_pop(L, 1);
 821         }
 822         lua_pop(L, 1);
 823
 824         // Node immediately placed by client when node is dug
 825         getstringfield(L, index, "node_dig_prediction",
 826                 f.node_dig_prediction);
 827
 828         // How much the node slows down players, ranging from 1 to 7,
 829         // the higher, the slower.
 830         f.move_resistance = getintfield_default(L, index,
 831                         "move_resistance", f.move_resistance);
 832
 833         // Whether e.g. players in this node will have liquid movement physics
 834         lua_getfield(L, index, "liquid_move_physics");
 835         if(lua_isboolean(L, -1)) {
 836                 f.liquid_move_physics = lua_toboolean(L, -1);
 837         } else if(lua_isnil(L, -1)) {
 838                 f.liquid_move_physics = f.liquid_type != LIQUID_NONE;
 839         } else {
 840                 errorstream << "Field \"liquid_move_physics\": Invalid type!" << std::endl;
 841         }
 842         lua_pop(L, 1);
 843 }
 844
 845 void push_content_features(lua_State *L, const ContentFeatures &c)
 846 {
 847         std::string paramtype(ScriptApiNode::es_ContentParamType[(int)c.param_type].str);
 848         std::string paramtype2(ScriptApiNode::es_ContentParamType2[(int)c.param_type_2].str);
 849         std::string drawtype(ScriptApiNode::es_DrawType[(int)c.drawtype].str);
 850         std::string liquid_type(ScriptApiNode::es_LiquidType[(int)c.liquid_type].str);
 851
 852         /* Missing "tiles" because I don't see a usecase (at least not yet). */
 853
 854         lua_newtable(L);
 855         lua_pushboolean(L, c.has_on_construct);
 856         lua_setfield(L, -2, "has_on_construct");
 857         lua_pushboolean(L, c.has_on_destruct);
 858         lua_setfield(L, -2, "has_on_destruct");
 859         lua_pushboolean(L, c.has_after_destruct);
 860         lua_setfield(L, -2, "has_after_destruct");
 861         lua_pushstring(L, c.name.c_str());
 862         lua_setfield(L, -2, "name");
 863         push_groups(L, c.groups);
 864         lua_setfield(L, -2, "groups");
 865         lua_pushstring(L, paramtype.c_str());
 866         lua_setfield(L, -2, "paramtype");
 867         lua_pushstring(L, paramtype2.c_str());
 868         lua_setfield(L, -2, "paramtype2");
 869         lua_pushstring(L, drawtype.c_str());
 870         lua_setfield(L, -2, "drawtype");
 871         if (!c.mesh.empty()) {
 872                 lua_pushstring(L, c.mesh.c_str());
 873                 lua_setfield(L, -2, "mesh");
 874         }
 875 #ifndef SERVER
 876         push_ARGB8(L, c.minimap_color);       // I know this is not set-able w/ register_node,
 877         lua_setfield(L, -2, "minimap_color"); // but the people need to know!
 878 #endif
 879         lua_pushnumber(L, c.visual_scale);
 880         lua_setfield(L, -2, "visual_scale");
 881         lua_pushnumber(L, c.alpha);
 882         lua_setfield(L, -2, "alpha");
 883         if (!c.palette_name.empty()) {
 884                 push_ARGB8(L, c.color);
 885                 lua_setfield(L, -2, "color");
 886
 887                 lua_pushstring(L, c.palette_name.c_str());
 888                 lua_setfield(L, -2, "palette_name");
 889
 890                 push_palette(L, c.palette);
 891                 lua_setfield(L, -2, "palette");
 892         }
 893         lua_pushnumber(L, c.waving);
 894         lua_setfield(L, -2, "waving");
 895         lua_pushnumber(L, c.connect_sides);
 896         lua_setfield(L, -2, "connect_sides");
 897
 898         lua_createtable(L, c.connects_to.size(), 0);
 899         u16 i = 1;
 900         for (const std::string &it : c.connects_to) {
 901                 lua_pushlstring(L, it.c_str(), it.size());
 902                 lua_rawseti(L, -2, i++);
 903         }
 904         lua_setfield(L, -2, "connects_to");
 905
 906         push_ARGB8(L, c.post_effect_color);
 907         lua_setfield(L, -2, "post_effect_color");
 908         lua_pushnumber(L, c.leveled);
 909         lua_setfield(L, -2, "leveled");
 910         lua_pushnumber(L, c.leveled_max);
 911         lua_setfield(L, -2, "leveled_max");
 912         lua_pushboolean(L, c.sunlight_propagates);
 913         lua_setfield(L, -2, "sunlight_propagates");
 914         lua_pushnumber(L, c.light_source);
 915         lua_setfield(L, -2, "light_source");
 916         lua_pushboolean(L, c.is_ground_content);
 917         lua_setfield(L, -2, "is_ground_content");
 918         lua_pushboolean(L, c.walkable);
 919         lua_setfield(L, -2, "walkable");
 920         lua_pushboolean(L, c.pointable);
 921         lua_setfield(L, -2, "pointable");
 922         lua_pushboolean(L, c.diggable);
 923         lua_setfield(L, -2, "diggable");
 924         lua_pushboolean(L, c.climbable);
 925         lua_setfield(L, -2, "climbable");
 926         lua_pushboolean(L, c.buildable_to);
 927         lua_setfield(L, -2, "buildable_to");
 928         lua_pushboolean(L, c.rightclickable);
 929         lua_setfield(L, -2, "rightclickable");
 930         lua_pushnumber(L, c.damage_per_second);
 931         lua_setfield(L, -2, "damage_per_second");
 932         if (c.isLiquid()) {
 933                 lua_pushstring(L, liquid_type.c_str());
 934                 lua_setfield(L, -2, "liquid_type");
 935                 lua_pushstring(L, c.liquid_alternative_flowing.c_str());
 936                 lua_setfield(L, -2, "liquid_alternative_flowing");
 937                 lua_pushstring(L, c.liquid_alternative_source.c_str());
 938                 lua_setfield(L, -2, "liquid_alternative_source");
 939                 lua_pushnumber(L, c.liquid_viscosity);
 940                 lua_setfield(L, -2, "liquid_viscosity");
 941                 lua_pushboolean(L, c.liquid_renewable);
 942                 lua_setfield(L, -2, "liquid_renewable");
 943                 lua_pushnumber(L, c.liquid_range);
 944                 lua_setfield(L, -2, "liquid_range");
 945         }
 946         lua_pushnumber(L, c.drowning);
 947         lua_setfield(L, -2, "drowning");
 948         lua_pushboolean(L, c.floodable);
 949         lua_setfield(L, -2, "floodable");
 950         push_nodebox(L, c.node_box);
 951         lua_setfield(L, -2, "node_box");
 952         push_nodebox(L, c.selection_box);
 953         lua_setfield(L, -2, "selection_box");
 954         push_nodebox(L, c.collision_box);
 955         lua_setfield(L, -2, "collision_box");
 956         lua_newtable(L);
 957         push_soundspec(L, c.sound_footstep);
 958         lua_setfield(L, -2, "sound_footstep");
 959         push_soundspec(L, c.sound_dig);
 960         lua_setfield(L, -2, "sound_dig");
 961         push_soundspec(L, c.sound_dug);
 962         lua_setfield(L, -2, "sound_dug");
 963         lua_setfield(L, -2, "sounds");
 964         lua_pushboolean(L, c.legacy_facedir_simple);
 965         lua_setfield(L, -2, "legacy_facedir_simple");
 966         lua_pushboolean(L, c.legacy_wallmounted);
 967         lua_setfield(L, -2, "legacy_wallmounted");
 968         lua_pushstring(L, c.node_dig_prediction.c_str());
 969         lua_setfield(L, -2, "node_dig_prediction");
 970         lua_pushnumber(L, c.move_resistance);
 971         lua_setfield(L, -2, "move_resistance");
 972         lua_pushboolean(L, c.liquid_move_physics);
 973         lua_setfield(L, -2, "liquid_move_physics");
 974 }
 975
 976 /******************************************************************************/
 977 void push_nodebox(lua_State *L, const NodeBox &box)
 978 {
 979         lua_newtable(L);
 980         switch (box.type)
 981         {
 982                 case NODEBOX_REGULAR:
 983                         lua_pushstring(L, "regular");
 984                         lua_setfield(L, -2, "type");
 985                         break;
 986                 case NODEBOX_LEVELED:
 987                 case NODEBOX_FIXED:
 988                         lua_pushstring(L, "fixed");
 989                         lua_setfield(L, -2, "type");
 990                         push_box(L, box.fixed);
 991                         lua_setfield(L, -2, "fixed");
 992                         break;
 993                 case NODEBOX_WALLMOUNTED:
 994                         lua_pushstring(L, "wallmounted");
 995                         lua_setfield(L, -2, "type");
 996                         push_aabb3f(L, box.wall_top);
 997                         lua_setfield(L, -2, "wall_top");
 998                         push_aabb3f(L, box.wall_bottom);
 999                         lua_setfield(L, -2, "wall_bottom");
1000                         push_aabb3f(L, box.wall_side);
1001                         lua_setfield(L, -2, "wall_side");
1002                         break;
1003                 case NODEBOX_CONNECTED:
1004                         lua_pushstring(L, "connected");
1005                         lua_setfield(L, -2, "type");
1006                         push_box(L, box.connect_top);
1007                         lua_setfield(L, -2, "connect_top");
1008                         push_box(L, box.connect_bottom);
1009                         lua_setfield(L, -2, "connect_bottom");
1010                         push_box(L, box.connect_front);
1011                         lua_setfield(L, -2, "connect_front");
1012                         push_box(L, box.connect_back);
1013                         lua_setfield(L, -2, "connect_back");
1014                         push_box(L, box.connect_left);
1015                         lua_setfield(L, -2, "connect_left");
1016                         push_box(L, box.connect_right);
1017                         lua_setfield(L, -2, "connect_right");
1018                         break;
1019                 default:
1020                         FATAL_ERROR("Invalid box.type");
1021                         break;
1022         }
1023 }
1024
1025 void push_box(lua_State *L, const std::vector<aabb3f> &box)
1026 {
1027         lua_createtable(L, box.size(), 0);
1028         u8 i = 1;
1029         for (const aabb3f &it : box) {
1030                 push_aabb3f(L, it);
1031                 lua_rawseti(L, -2, i++);
1032         }
1033 }
1034
1035 /******************************************************************************/
1036 void push_palette(lua_State *L, const std::vector<video::SColor> *palette)
1037 {
1038         lua_createtable(L, palette->size(), 0);
1039         int newTable = lua_gettop(L);
1040         int index = 1;
1041         std::vector<video::SColor>::const_iterator iter;
1042         for (iter = palette->begin(); iter != palette->end(); ++iter) {
1043                 push_ARGB8(L, (*iter));
1044                 lua_rawseti(L, newTable, index);
1045                 index++;
1046         }
1047 }
1048
1049 /******************************************************************************/
1050 void read_server_sound_params(lua_State *L, int index,
1051                 ServerSoundParams &params)
1052 {
1053         if(index < 0)
1054                 index = lua_gettop(L) + 1 + index;
1055         // Clear
1056         params = ServerSoundParams();
1057         if(lua_istable(L, index)){
1058                 getfloatfield(L, index, "gain", params.gain);
1059                 getstringfield(L, index, "to_player", params.to_player);
1060                 getfloatfield(L, index, "fade", params.fade);
1061                 getfloatfield(L, index, "pitch", params.pitch);
1062                 lua_getfield(L, index, "pos");
1063                 if(!lua_isnil(L, -1)){
1064                         v3f p = read_v3f(L, -1)*BS;
1065                         params.pos = p;
1066                         params.type = ServerSoundParams::SSP_POSITIONAL;
1067                 }
1068                 lua_pop(L, 1);
1069                 lua_getfield(L, index, "object");
1070                 if(!lua_isnil(L, -1)){
1071                         ObjectRef *ref = ObjectRef::checkobject(L, -1);
1072                         ServerActiveObject *sao = ObjectRef::getobject(ref);
1073                         if(sao){
1074                                 params.object = sao->getId();
1075                                 params.type = ServerSoundParams::SSP_OBJECT;
1076                         }
1077                 }
1078                 lua_pop(L, 1);
1079                 params.max_hear_distance = BS*getfloatfield_default(L, index,
1080                                 "max_hear_distance", params.max_hear_distance/BS);
1081                 getboolfield(L, index, "loop", params.loop);
1082                 getstringfield(L, index, "exclude_player", params.exclude_player);
1083         }
1084 }
1085
1086 /******************************************************************************/
1087 void read_soundspec(lua_State *L, int index, SimpleSoundSpec &spec)
1088 {
1089         if(index < 0)
1090                 index = lua_gettop(L) + 1 + index;
1091         if (lua_isnil(L, index))
1092                 return;
1093
1094         if (lua_istable(L, index)) {
1095                 getstringfield(L, index, "name", spec.name);
1096                 getfloatfield(L, index, "gain", spec.gain);
1097                 getfloatfield(L, index, "fade", spec.fade);
1098                 getfloatfield(L, index, "pitch", spec.pitch);
1099         } else if (lua_isstring(L, index)) {
1100                 spec.name = lua_tostring(L, index);
1101         }
1102 }
1103
1104 void push_soundspec(lua_State *L, const SimpleSoundSpec &spec)
1105 {
1106         lua_createtable(L, 0, 3);
1107         lua_pushstring(L, spec.name.c_str());
1108         lua_setfield(L, -2, "name");
1109         lua_pushnumber(L, spec.gain);
1110         lua_setfield(L, -2, "gain");
1111         lua_pushnumber(L, spec.fade);
1112         lua_setfield(L, -2, "fade");
1113         lua_pushnumber(L, spec.pitch);
1114         lua_setfield(L, -2, "pitch");
1115 }
1116
1117 /******************************************************************************/
1118 NodeBox read_nodebox(lua_State *L, int index)
1119 {
1120         NodeBox nodebox;
1121         if (lua_isnil(L, -1))
1122                 return nodebox;
1123
1124         luaL_checktype(L, -1, LUA_TTABLE);
1125
1126         nodebox.type = (NodeBoxType)getenumfield(L, index, "type",
1127                         ScriptApiNode::es_NodeBoxType, NODEBOX_REGULAR);
1128
1129 #define NODEBOXREAD(n, s){ \
1130                 lua_getfield(L, index, (s)); \
1131                 if (lua_istable(L, -1)) \
1132                         (n) = read_aabb3f(L, -1, BS); \
1133                 lua_pop(L, 1); \
1134         }
1135
1136 #define NODEBOXREADVEC(n, s) \
1137         lua_getfield(L, index, (s)); \
1138         if (lua_istable(L, -1)) \
1139                 (n) = read_aabb3f_vector(L, -1, BS); \
1140         lua_pop(L, 1);
1141
1142         NODEBOXREADVEC(nodebox.fixed, "fixed");
1143         NODEBOXREAD(nodebox.wall_top, "wall_top");
1144         NODEBOXREAD(nodebox.wall_bottom, "wall_bottom");
1145         NODEBOXREAD(nodebox.wall_side, "wall_side");
1146         NODEBOXREADVEC(nodebox.connect_top, "connect_top");
1147         NODEBOXREADVEC(nodebox.connect_bottom, "connect_bottom");
1148         NODEBOXREADVEC(nodebox.connect_front, "connect_front");
1149         NODEBOXREADVEC(nodebox.connect_left, "connect_left");
1150         NODEBOXREADVEC(nodebox.connect_back, "connect_back");
1151         NODEBOXREADVEC(nodebox.connect_right, "connect_right");
1152         NODEBOXREADVEC(nodebox.disconnected_top, "disconnected_top");
1153         NODEBOXREADVEC(nodebox.disconnected_bottom, "disconnected_bottom");
1154         NODEBOXREADVEC(nodebox.disconnected_front, "disconnected_front");
1155         NODEBOXREADVEC(nodebox.disconnected_left, "disconnected_left");
1156         NODEBOXREADVEC(nodebox.disconnected_back, "disconnected_back");
1157         NODEBOXREADVEC(nodebox.disconnected_right, "disconnected_right");
1158         NODEBOXREADVEC(nodebox.disconnected, "disconnected");
1159         NODEBOXREADVEC(nodebox.disconnected_sides, "disconnected_sides");
1160
1161         return nodebox;
1162 }
1163
1164 /******************************************************************************/
1165 MapNode readnode(lua_State *L, int index, const NodeDefManager *ndef)
1166 {
1167         lua_getfield(L, index, "name");
1168         if (!lua_isstring(L, -1))
1169                 throw LuaError("Node name is not set or is not a string!");
1170         std::string name = lua_tostring(L, -1);
1171         lua_pop(L, 1);
1172
1173         u8 param1 = 0;
1174         lua_getfield(L, index, "param1");
1175         if (!lua_isnil(L, -1))
1176                 param1 = lua_tonumber(L, -1);
1177         lua_pop(L, 1);
1178
1179         u8 param2 = 0;
1180         lua_getfield(L, index, "param2");
1181         if (!lua_isnil(L, -1))
1182                 param2 = lua_tonumber(L, -1);
1183         lua_pop(L, 1);
1184
1185         content_t id = CONTENT_IGNORE;
1186         if (!ndef->getId(name, id))
1187                 throw LuaError("\"" + name + "\" is not a registered node!");
1188
1189         return {id, param1, param2};
1190 }
1191
1192 /******************************************************************************/
1193 void pushnode(lua_State *L, const MapNode &n, const NodeDefManager *ndef)
1194 {
1195         lua_createtable(L, 0, 3);
1196         lua_pushstring(L, ndef->get(n).name.c_str());
1197         lua_setfield(L, -2, "name");
1198         lua_pushinteger(L, n.getParam1());
1199         lua_setfield(L, -2, "param1");
1200         lua_pushinteger(L, n.getParam2());
1201         lua_setfield(L, -2, "param2");
1202 }
1203
1204 /******************************************************************************/
1205 void warn_if_field_exists(lua_State *L, int table,
1206                 const char *name, const std::string &message)
1207 {
1208         lua_getfield(L, table, name);
1209         if (!lua_isnil(L, -1)) {
1210                 warningstream << "Field \"" << name << "\": "
1211                                 << message << std::endl;
1212                 infostream << script_get_backtrace(L) << std::endl;
1213         }
1214         lua_pop(L, 1);
1215 }
1216
1217 /******************************************************************************/
1218 int getenumfield(lua_State *L, int table,
1219                 const char *fieldname, const EnumString *spec, int default_)
1220 {
1221         int result = default_;
1222         string_to_enum(spec, result,
1223                         getstringfield_default(L, table, fieldname, ""));
1224         return result;
1225 }
1226
1227 /******************************************************************************/
1228 bool string_to_enum(const EnumString *spec, int &result,
1229                 const std::string &str)
1230 {
1231         const EnumString *esp = spec;
1232         while(esp->str){
1233                 if (!strcmp(str.c_str(), esp->str)) {
1234                         result = esp->num;
1235                         return true;
1236                 }
1237                 esp++;
1238         }
1239         return false;
1240 }
1241
1242 /******************************************************************************/
1243 ItemStack read_item(lua_State* L, int index, IItemDefManager *idef)
1244 {
1245         if(index < 0)
1246                 index = lua_gettop(L) + 1 + index;
1247
1248         if (lua_isnil(L, index)) {
1249                 return ItemStack();
1250         }
1251
1252         if (lua_isuserdata(L, index)) {
1253                 // Convert from LuaItemStack
1254                 LuaItemStack *o = LuaItemStack::checkobject(L, index);
1255                 return o->getItem();
1256         }
1257
1258         if (lua_isstring(L, index)) {
1259                 // Convert from itemstring
1260                 std::string itemstring = lua_tostring(L, index);
1261                 try
1262                 {
1263                         ItemStack item;
1264                         item.deSerialize(itemstring, idef);
1265                         return item;
1266                 }
1267                 catch(SerializationError &e)
1268                 {
1269                         warningstream<<"unable to create item from itemstring"
1270                                         <<": "<<itemstring<<std::endl;
1271                         return ItemStack();
1272                 }
1273         }
1274         else if(lua_istable(L, index))
1275         {
1276                 // Convert from table
1277                 std::string name = getstringfield_default(L, index, "name", "");
1278                 int count = getintfield_default(L, index, "count", 1);
1279                 int wear = getintfield_default(L, index, "wear", 0);
1280
1281                 ItemStack istack(name, count, wear, idef);
1282
1283                 // BACKWARDS COMPATIBLITY
1284                 std::string value = getstringfield_default(L, index, "metadata", "");
1285                 istack.metadata.setString("", value);
1286
1287                 // Get meta
1288                 lua_getfield(L, index, "meta");
1289                 int fieldstable = lua_gettop(L);
1290                 if (lua_istable(L, fieldstable)) {
1291                         lua_pushnil(L);
1292                         while (lua_next(L, fieldstable) != 0) {
1293                                 // key at index -2 and value at index -1
1294                                 std::string key = lua_tostring(L, -2);
1295                                 size_t value_len;
1296                                 const char *value_cs = lua_tolstring(L, -1, &value_len);
1297                                 std::string value(value_cs, value_len);
1298                                 istack.metadata.setString(key, value);
1299                                 lua_pop(L, 1); // removes value, keeps key for next iteration
1300                         }
1301                 }
1302
1303                 return istack;
1304         } else {
1305                 throw LuaError("Expecting itemstack, itemstring, table or nil");
1306         }
1307 }
1308
1309 /******************************************************************************/
1310 void push_tool_capabilities(lua_State *L,
1311                 const ToolCapabilities &toolcap)
1312 {
1313         lua_newtable(L);
1314         setfloatfield(L, -1, "full_punch_interval", toolcap.full_punch_interval);
1315         setintfield(L, -1, "max_drop_level", toolcap.max_drop_level);
1316         setintfield(L, -1, "punch_attack_uses", toolcap.punch_attack_uses);
1317                 // Create groupcaps table
1318                 lua_newtable(L);
1319                 // For each groupcap
1320                 for (const auto &gc_it : toolcap.groupcaps) {
1321                         // Create groupcap table
1322                         lua_newtable(L);
1323                         const std::string &name = gc_it.first;
1324                         const ToolGroupCap &groupcap = gc_it.second;
1325                         // Create subtable "times"
1326                         lua_newtable(L);
1327                         for (auto time : groupcap.times) {
1328                                 lua_pushinteger(L, time.first);
1329                                 lua_pushnumber(L, time.second);
1330                                 lua_settable(L, -3);
1331                         }
1332                         // Set subtable "times"
1333                         lua_setfield(L, -2, "times");
1334                         // Set simple parameters
1335                         setintfield(L, -1, "maxlevel", groupcap.maxlevel);
1336                         setintfield(L, -1, "uses", groupcap.uses);
1337                         // Insert groupcap table into groupcaps table
1338                         lua_setfield(L, -2, name.c_str());
1339                 }
1340                 // Set groupcaps table
1341                 lua_setfield(L, -2, "groupcaps");
1342                 //Create damage_groups table
1343                 lua_newtable(L);
1344                 // For each damage group
1345                 for (const auto &damageGroup : toolcap.damageGroups) {
1346                         // Create damage group table
1347                         lua_pushinteger(L, damageGroup.second);
1348                         lua_setfield(L, -2, damageGroup.first.c_str());
1349                 }
1350                 lua_setfield(L, -2, "damage_groups");
1351 }
1352
1353 /******************************************************************************/
1354 void push_inventory_list(lua_State *L, const InventoryList &invlist)
1355 {
1356         push_items(L, invlist.getItems());
1357 }
1358
1359 /******************************************************************************/
1360 void push_inventory_lists(lua_State *L, const Inventory &inv)
1361 {
1362         const auto &lists = inv.getLists();
1363         lua_createtable(L, 0, lists.size());
1364         for(const InventoryList *list : lists) {
1365                 const std::string &name = list->getName();
1366                 lua_pushlstring(L, name.c_str(), name.size());
1367                 push_inventory_list(L, *list);
1368                 lua_rawset(L, -3);
1369         }
1370 }
1371
1372 /******************************************************************************/
1373 void read_inventory_list(lua_State *L, int tableindex,
1374                 Inventory *inv, const char *name, IGameDef *gdef, int forcesize)
1375 {
1376         if(tableindex < 0)
1377                 tableindex = lua_gettop(L) + 1 + tableindex;
1378
1379         // If nil, delete list
1380         if(lua_isnil(L, tableindex)){
1381                 inv->deleteList(name);
1382                 return;
1383         }
1384
1385         // Get Lua-specified items to insert into the list
1386         std::vector<ItemStack> items = read_items(L, tableindex, gdef);
1387         size_t listsize = (forcesize >= 0) ? forcesize : items.size();
1388
1389         // Create or resize/clear list
1390         InventoryList *invlist = inv->addList(name, listsize);
1391         if (!invlist) {
1392                 luaL_error(L, "inventory list: cannot create list named '%s'", name);
1393                 return;
1394         }
1395
1396         for (size_t i = 0; i < items.size(); ++i) {
1397                 if (i == listsize)
1398                         break; // Truncate provided list of items
1399                 invlist->changeItem(i, items[i]);
1400         }
1401 }
1402
1403 /******************************************************************************/
1404 struct TileAnimationParams read_animation_definition(lua_State *L, int index)
1405 {
1406         if(index < 0)
1407                 index = lua_gettop(L) + 1 + index;
1408
1409         struct TileAnimationParams anim;
1410         anim.type = TAT_NONE;
1411         if (!lua_istable(L, index))
1412                 return anim;
1413
1414         anim.type = (TileAnimationType)
1415                 getenumfield(L, index, "type", es_TileAnimationType,
1416                 TAT_NONE);
1417         if (anim.type == TAT_VERTICAL_FRAMES) {
1418                 // {type="vertical_frames", aspect_w=16, aspect_h=16, length=2.0}
1419                 anim.vertical_frames.aspect_w =
1420                         getintfield_default(L, index, "aspect_w", 16);
1421                 anim.vertical_frames.aspect_h =
1422                         getintfield_default(L, index, "aspect_h", 16);
1423                 anim.vertical_frames.length =
1424                         getfloatfield_default(L, index, "length", 1.0);
1425         } else if (anim.type == TAT_SHEET_2D) {
1426                 // {type="sheet_2d", frames_w=5, frames_h=3, frame_length=0.5}
1427                 getintfield(L, index, "frames_w",
1428                         anim.sheet_2d.frames_w);
1429                 getintfield(L, index, "frames_h",
1430                         anim.sheet_2d.frames_h);
1431                 getfloatfield(L, index, "frame_length",
1432                         anim.sheet_2d.frame_length);
1433         }
1434
1435         return anim;
1436 }
1437
1438 /******************************************************************************/
1439 ToolCapabilities read_tool_capabilities(
1440                 lua_State *L, int table)
1441 {
1442         ToolCapabilities toolcap;
1443         getfloatfield(L, table, "full_punch_interval", toolcap.full_punch_interval);
1444         getintfield(L, table, "max_drop_level", toolcap.max_drop_level);
1445         getintfield(L, table, "punch_attack_uses", toolcap.punch_attack_uses);
1446         lua_getfield(L, table, "groupcaps");
1447         if(lua_istable(L, -1)){
1448                 int table_groupcaps = lua_gettop(L);
1449                 lua_pushnil(L);
1450                 while(lua_next(L, table_groupcaps) != 0){
1451                         // key at index -2 and value at index -1
1452                         std::string groupname = luaL_checkstring(L, -2);
1453                         if(lua_istable(L, -1)){
1454                                 int table_groupcap = lua_gettop(L);
1455                                 // This will be created
1456                                 ToolGroupCap groupcap;
1457                                 // Read simple parameters
1458                                 getintfield(L, table_groupcap, "maxlevel", groupcap.maxlevel);
1459                                 getintfield(L, table_groupcap, "uses", groupcap.uses);
1460                                 // DEPRECATED: maxwear
1461                                 float maxwear = 0;
1462                                 if (getfloatfield(L, table_groupcap, "maxwear", maxwear)){
1463                                         if (maxwear != 0)
1464                                                 groupcap.uses = 1.0/maxwear;
1465                                         else
1466                                                 groupcap.uses = 0;
1467                                         warningstream << "Field \"maxwear\" is deprecated; "
1468                                                         << "replace with uses=1/maxwear" << std::endl;
1469                                         infostream << script_get_backtrace(L) << std::endl;
1470                                 }
1471                                 // Read "times" table
1472                                 lua_getfield(L, table_groupcap, "times");
1473                                 if(lua_istable(L, -1)){
1474                                         int table_times = lua_gettop(L);
1475                                         lua_pushnil(L);
1476                                         while(lua_next(L, table_times) != 0){
1477                                                 // key at index -2 and value at index -1
1478                                                 int rating = luaL_checkinteger(L, -2);
1479                                                 float time = luaL_checknumber(L, -1);
1480                                                 groupcap.times[rating] = time;
1481                                                 // removes value, keeps key for next iteration
1482                                                 lua_pop(L, 1);
1483                                         }
1484                                 }
1485                                 lua_pop(L, 1);
1486                                 // Insert groupcap into toolcap
1487                                 toolcap.groupcaps[groupname] = groupcap;
1488                         }
1489                         // removes value, keeps key for next iteration
1490                         lua_pop(L, 1);
1491                 }
1492         }
1493         lua_pop(L, 1);
1494
1495         lua_getfield(L, table, "damage_groups");
1496         if(lua_istable(L, -1)){
1497                 int table_damage_groups = lua_gettop(L);
1498                 lua_pushnil(L);
1499                 while(lua_next(L, table_damage_groups) != 0){
1500                         // key at index -2 and value at index -1
1501                         std::string groupname = luaL_checkstring(L, -2);
1502                         u16 value = luaL_checkinteger(L, -1);
1503                         toolcap.damageGroups[groupname] = value;
1504                         // removes value, keeps key for next iteration
1505                         lua_pop(L, 1);
1506                 }
1507         }
1508         lua_pop(L, 1);
1509         return toolcap;
1510 }
1511
1512 /******************************************************************************/
1513 void push_dig_params(lua_State *L,const DigParams &params)
1514 {
1515         lua_createtable(L, 0, 3);
1516         setboolfield(L, -1, "diggable", params.diggable);
1517         setfloatfield(L, -1, "time", params.time);
1518         setintfield(L, -1, "wear", params.wear);
1519 }
1520
1521 /******************************************************************************/
1522 void push_hit_params(lua_State *L,const HitParams &params)
1523 {
1524         lua_createtable(L, 0, 3);
1525         setintfield(L, -1, "hp", params.hp);
1526         setintfield(L, -1, "wear", params.wear);
1527 }
1528
1529 /******************************************************************************/
1530
1531 bool getflagsfield(lua_State *L, int table, const char *fieldname,
1532         FlagDesc *flagdesc, u32 *flags, u32 *flagmask)
1533 {
1534         lua_getfield(L, table, fieldname);
1535
1536         bool success = read_flags(L, -1, flagdesc, flags, flagmask);
1537
1538         lua_pop(L, 1);
1539
1540         return success;
1541 }
1542
1543 bool read_flags(lua_State *L, int index, FlagDesc *flagdesc,
1544         u32 *flags, u32 *flagmask)
1545 {
1546         if (lua_isstring(L, index)) {
1547                 std::string flagstr = lua_tostring(L, index);
1548                 *flags = readFlagString(flagstr, flagdesc, flagmask);
1549         } else if (lua_istable(L, index)) {
1550                 *flags = read_flags_table(L, index, flagdesc, flagmask);
1551         } else {
1552                 return false;
1553         }
1554
1555         return true;
1556 }
1557
1558 u32 read_flags_table(lua_State *L, int table, FlagDesc *flagdesc, u32 *flagmask)
1559 {
1560         u32 flags = 0, mask = 0;
1561         char fnamebuf[64] = "no";
1562
1563         for (int i = 0; flagdesc[i].name; i++) {
1564                 bool result;
1565
1566                 if (getboolfield(L, table, flagdesc[i].name, result)) {
1567                         mask |= flagdesc[i].flag;
1568                         if (result)
1569                                 flags |= flagdesc[i].flag;
1570                 }
1571
1572                 strlcpy(fnamebuf + 2, flagdesc[i].name, sizeof(fnamebuf) - 2);
1573                 if (getboolfield(L, table, fnamebuf, result))
1574                         mask |= flagdesc[i].flag;
1575         }
1576
1577         if (flagmask)
1578                 *flagmask = mask;
1579
1580         return flags;
1581 }
1582
1583 void push_flags_string(lua_State *L, FlagDesc *flagdesc, u32 flags, u32 flagmask)
1584 {
1585         std::string flagstring = writeFlagString(flags, flagdesc, flagmask);
1586         lua_pushlstring(L, flagstring.c_str(), flagstring.size());
1587 }
1588
1589 /******************************************************************************/
1590 /* Lua Stored data!                                                           */
1591 /******************************************************************************/
1592
1593 /******************************************************************************/
1594 void read_groups(lua_State *L, int index, ItemGroupList &result)
1595 {
1596         if (lua_isnil(L, index))
1597                 return;
1598
1599         luaL_checktype(L, index, LUA_TTABLE);
1600
1601         result.clear();
1602         lua_pushnil(L);
1603         if (index < 0)
1604                 index -= 1;
1605         while (lua_next(L, index) != 0) {
1606                 // key at index -2 and value at index -1
1607                 std::string name = luaL_checkstring(L, -2);
1608                 int rating = luaL_checkinteger(L, -1);
1609                 // zero rating indicates not in the group
1610                 if (rating != 0)
1611                         result[name] = rating;
1612                 // removes value, keeps key for next iteration
1613                 lua_pop(L, 1);
1614         }
1615 }
1616
1617 /******************************************************************************/
1618 void push_groups(lua_State *L, const ItemGroupList &groups)
1619 {
1620         lua_createtable(L, 0, groups.size());
1621         for (const auto &group : groups) {
1622                 lua_pushinteger(L, group.second);
1623                 lua_setfield(L, -2, group.first.c_str());
1624         }
1625 }
1626
1627 /******************************************************************************/
1628 void push_items(lua_State *L, const std::vector<ItemStack> &items)
1629 {
1630         lua_createtable(L, items.size(), 0);
1631         for (u32 i = 0; i != items.size(); i++) {
1632                 LuaItemStack::create(L, items[i]);
1633                 lua_rawseti(L, -2, i + 1);
1634         }
1635 }
1636
1637 /******************************************************************************/
1638 std::vector<ItemStack> read_items(lua_State *L, int index, IGameDef *gdef)
1639 {
1640         if(index < 0)
1641                 index = lua_gettop(L) + 1 + index;
1642
1643         std::vector<ItemStack> items;
1644         luaL_checktype(L, index, LUA_TTABLE);
1645         lua_pushnil(L);
1646         while (lua_next(L, index)) {
1647                 s32 key = luaL_checkinteger(L, -2);
1648                 if (key < 1) {
1649                         throw LuaError("Invalid inventory list index");
1650                 }
1651                 if (items.size() < (u32) key) {
1652                         items.resize(key);
1653                 }
1654                 items[key - 1] = read_item(L, -1, gdef->idef());
1655                 lua_pop(L, 1);
1656         }
1657         return items;
1658 }
1659
1660 /******************************************************************************/
1661 void luaentity_get(lua_State *L, u16 id)
1662 {
1663         // Get luaentities[i]
1664         lua_getglobal(L, "core");
1665         lua_getfield(L, -1, "luaentities");
1666         luaL_checktype(L, -1, LUA_TTABLE);
1667         lua_pushinteger(L, id);
1668         lua_gettable(L, -2);
1669         lua_remove(L, -2); // Remove luaentities
1670         lua_remove(L, -2); // Remove core
1671 }
1672
1673 /******************************************************************************/
1674 bool read_noiseparams(lua_State *L, int index, NoiseParams *np)
1675 {
1676         if (index < 0)
1677                 index = lua_gettop(L) + 1 + index;
1678
1679         if (!lua_istable(L, index))
1680                 return false;
1681
1682         getfloatfield(L, index, "offset",      np->offset);
1683         getfloatfield(L, index, "scale",       np->scale);
1684         getfloatfield(L, index, "persist",     np->persist);
1685         getfloatfield(L, index, "persistence", np->persist);
1686         getfloatfield(L, index, "lacunarity",  np->lacunarity);
1687         getintfield(L,   index, "seed",        np->seed);
1688         getintfield(L,   index, "octaves",     np->octaves);
1689
1690         u32 flags    = 0;
1691         u32 flagmask = 0;
1692         np->flags = getflagsfield(L, index, "flags", flagdesc_noiseparams,
1693                 &flags, &flagmask) ? flags : NOISE_FLAG_DEFAULTS;
1694
1695         lua_getfield(L, index, "spread");
1696         np->spread  = read_v3f(L, -1);
1697         lua_pop(L, 1);
1698
1699         return true;
1700 }
1701
1702 void push_noiseparams(lua_State *L, NoiseParams *np)
1703 {
1704         lua_newtable(L);
1705         setfloatfield(L, -1, "offset",      np->offset);
1706         setfloatfield(L, -1, "scale",       np->scale);
1707         setfloatfield(L, -1, "persist",     np->persist);
1708         setfloatfield(L, -1, "persistence", np->persist);
1709         setfloatfield(L, -1, "lacunarity",  np->lacunarity);
1710         setintfield(  L, -1, "seed",        np->seed);
1711         setintfield(  L, -1, "octaves",     np->octaves);
1712
1713         push_flags_string(L, flagdesc_noiseparams, np->flags,
1714                 np->flags);
1715         lua_setfield(L, -2, "flags");
1716
1717         push_v3f(L, np->spread);
1718         lua_setfield(L, -2, "spread");
1719 }
1720
1721 /******************************************************************************/
1722 // Returns depth of json value tree
1723 static int push_json_value_getdepth(const Json::Value &value)
1724 {
1725         if (!value.isArray() && !value.isObject())
1726                 return 1;
1727
1728         int maxdepth = 0;
1729         for (const auto &it : value) {
1730                 int elemdepth = push_json_value_getdepth(it);
1731                 if (elemdepth > maxdepth)
1732                         maxdepth = elemdepth;
1733         }
1734         return maxdepth + 1;
1735 }
1736 // Recursive function to convert JSON --> Lua table
1737 static bool push_json_value_helper(lua_State *L, const Json::Value &value,
1738                 int nullindex)
1739 {
1740         switch(value.type()) {
1741                 case Json::nullValue:
1742                 default:
1743                         lua_pushvalue(L, nullindex);
1744                         break;
1745                 case Json::intValue:
1746                         lua_pushinteger(L, value.asLargestInt());
1747                         break;
1748                 case Json::uintValue:
1749                         lua_pushinteger(L, value.asLargestUInt());
1750                         break;
1751                 case Json::realValue:
1752                         lua_pushnumber(L, value.asDouble());
1753                         break;
1754                 case Json::stringValue:
1755                         {
1756                                 const char *str = value.asCString();
1757                                 lua_pushstring(L, str ? str : "");
1758                         }
1759                         break;
1760                 case Json::booleanValue:
1761                         lua_pushboolean(L, value.asInt());
1762                         break;
1763                 case Json::arrayValue:
1764                         lua_createtable(L, value.size(), 0);
1765                         for (Json::Value::const_iterator it = value.begin();
1766                                         it != value.end(); ++it) {
1767                                 push_json_value_helper(L, *it, nullindex);
1768                                 lua_rawseti(L, -2, it.index() + 1);
1769                         }
1770                         break;
1771                 case Json::objectValue:
1772                         lua_createtable(L, 0, value.size());
1773                         for (Json::Value::const_iterator it = value.begin();
1774                                         it != value.end(); ++it) {
1775 #if !defined(JSONCPP_STRING) && (JSONCPP_VERSION_MAJOR < 1 || JSONCPP_VERSION_MINOR < 9)
1776                                 const char *str = it.memberName();
1777                                 lua_pushstring(L, str ? str : "");
1778 #else
1779                                 std::string str = it.name();
1780                                 lua_pushstring(L, str.c_str());
1781 #endif
1782                                 push_json_value_helper(L, *it, nullindex);
1783                                 lua_rawset(L, -3);
1784                         }
1785                         break;
1786         }
1787         return true;
1788 }
1789 // converts JSON --> Lua table; returns false if lua stack limit exceeded
1790 // nullindex: Lua stack index of value to use in place of JSON null
1791 bool push_json_value(lua_State *L, const Json::Value &value, int nullindex)
1792 {
1793         if(nullindex < 0)
1794                 nullindex = lua_gettop(L) + 1 + nullindex;
1795
1796         int depth = push_json_value_getdepth(value);
1797
1798         // The maximum number of Lua stack slots used at each recursion level
1799         // of push_json_value_helper is 2, so make sure there a depth * 2 slots
1800         if (lua_checkstack(L, depth * 2))
1801                 return push_json_value_helper(L, value, nullindex);
1802
1803         return false;
1804 }
1805
1806 // Converts Lua table --> JSON
1807 void read_json_value(lua_State *L, Json::Value &root, int index, u8 recursion)
1808 {
1809         if (recursion > 16) {
1810                 throw SerializationError("Maximum recursion depth exceeded");
1811         }
1812         int type = lua_type(L, index);
1813         if (type == LUA_TBOOLEAN) {
1814                 root = (bool) lua_toboolean(L, index);
1815         } else if (type == LUA_TNUMBER) {
1816                 root = lua_tonumber(L, index);
1817         } else if (type == LUA_TSTRING) {
1818                 size_t len;
1819                 const char *str = lua_tolstring(L, index, &len);
1820                 root = std::string(str, len);
1821         } else if (type == LUA_TTABLE) {
1822                 lua_pushnil(L);
1823                 while (lua_next(L, index)) {
1824                         // Key is at -2 and value is at -1
1825                         Json::Value value;
1826                         read_json_value(L, value, lua_gettop(L), recursion + 1);
1827
1828                         Json::ValueType roottype = root.type();
1829                         int keytype = lua_type(L, -1);
1830                         if (keytype == LUA_TNUMBER) {
1831                                 lua_Number key = lua_tonumber(L, -1);
1832                                 if (roottype != Json::nullValue && roottype != Json::arrayValue) {
1833                                         throw SerializationError("Can't mix array and object values in JSON");
1834                                 } else if (key < 1) {
1835                                         throw SerializationError("Can't use zero-based or negative indexes in JSON");
1836                                 } else if (floor(key) != key) {
1837                                         throw SerializationError("Can't use indexes with a fractional part in JSON");
1838                                 }
1839                                 root[(Json::ArrayIndex) key - 1] = value;
1840                         } else if (keytype == LUA_TSTRING) {
1841                                 if (roottype != Json::nullValue && roottype != Json::objectValue) {
1842                                         throw SerializationError("Can't mix array and object values in JSON");
1843                                 }
1844                                 root[lua_tostring(L, -1)] = value;
1845                         } else {
1846                                 throw SerializationError("Lua key to convert to JSON is not a string or number");
1847                         }
1848                 }
1849         } else if (type == LUA_TNIL) {
1850                 root = Json::nullValue;
1851         } else {
1852                 throw SerializationError("Can only store booleans, numbers, strings, objects, arrays, and null in JSON");
1853         }
1854         lua_pop(L, 1); // Pop value
1855 }
1856
1857 void push_pointed_thing(lua_State *L, const PointedThing &pointed, bool csm,
1858         bool hitpoint)
1859 {
1860         lua_newtable(L);
1861         if (pointed.type == POINTEDTHING_NODE) {
1862                 lua_pushstring(L, "node");
1863                 lua_setfield(L, -2, "type");
1864                 push_v3s16(L, pointed.node_undersurface);
1865                 lua_setfield(L, -2, "under");
1866                 push_v3s16(L, pointed.node_abovesurface);
1867                 lua_setfield(L, -2, "above");
1868         } else if (pointed.type == POINTEDTHING_OBJECT) {
1869                 lua_pushstring(L, "object");
1870                 lua_setfield(L, -2, "type");
1871
1872                 if (csm) {
1873                         lua_pushinteger(L, pointed.object_id);
1874                         lua_setfield(L, -2, "id");
1875                 } else {
1876                         push_objectRef(L, pointed.object_id);
1877                         lua_setfield(L, -2, "ref");
1878                 }
1879         } else {
1880                 lua_pushstring(L, "nothing");
1881                 lua_setfield(L, -2, "type");
1882         }
1883         if (hitpoint && (pointed.type != POINTEDTHING_NOTHING)) {
1884                 push_v3f(L, pointed.intersection_point / BS); // convert to node coords
1885                 lua_setfield(L, -2, "intersection_point");
1886                 push_v3s16(L, pointed.intersection_normal);
1887                 lua_setfield(L, -2, "intersection_normal");
1888                 lua_pushinteger(L, pointed.box_id + 1); // change to Lua array index
1889                 lua_setfield(L, -2, "box_id");
1890         }
1891 }
1892
1893 void push_objectRef(lua_State *L, const u16 id)
1894 {
1895         // Get core.object_refs[i]
1896         lua_getglobal(L, "core");
1897         lua_getfield(L, -1, "object_refs");
1898         luaL_checktype(L, -1, LUA_TTABLE);
1899         lua_pushinteger(L, id);
1900         lua_gettable(L, -2);
1901         lua_remove(L, -2); // object_refs
1902         lua_remove(L, -2); // core
1903 }
1904
1905 void read_hud_element(lua_State *L, HudElement *elem)
1906 {
1907         elem->type = (HudElementType)getenumfield(L, 2, "hud_elem_type",
1908                                                                         es_HudElementType, HUD_ELEM_TEXT);
1909
1910         lua_getfield(L, 2, "position");
1911         elem->pos = lua_istable(L, -1) ? read_v2f(L, -1) : v2f();
1912         lua_pop(L, 1);
1913
1914         lua_getfield(L, 2, "scale");
1915         elem->scale = lua_istable(L, -1) ? read_v2f(L, -1) : v2f();
1916         lua_pop(L, 1);
1917
1918         lua_getfield(L, 2, "size");
1919         elem->size = lua_istable(L, -1) ? read_v2s32(L, -1) : v2s32();
1920         lua_pop(L, 1);
1921
1922         elem->name    = getstringfield_default(L, 2, "name", "");
1923         elem->text    = getstringfield_default(L, 2, "text", "");
1924         elem->number  = getintfield_default(L, 2, "number", 0);
1925         if (elem->type == HUD_ELEM_WAYPOINT)
1926                 // waypoints reuse the item field to store precision, item = precision + 1
1927                 elem->item = getintfield_default(L, 2, "precision", -1) + 1;
1928         else
1929                 elem->item = getintfield_default(L, 2, "item", 0);
1930         elem->dir     = getintfield_default(L, 2, "direction", 0);
1931         elem->z_index = MYMAX(S16_MIN, MYMIN(S16_MAX,
1932                         getintfield_default(L, 2, "z_index", 0)));
1933         elem->text2   = getstringfield_default(L, 2, "text2", "");
1934
1935         // Deprecated, only for compatibility's sake
1936         if (elem->dir == 0)
1937                 elem->dir = getintfield_default(L, 2, "dir", 0);
1938
1939         lua_getfield(L, 2, "alignment");
1940         elem->align = lua_istable(L, -1) ? read_v2f(L, -1) : v2f();
1941         lua_pop(L, 1);
1942
1943         lua_getfield(L, 2, "offset");
1944         elem->offset = lua_istable(L, -1) ? read_v2f(L, -1) : v2f();
1945         lua_pop(L, 1);
1946
1947         lua_getfield(L, 2, "world_pos");
1948         elem->world_pos = lua_istable(L, -1) ? read_v3f(L, -1) : v3f();
1949         lua_pop(L, 1);
1950
1951         elem->style = getintfield_default(L, 2, "style", 0);
1952
1953         /* check for known deprecated element usage */
1954         if ((elem->type  == HUD_ELEM_STATBAR) && (elem->size == v2s32()))
1955                 log_deprecated(L,"Deprecated usage of statbar without size!");
1956 }
1957
1958 void push_hud_element(lua_State *L, HudElement *elem)
1959 {
1960         lua_newtable(L);
1961
1962         lua_pushstring(L, es_HudElementType[(u8)elem->type].str);
1963         lua_setfield(L, -2, "type");
1964
1965         push_v2f(L, elem->pos);
1966         lua_setfield(L, -2, "position");
1967
1968         lua_pushstring(L, elem->name.c_str());
1969         lua_setfield(L, -2, "name");
1970
1971         push_v2f(L, elem->scale);
1972         lua_setfield(L, -2, "scale");
1973
1974         lua_pushstring(L, elem->text.c_str());
1975         lua_setfield(L, -2, "text");
1976
1977         lua_pushnumber(L, elem->number);
1978         lua_setfield(L, -2, "number");
1979
1980         if (elem->type == HUD_ELEM_WAYPOINT) {
1981                 // waypoints reuse the item field to store precision, precision = item - 1
1982                 lua_pushnumber(L, elem->item - 1);
1983                 lua_setfield(L, -2, "precision");
1984         }
1985         // push the item field for waypoints as well for backwards compatibility
1986         lua_pushnumber(L, elem->item);
1987         lua_setfield(L, -2, "item");
1988
1989         lua_pushnumber(L, elem->dir);
1990         lua_setfield(L, -2, "direction");
1991
1992         push_v2f(L, elem->offset);
1993         lua_setfield(L, -2, "offset");
1994
1995         push_v2f(L, elem->align);
1996         lua_setfield(L, -2, "alignment");
1997
1998         push_v2s32(L, elem->size);
1999         lua_setfield(L, -2, "size");
2000
2001         // Deprecated, only for compatibility's sake
2002         lua_pushnumber(L, elem->dir);
2003         lua_setfield(L, -2, "dir");
2004
2005         push_v3f(L, elem->world_pos);
2006         lua_setfield(L, -2, "world_pos");
2007
2008         lua_pushnumber(L, elem->z_index);
2009         lua_setfield(L, -2, "z_index");
2010
2011         lua_pushstring(L, elem->text2.c_str());
2012         lua_setfield(L, -2, "text2");
2013
2014         lua_pushinteger(L, elem->style);
2015         lua_setfield(L, -2, "style");
2016 }
2017
2018 bool read_hud_change(lua_State *L, HudElementStat &stat, HudElement *elem, void **value)
2019 {
2020         std::string statstr = lua_tostring(L, 3);
2021         {
2022                 int statint;
2023                 if (!string_to_enum(es_HudElementStat, statint, statstr)) {
2024                         script_log_unique(L, "Unknown HUD stat type: " + statstr, warningstream);
2025                         return false;
2026                 }
2027
2028                 stat = (HudElementStat)statint;
2029         }
2030
2031         switch (stat) {
2032                 case HUD_STAT_POS:
2033                         elem->pos = read_v2f(L, 4);
2034                         *value = &elem->pos;
2035                         break;
2036                 case HUD_STAT_NAME:
2037                         elem->name = luaL_checkstring(L, 4);
2038                         *value = &elem->name;
2039                         break;
2040                 case HUD_STAT_SCALE:
2041                         elem->scale = read_v2f(L, 4);
2042                         *value = &elem->scale;
2043                         break;
2044                 case HUD_STAT_TEXT:
2045                         elem->text = luaL_checkstring(L, 4);
2046                         *value = &elem->text;
2047                         break;
2048                 case HUD_STAT_NUMBER:
2049                         elem->number = luaL_checknumber(L, 4);
2050                         *value = &elem->number;
2051                         break;
2052                 case HUD_STAT_ITEM:
2053                         elem->item = luaL_checknumber(L, 4);
2054                         if (elem->type == HUD_ELEM_WAYPOINT && statstr == "precision")
2055                                 elem->item++;
2056                         *value = &elem->item;
2057                         break;
2058                 case HUD_STAT_DIR:
2059                         elem->dir = luaL_checknumber(L, 4);
2060                         *value = &elem->dir;
2061                         break;
2062                 case HUD_STAT_ALIGN:
2063                         elem->align = read_v2f(L, 4);
2064                         *value = &elem->align;
2065                         break;
2066                 case HUD_STAT_OFFSET:
2067                         elem->offset = read_v2f(L, 4);
2068                         *value = &elem->offset;
2069                         break;
2070                 case HUD_STAT_WORLD_POS:
2071                         elem->world_pos = read_v3f(L, 4);
2072                         *value = &elem->world_pos;
2073                         break;
2074                 case HUD_STAT_SIZE:
2075                         elem->size = read_v2s32(L, 4);
2076                         *value = &elem->size;
2077                         break;
2078                 case HUD_STAT_Z_INDEX:
2079                         elem->z_index = MYMAX(S16_MIN, MYMIN(S16_MAX, luaL_checknumber(L, 4)));
2080                         *value = &elem->z_index;
2081                         break;
2082                 case HUD_STAT_TEXT2:
2083                         elem->text2 = luaL_checkstring(L, 4);
2084                         *value = &elem->text2;
2085                         break;
2086                 case HUD_STAT_STYLE:
2087                         elem->style = luaL_checknumber(L, 4);
2088                         *value = &elem->style;
2089                         break;
2090         }
2091
2092         return true;
2093 }
2094
2095 /******************************************************************************/
2096
2097 // Indices must match values in `enum CollisionType` exactly!!
2098 static const char *collision_type_str[] = {
2099         "node",
2100         "object",
2101 };
2102
2103 // Indices must match values in `enum CollisionAxis` exactly!!
2104 static const char *collision_axis_str[] = {
2105         "x",
2106         "y",
2107         "z",
2108 };
2109
2110 void push_collision_move_result(lua_State *L, const collisionMoveResult &res)
2111 {
2112         lua_createtable(L, 0, 4);
2113
2114         setboolfield(L, -1, "touching_ground", res.touching_ground);
2115         setboolfield(L, -1, "collides", res.collides);
2116         setboolfield(L, -1, "standing_on_object", res.standing_on_object);
2117
2118         /* collisions */
2119         lua_createtable(L, res.collisions.size(), 0);
2120         int i = 1;
2121         for (const auto &c : res.collisions) {
2122                 lua_createtable(L, 0, 5);
2123
2124                 lua_pushstring(L, collision_type_str[c.type]);
2125                 lua_setfield(L, -2, "type");
2126
2127                 assert(c.axis != COLLISION_AXIS_NONE);
2128                 lua_pushstring(L, collision_axis_str[c.axis]);
2129                 lua_setfield(L, -2, "axis");
2130
2131                 if (c.type == COLLISION_NODE) {
2132                         push_v3s16(L, c.node_p);
2133                         lua_setfield(L, -2, "node_pos");
2134                 } else if (c.type == COLLISION_OBJECT) {
2135                         push_objectRef(L, c.object->getId());
2136                         lua_setfield(L, -2, "object");
2137                 }
2138
2139                 push_v3f(L, c.old_speed / BS);
2140                 lua_setfield(L, -2, "old_velocity");
2141
2142                 push_v3f(L, c.new_speed / BS);
2143                 lua_setfield(L, -2, "new_velocity");
2144
2145                 lua_rawseti(L, -2, i++);
2146         }
2147         lua_setfield(L, -2, "collisions");
2148         /**/
2149 }