src/script/lua_api/l_object.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "lua_api/l_object.h"
  21 #include "lua_api/l_internal.h"
  22 #include "lua_api/l_inventory.h"
  23 #include "lua_api/l_item.h"
  24 #include "common/c_converter.h"
  25 #include "common/c_content.h"
  26 #include "log.h"
  27 #include "tool.h"
  28 #include "serverobject.h"
  29 #include "content_sao.h"
  30 #include "server.h"
  31 #include "hud.h"
  32 #include "scripting_game.h"
  33
  34 struct EnumString es_HudElementType[] =
  35 {
  36         {HUD_ELEM_IMAGE,     "image"},
  37         {HUD_ELEM_TEXT,      "text"},
  38         {HUD_ELEM_STATBAR,   "statbar"},
  39         {HUD_ELEM_INVENTORY, "inventory"},
  40         {HUD_ELEM_WAYPOINT,  "waypoint"},
  41 {0, NULL},
  42 };
  43
  44 struct EnumString es_HudElementStat[] =
  45 {
  46         {HUD_STAT_POS,    "position"},
  47         {HUD_STAT_POS,    "pos"}, /* Deprecated, only for compatibility's sake */
  48         {HUD_STAT_NAME,   "name"},
  49         {HUD_STAT_SCALE,  "scale"},
  50         {HUD_STAT_TEXT,   "text"},
  51         {HUD_STAT_NUMBER, "number"},
  52         {HUD_STAT_ITEM,   "item"},
  53         {HUD_STAT_DIR,    "direction"},
  54         {HUD_STAT_ALIGN,  "alignment"},
  55         {HUD_STAT_OFFSET, "offset"},
  56         {HUD_STAT_WORLD_POS, "world_pos"},
  57         {0, NULL},
  58 };
  59
  60 struct EnumString es_HudBuiltinElement[] =
  61 {
  62         {HUD_FLAG_HOTBAR_VISIBLE,    "hotbar"},
  63         {HUD_FLAG_HEALTHBAR_VISIBLE, "healthbar"},
  64         {HUD_FLAG_CROSSHAIR_VISIBLE, "crosshair"},
  65         {HUD_FLAG_WIELDITEM_VISIBLE, "wielditem"},
  66         {HUD_FLAG_BREATHBAR_VISIBLE, "breathbar"},
  67         {HUD_FLAG_MINIMAP_VISIBLE,   "minimap"},
  68         {0, NULL},
  69 };
  70
  71 /*
  72         ObjectRef
  73 */
  74
  75
  76 ObjectRef* ObjectRef::checkobject(lua_State *L, int narg)
  77 {
  78         luaL_checktype(L, narg, LUA_TUSERDATA);
  79         void *ud = luaL_checkudata(L, narg, className);
  80         if (!ud) luaL_typerror(L, narg, className);
  81         return *(ObjectRef**)ud;  // unbox pointer
  82 }
  83
  84 ServerActiveObject* ObjectRef::getobject(ObjectRef *ref)
  85 {
  86         ServerActiveObject *co = ref->m_object;
  87         return co;
  88 }
  89
  90 LuaEntitySAO* ObjectRef::getluaobject(ObjectRef *ref)
  91 {
  92         ServerActiveObject *obj = getobject(ref);
  93         if (obj == NULL)
  94                 return NULL;
  95         if (obj->getType() != ACTIVEOBJECT_TYPE_LUAENTITY)
  96                 return NULL;
  97         return (LuaEntitySAO*)obj;
  98 }
  99
 100 PlayerSAO* ObjectRef::getplayersao(ObjectRef *ref)
 101 {
 102         ServerActiveObject *obj = getobject(ref);
 103         if (obj == NULL)
 104                 return NULL;
 105         if (obj->getType() != ACTIVEOBJECT_TYPE_PLAYER)
 106                 return NULL;
 107         return (PlayerSAO*)obj;
 108 }
 109
 110 Player* ObjectRef::getplayer(ObjectRef *ref)
 111 {
 112         PlayerSAO *playersao = getplayersao(ref);
 113         if (playersao == NULL)
 114                 return NULL;
 115         return playersao->getPlayer();
 116 }
 117
 118 // Exported functions
 119
 120 // garbage collector
 121 int ObjectRef::gc_object(lua_State *L) {
 122         ObjectRef *o = *(ObjectRef **)(lua_touserdata(L, 1));
 123         //infostream<<"ObjectRef::gc_object: o="<<o<<std::endl;
 124         delete o;
 125         return 0;
 126 }
 127
 128 // remove(self)
 129 int ObjectRef::l_remove(lua_State *L)
 130 {
 131         GET_ENV_PTR;
 132
 133         ObjectRef *ref = checkobject(L, 1);
 134         ServerActiveObject *co = getobject(ref);
 135         if (co == NULL)
 136                 return 0;
 137         if (co->getType() == ACTIVEOBJECT_TYPE_PLAYER)
 138                 return 0;
 139
 140         std::set<int> child_ids = co->getAttachmentChildIds();
 141         std::set<int>::iterator it;
 142         for (it = child_ids.begin(); it != child_ids.end(); ++it) {
 143                 ServerActiveObject *child = env->getActiveObject(*it);
 144                 child->setAttachment(0, "", v3f(0, 0, 0), v3f(0, 0, 0));
 145         }
 146
 147         verbosestream<<"ObjectRef::l_remove(): id="<<co->getId()<<std::endl;
 148         co->m_removed = true;
 149         return 0;
 150 }
 151
 152 // getpos(self)
 153 // returns: {x=num, y=num, z=num}
 154 int ObjectRef::l_getpos(lua_State *L)
 155 {
 156         NO_MAP_LOCK_REQUIRED;
 157         ObjectRef *ref = checkobject(L, 1);
 158         ServerActiveObject *co = getobject(ref);
 159         if (co == NULL) return 0;
 160         v3f pos = co->getBasePosition() / BS;
 161         lua_newtable(L);
 162         lua_pushnumber(L, pos.X);
 163         lua_setfield(L, -2, "x");
 164         lua_pushnumber(L, pos.Y);
 165         lua_setfield(L, -2, "y");
 166         lua_pushnumber(L, pos.Z);
 167         lua_setfield(L, -2, "z");
 168         return 1;
 169 }
 170
 171 // setpos(self, pos)
 172 int ObjectRef::l_setpos(lua_State *L)
 173 {
 174         NO_MAP_LOCK_REQUIRED;
 175         ObjectRef *ref = checkobject(L, 1);
 176         //LuaEntitySAO *co = getluaobject(ref);
 177         ServerActiveObject *co = getobject(ref);
 178         if (co == NULL) return 0;
 179         // pos
 180         v3f pos = checkFloatPos(L, 2);
 181         // Do it
 182         co->setPos(pos);
 183         return 0;
 184 }
 185
 186 // moveto(self, pos, continuous=false)
 187 int ObjectRef::l_moveto(lua_State *L)
 188 {
 189         NO_MAP_LOCK_REQUIRED;
 190         ObjectRef *ref = checkobject(L, 1);
 191         //LuaEntitySAO *co = getluaobject(ref);
 192         ServerActiveObject *co = getobject(ref);
 193         if (co == NULL) return 0;
 194         // pos
 195         v3f pos = checkFloatPos(L, 2);
 196         // continuous
 197         bool continuous = lua_toboolean(L, 3);
 198         // Do it
 199         co->moveTo(pos, continuous);
 200         return 0;
 201 }
 202
 203 // punch(self, puncher, time_from_last_punch, tool_capabilities, dir)
 204 int ObjectRef::l_punch(lua_State *L)
 205 {
 206         NO_MAP_LOCK_REQUIRED;
 207         ObjectRef *ref = checkobject(L, 1);
 208         ObjectRef *puncher_ref = checkobject(L, 2);
 209         ServerActiveObject *co = getobject(ref);
 210         ServerActiveObject *puncher = getobject(puncher_ref);
 211         if (co == NULL) return 0;
 212         if (puncher == NULL) return 0;
 213         v3f dir;
 214         if (lua_type(L, 5) != LUA_TTABLE)
 215                 dir = co->getBasePosition() - puncher->getBasePosition();
 216         else
 217                 dir = read_v3f(L, 5);
 218         float time_from_last_punch = 1000000;
 219         if (lua_isnumber(L, 3))
 220                 time_from_last_punch = lua_tonumber(L, 3);
 221         ToolCapabilities toolcap = read_tool_capabilities(L, 4);
 222         dir.normalize();
 223
 224         s16 src_original_hp = co->getHP();
 225         s16 dst_origin_hp = puncher->getHP();
 226
 227         // Do it
 228         co->punch(dir, &toolcap, puncher, time_from_last_punch);
 229
 230         // If the punched is a player, and its HP changed
 231         if (src_original_hp != co->getHP() &&
 232                         co->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
 233                 getServer(L)->SendPlayerHPOrDie((PlayerSAO *)co);
 234         }
 235
 236         // If the puncher is a player, and its HP changed
 237         if (dst_origin_hp != puncher->getHP() &&
 238                         puncher->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
 239                 getServer(L)->SendPlayerHPOrDie((PlayerSAO *)puncher);
 240         }
 241         return 0;
 242 }
 243
 244 // right_click(self, clicker); clicker = an another ObjectRef
 245 int ObjectRef::l_right_click(lua_State *L)
 246 {
 247         NO_MAP_LOCK_REQUIRED;
 248         ObjectRef *ref = checkobject(L, 1);
 249         ObjectRef *ref2 = checkobject(L, 2);
 250         ServerActiveObject *co = getobject(ref);
 251         ServerActiveObject *co2 = getobject(ref2);
 252         if (co == NULL) return 0;
 253         if (co2 == NULL) return 0;
 254         // Do it
 255         co->rightClick(co2);
 256         return 0;
 257 }
 258
 259 // set_hp(self, hp)
 260 // hp = number of hitpoints (2 * number of hearts)
 261 // returns: nil
 262 int ObjectRef::l_set_hp(lua_State *L)
 263 {
 264         NO_MAP_LOCK_REQUIRED;
 265         ObjectRef *ref = checkobject(L, 1);
 266         luaL_checknumber(L, 2);
 267         ServerActiveObject *co = getobject(ref);
 268         if (co == NULL) return 0;
 269         int hp = lua_tonumber(L, 2);
 270         /*infostream<<"ObjectRef::l_set_hp(): id="<<co->getId()
 271                         <<" hp="<<hp<<std::endl;*/
 272         // Do it
 273         co->setHP(hp);
 274         if (co->getType() == ACTIVEOBJECT_TYPE_PLAYER)
 275                 getServer(L)->SendPlayerHPOrDie((PlayerSAO *)co);
 276
 277         // Return
 278         return 0;
 279 }
 280
 281 // get_hp(self)
 282 // returns: number of hitpoints (2 * number of hearts)
 283 // 0 if not applicable to this type of object
 284 int ObjectRef::l_get_hp(lua_State *L)
 285 {
 286         NO_MAP_LOCK_REQUIRED;
 287         ObjectRef *ref = checkobject(L, 1);
 288         ServerActiveObject *co = getobject(ref);
 289         if (co == NULL) {
 290                 // Default hp is 1
 291                 lua_pushnumber(L, 1);
 292                 return 1;
 293         }
 294         int hp = co->getHP();
 295         /*infostream<<"ObjectRef::l_get_hp(): id="<<co->getId()
 296                         <<" hp="<<hp<<std::endl;*/
 297         // Return
 298         lua_pushnumber(L, hp);
 299         return 1;
 300 }
 301
 302 // get_inventory(self)
 303 int ObjectRef::l_get_inventory(lua_State *L)
 304 {
 305         NO_MAP_LOCK_REQUIRED;
 306         ObjectRef *ref = checkobject(L, 1);
 307         ServerActiveObject *co = getobject(ref);
 308         if (co == NULL) return 0;
 309         // Do it
 310         InventoryLocation loc = co->getInventoryLocation();
 311         if (getServer(L)->getInventory(loc) != NULL)
 312                 InvRef::create(L, loc);
 313         else
 314                 lua_pushnil(L); // An object may have no inventory (nil)
 315         return 1;
 316 }
 317
 318 // get_wield_list(self)
 319 int ObjectRef::l_get_wield_list(lua_State *L)
 320 {
 321         NO_MAP_LOCK_REQUIRED;
 322         ObjectRef *ref = checkobject(L, 1);
 323         ServerActiveObject *co = getobject(ref);
 324         if (co == NULL) return 0;
 325         // Do it
 326         lua_pushstring(L, co->getWieldList().c_str());
 327         return 1;
 328 }
 329
 330 // get_wield_index(self)
 331 int ObjectRef::l_get_wield_index(lua_State *L)
 332 {
 333         NO_MAP_LOCK_REQUIRED;
 334         ObjectRef *ref = checkobject(L, 1);
 335         ServerActiveObject *co = getobject(ref);
 336         if (co == NULL) return 0;
 337         // Do it
 338         lua_pushinteger(L, co->getWieldIndex() + 1);
 339         return 1;
 340 }
 341
 342 // get_wielded_item(self)
 343 int ObjectRef::l_get_wielded_item(lua_State *L)
 344 {
 345         NO_MAP_LOCK_REQUIRED;
 346         ObjectRef *ref = checkobject(L, 1);
 347         ServerActiveObject *co = getobject(ref);
 348         if (co == NULL) {
 349                 // Empty ItemStack
 350                 LuaItemStack::create(L, ItemStack());
 351                 return 1;
 352         }
 353         // Do it
 354         LuaItemStack::create(L, co->getWieldedItem());
 355         return 1;
 356 }
 357
 358 // set_wielded_item(self, itemstack or itemstring or table or nil)
 359 int ObjectRef::l_set_wielded_item(lua_State *L)
 360 {
 361         NO_MAP_LOCK_REQUIRED;
 362         ObjectRef *ref = checkobject(L, 1);
 363         ServerActiveObject *co = getobject(ref);
 364         if (co == NULL) return 0;
 365         // Do it
 366         ItemStack item = read_item(L, 2, getServer(L));
 367         bool success = co->setWieldedItem(item);
 368         if (success && co->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
 369                 getServer(L)->SendInventory(((PlayerSAO*)co));
 370         }
 371         lua_pushboolean(L, success);
 372         return 1;
 373 }
 374
 375 // set_armor_groups(self, groups)
 376 int ObjectRef::l_set_armor_groups(lua_State *L)
 377 {
 378         NO_MAP_LOCK_REQUIRED;
 379         ObjectRef *ref = checkobject(L, 1);
 380         ServerActiveObject *co = getobject(ref);
 381         if (co == NULL) return 0;
 382         // Do it
 383         ItemGroupList groups;
 384         read_groups(L, 2, groups);
 385         co->setArmorGroups(groups);
 386         return 0;
 387 }
 388
 389 // get_armor_groups(self)
 390 int ObjectRef::l_get_armor_groups(lua_State *L)
 391 {
 392         NO_MAP_LOCK_REQUIRED;
 393         ObjectRef *ref = checkobject(L, 1);
 394         ServerActiveObject *co = getobject(ref);
 395         if (co == NULL)
 396                 return 0;
 397         // Do it
 398         ItemGroupList groups = co->getArmorGroups();
 399         push_groups(L, groups);
 400         return 1;
 401 }
 402
 403 // set_physics_override(self, physics_override_speed, physics_override_jump,
 404 //                      physics_override_gravity, sneak, sneak_glitch)
 405 int ObjectRef::l_set_physics_override(lua_State *L)
 406 {
 407         NO_MAP_LOCK_REQUIRED;
 408         ObjectRef *ref = checkobject(L, 1);
 409         PlayerSAO *co = (PlayerSAO *) getobject(ref);
 410         if (co == NULL) return 0;
 411         // Do it
 412         if (lua_istable(L, 2)) {
 413                 co->m_physics_override_speed = getfloatfield_default(L, 2, "speed", co->m_physics_override_speed);
 414                 co->m_physics_override_jump = getfloatfield_default(L, 2, "jump", co->m_physics_override_jump);
 415                 co->m_physics_override_gravity = getfloatfield_default(L, 2, "gravity", co->m_physics_override_gravity);
 416                 co->m_physics_override_sneak = getboolfield_default(L, 2, "sneak", co->m_physics_override_sneak);
 417                 co->m_physics_override_sneak_glitch = getboolfield_default(L, 2, "sneak_glitch", co->m_physics_override_sneak_glitch);
 418                 co->m_physics_override_sent = false;
 419         } else {
 420                 // old, non-table format
 421                 if (!lua_isnil(L, 2)) {
 422                         co->m_physics_override_speed = lua_tonumber(L, 2);
 423                         co->m_physics_override_sent = false;
 424                 }
 425                 if (!lua_isnil(L, 3)) {
 426                         co->m_physics_override_jump = lua_tonumber(L, 3);
 427                         co->m_physics_override_sent = false;
 428                 }
 429                 if (!lua_isnil(L, 4)) {
 430                         co->m_physics_override_gravity = lua_tonumber(L, 4);
 431                         co->m_physics_override_sent = false;
 432                 }
 433         }
 434         return 0;
 435 }
 436
 437 // get_physics_override(self)
 438 int ObjectRef::l_get_physics_override(lua_State *L)
 439 {
 440         NO_MAP_LOCK_REQUIRED;
 441         ObjectRef *ref = checkobject(L, 1);
 442         PlayerSAO *co = (PlayerSAO *)getobject(ref);
 443         if (co == NULL)
 444                 return 0;
 445         // Do it
 446         lua_newtable(L);
 447         lua_pushnumber(L, co->m_physics_override_speed);
 448         lua_setfield(L, -2, "speed");
 449         lua_pushnumber(L, co->m_physics_override_jump);
 450         lua_setfield(L, -2, "jump");
 451         lua_pushnumber(L, co->m_physics_override_gravity);
 452         lua_setfield(L, -2, "gravity");
 453         lua_pushboolean(L, co->m_physics_override_sneak);
 454         lua_setfield(L, -2, "sneak");
 455         lua_pushboolean(L, co->m_physics_override_sneak_glitch);
 456         lua_setfield(L, -2, "sneak_glitch");
 457         return 1;
 458 }
 459
 460 // set_animation(self, frame_range, frame_speed, frame_blend, frame_loop)
 461 int ObjectRef::l_set_animation(lua_State *L)
 462 {
 463         NO_MAP_LOCK_REQUIRED;
 464         ObjectRef *ref = checkobject(L, 1);
 465         ServerActiveObject *co = getobject(ref);
 466         if (co == NULL) return 0;
 467         // Do it
 468         v2f frames = v2f(1, 1);
 469         if (!lua_isnil(L, 2))
 470                 frames = read_v2f(L, 2);
 471         float frame_speed = 15;
 472         if (!lua_isnil(L, 3))
 473                 frame_speed = lua_tonumber(L, 3);
 474         float frame_blend = 0;
 475         if (!lua_isnil(L, 4))
 476                 frame_blend = lua_tonumber(L, 4);
 477         bool frame_loop = true;
 478         if (lua_isboolean(L, 5))
 479                 frame_loop = lua_toboolean(L, 5);
 480         co->setAnimation(frames, frame_speed, frame_blend, frame_loop);
 481         return 0;
 482 }
 483
 484 // get_animation(self)
 485 int ObjectRef::l_get_animation(lua_State *L)
 486 {
 487         NO_MAP_LOCK_REQUIRED;
 488         ObjectRef *ref = checkobject(L, 1);
 489         ServerActiveObject *co = getobject(ref);
 490         if (co == NULL)
 491                 return 0;
 492         // Do it
 493         v2f frames = v2f(1,1);
 494         float frame_speed = 15;
 495         float frame_blend = 0;
 496         bool frame_loop = true;
 497         co->getAnimation(&frames, &frame_speed, &frame_blend, &frame_loop);
 498
 499         push_v2f(L, frames);
 500         lua_pushnumber(L, frame_speed);
 501         lua_pushnumber(L, frame_blend);
 502         lua_pushboolean(L, frame_loop);
 503         return 4;
 504 }
 505
 506 // set_local_animation(self, {stand/idle}, {walk}, {dig}, {walk+dig}, frame_speed)
 507 int ObjectRef::l_set_local_animation(lua_State *L)
 508 {
 509         NO_MAP_LOCK_REQUIRED;
 510         ObjectRef *ref = checkobject(L, 1);
 511         Player *player = getplayer(ref);
 512         if (player == NULL)
 513                 return 0;
 514         // Do it
 515         v2s32 frames[4];
 516         for (int i=0;i<4;i++) {
 517                 if (!lua_isnil(L, 2+1))
 518                         frames[i] = read_v2s32(L, 2+i);
 519         }
 520         float frame_speed = 30;
 521         if (!lua_isnil(L, 6))
 522                 frame_speed = lua_tonumber(L, 6);
 523
 524         if (!getServer(L)->setLocalPlayerAnimations(player, frames, frame_speed))
 525                 return 0;
 526
 527         lua_pushboolean(L, true);
 528         return 0;
 529 }
 530
 531 // get_local_animation(self)
 532 int ObjectRef::l_get_local_animation(lua_State *L)
 533 {
 534         NO_MAP_LOCK_REQUIRED
 535         ObjectRef *ref = checkobject(L, 1);
 536         Player *player = getplayer(ref);
 537         if (player == NULL)
 538                 return 0;
 539
 540         v2s32 frames[4];
 541         float frame_speed;
 542         player->getLocalAnimations(frames, &frame_speed);
 543
 544         for (int i = 0; i < 4; i++) {
 545                 push_v2s32(L, frames[i]);
 546         }
 547
 548         lua_pushnumber(L, frame_speed);
 549         return 5;
 550 }
 551
 552 // set_eye_offset(self, v3f first pv, v3f third pv)
 553 int ObjectRef::l_set_eye_offset(lua_State *L)
 554 {
 555         NO_MAP_LOCK_REQUIRED;
 556         ObjectRef *ref = checkobject(L, 1);
 557         Player *player = getplayer(ref);
 558         if (player == NULL)
 559                 return 0;
 560         // Do it
 561         v3f offset_first = v3f(0, 0, 0);
 562         v3f offset_third = v3f(0, 0, 0);
 563
 564         if (!lua_isnil(L, 2))
 565                 offset_first = read_v3f(L, 2);
 566         if (!lua_isnil(L, 3))
 567                 offset_third = read_v3f(L, 3);
 568
 569         // Prevent abuse of offset values (keep player always visible)
 570         offset_third.X = rangelim(offset_third.X,-10,10);
 571         offset_third.Z = rangelim(offset_third.Z,-5,5);
 572         /* TODO: if possible: improve the camera colision detetion to allow Y <= -1.5) */
 573         offset_third.Y = rangelim(offset_third.Y,-10,15); //1.5*BS
 574
 575         if (!getServer(L)->setPlayerEyeOffset(player, offset_first, offset_third))
 576                 return 0;
 577
 578         lua_pushboolean(L, true);
 579         return 0;
 580 }
 581
 582 // get_eye_offset(self)
 583 int ObjectRef::l_get_eye_offset(lua_State *L)
 584 {
 585         NO_MAP_LOCK_REQUIRED;
 586         ObjectRef *ref = checkobject(L, 1);
 587         Player *player = getplayer(ref);
 588         if (player == NULL)
 589                 return 0;
 590         // Do it
 591         push_v3f(L, player->eye_offset_first);
 592         push_v3f(L, player->eye_offset_third);
 593         return 2;
 594 }
 595
 596 // set_bone_position(self, std::string bone, v3f position, v3f rotation)
 597 int ObjectRef::l_set_bone_position(lua_State *L)
 598 {
 599         NO_MAP_LOCK_REQUIRED;
 600         ObjectRef *ref = checkobject(L, 1);
 601         ServerActiveObject *co = getobject(ref);
 602         if (co == NULL) return 0;
 603         // Do it
 604         std::string bone = "";
 605         if (!lua_isnil(L, 2))
 606                 bone = lua_tostring(L, 2);
 607         v3f position = v3f(0, 0, 0);
 608         if (!lua_isnil(L, 3))
 609                 position = read_v3f(L, 3);
 610         v3f rotation = v3f(0, 0, 0);
 611         if (!lua_isnil(L, 4))
 612                 rotation = read_v3f(L, 4);
 613         co->setBonePosition(bone, position, rotation);
 614         return 0;
 615 }
 616
 617 // get_bone_position(self, bone)
 618 int ObjectRef::l_get_bone_position(lua_State *L)
 619 {
 620         NO_MAP_LOCK_REQUIRED;
 621         ObjectRef *ref = checkobject(L, 1);
 622         ServerActiveObject *co = getobject(ref);
 623         if (co == NULL)
 624                 return 0;
 625         // Do it
 626         std::string bone = "";
 627         if (!lua_isnil(L, 2))
 628                 bone = lua_tostring(L, 2);
 629
 630         v3f position = v3f(0, 0, 0);
 631         v3f rotation = v3f(0, 0, 0);
 632         co->getBonePosition(bone, &position, &rotation);
 633
 634         push_v3f(L, position);
 635         push_v3f(L, rotation);
 636         return 2;
 637 }
 638
 639 // set_attach(self, parent, bone, position, rotation)
 640 int ObjectRef::l_set_attach(lua_State *L)
 641 {
 642         GET_ENV_PTR;
 643
 644         ObjectRef *ref = checkobject(L, 1);
 645         ObjectRef *parent_ref = checkobject(L, 2);
 646         ServerActiveObject *co = getobject(ref);
 647         ServerActiveObject *parent = getobject(parent_ref);
 648         if (co == NULL)
 649                 return 0;
 650         if (parent == NULL)
 651                 return 0;
 652         // Do it
 653         int parent_id = 0;
 654         std::string bone = "";
 655         v3f position = v3f(0, 0, 0);
 656         v3f rotation = v3f(0, 0, 0);
 657         co->getAttachment(&parent_id, &bone, &position, &rotation);
 658         if (parent_id) {
 659                 ServerActiveObject *old_parent = env->getActiveObject(parent_id);
 660                 old_parent->removeAttachmentChild(co->getId());
 661         }
 662
 663         bone = "";
 664         if (!lua_isnil(L, 3))
 665                 bone = lua_tostring(L, 3);
 666         position = v3f(0, 0, 0);
 667         if (!lua_isnil(L, 4))
 668                 position = read_v3f(L, 4);
 669         rotation = v3f(0, 0, 0);
 670         if (!lua_isnil(L, 5))
 671                 rotation = read_v3f(L, 5);
 672         co->setAttachment(parent->getId(), bone, position, rotation);
 673         parent->addAttachmentChild(co->getId());
 674         return 0;
 675 }
 676
 677 // get_attach(self)
 678 int ObjectRef::l_get_attach(lua_State *L)
 679 {
 680         GET_ENV_PTR;
 681
 682         ObjectRef *ref = checkobject(L, 1);
 683         ServerActiveObject *co = getobject(ref);
 684         if (co == NULL)
 685                 return 0;
 686
 687         // Do it
 688         int parent_id = 0;
 689         std::string bone = "";
 690         v3f position = v3f(0, 0, 0);
 691         v3f rotation = v3f(0, 0, 0);
 692         co->getAttachment(&parent_id, &bone, &position, &rotation);
 693         if (!parent_id)
 694                 return 0;
 695         ServerActiveObject *parent = env->getActiveObject(parent_id);
 696
 697         getScriptApiBase(L)->objectrefGetOrCreate(L, parent);
 698         lua_pushlstring(L, bone.c_str(), bone.size());
 699         push_v3f(L, position);
 700         push_v3f(L, rotation);
 701         return 4;
 702 }
 703
 704 // set_detach(self)
 705 int ObjectRef::l_set_detach(lua_State *L)
 706 {
 707         GET_ENV_PTR;
 708
 709         ObjectRef *ref = checkobject(L, 1);
 710         ServerActiveObject *co = getobject(ref);
 711         if (co == NULL)
 712                 return 0;
 713
 714         int parent_id = 0;
 715         std::string bone = "";
 716         v3f position;
 717         v3f rotation;
 718         co->getAttachment(&parent_id, &bone, &position, &rotation);
 719         ServerActiveObject *parent = NULL;
 720         if (parent_id)
 721                 parent = env->getActiveObject(parent_id);
 722
 723         // Do it
 724         co->setAttachment(0, "", v3f(0,0,0), v3f(0,0,0));
 725         if (parent != NULL)
 726                 parent->removeAttachmentChild(co->getId());
 727         return 0;
 728 }
 729
 730 // set_properties(self, properties)
 731 int ObjectRef::l_set_properties(lua_State *L)
 732 {
 733         NO_MAP_LOCK_REQUIRED;
 734         ObjectRef *ref = checkobject(L, 1);
 735         ServerActiveObject *co = getobject(ref);
 736         if (co == NULL) return 0;
 737         ObjectProperties *prop = co->accessObjectProperties();
 738         if (!prop)
 739                 return 0;
 740         read_object_properties(L, 2, prop);
 741         co->notifyObjectPropertiesModified();
 742         return 0;
 743 }
 744
 745 // get_properties(self)
 746 int ObjectRef::l_get_properties(lua_State *L)
 747 {
 748         NO_MAP_LOCK_REQUIRED;
 749         ObjectRef *ref = checkobject(L, 1);
 750         ServerActiveObject *co = getobject(ref);
 751         if (co == NULL)
 752                 return 0;
 753         ObjectProperties *prop = co->accessObjectProperties();
 754         if (!prop)
 755                 return 0;
 756         push_object_properties(L, prop);
 757         return 1;
 758 }
 759
 760 // is_player(self)
 761 int ObjectRef::l_is_player(lua_State *L)
 762 {
 763         NO_MAP_LOCK_REQUIRED;
 764         ObjectRef *ref = checkobject(L, 1);
 765         Player *player = getplayer(ref);
 766         lua_pushboolean(L, (player != NULL));
 767         return 1;
 768 }
 769
 770 // set_nametag_attributes(self, attributes)
 771 int ObjectRef::l_set_nametag_attributes(lua_State *L)
 772 {
 773         NO_MAP_LOCK_REQUIRED;
 774         ObjectRef *ref = checkobject(L, 1);
 775         ServerActiveObject *co = getobject(ref);
 776
 777         if (co == NULL)
 778                 return 0;
 779         ObjectProperties *prop = co->accessObjectProperties();
 780         if (!prop)
 781                 return 0;
 782
 783         lua_getfield(L, 2, "color");
 784         if (!lua_isnil(L, -1)) {
 785                 video::SColor color = prop->nametag_color;
 786                 read_color(L, -1, &color);
 787                 prop->nametag_color = color;
 788         }
 789         lua_pop(L, 1);
 790
 791         std::string nametag = getstringfield_default(L, 2, "text", "");
 792         if (nametag != "")
 793                 prop->nametag = nametag;
 794
 795         co->notifyObjectPropertiesModified();
 796         lua_pushboolean(L, true);
 797         return 1;
 798 }
 799
 800 // get_nametag_attributes(self)
 801 int ObjectRef::l_get_nametag_attributes(lua_State *L)
 802 {
 803         NO_MAP_LOCK_REQUIRED;
 804         ObjectRef *ref = checkobject(L, 1);
 805         ServerActiveObject *co = getobject(ref);
 806
 807         if (co == NULL)
 808                 return 0;
 809         ObjectProperties *prop = co->accessObjectProperties();
 810         if (!prop)
 811                 return 0;
 812
 813         video::SColor color = prop->nametag_color;
 814
 815         lua_newtable(L);
 816         push_ARGB8(L, color);
 817         lua_setfield(L, -2, "color");
 818         lua_pushstring(L, prop->nametag.c_str());
 819         lua_setfield(L, -2, "text");
 820         return 1;
 821 }
 822
 823 /* LuaEntitySAO-only */
 824
 825 // setvelocity(self, {x=num, y=num, z=num})
 826 int ObjectRef::l_setvelocity(lua_State *L)
 827 {
 828         NO_MAP_LOCK_REQUIRED;
 829         ObjectRef *ref = checkobject(L, 1);
 830         LuaEntitySAO *co = getluaobject(ref);
 831         if (co == NULL) return 0;
 832         v3f pos = checkFloatPos(L, 2);
 833         // Do it
 834         co->setVelocity(pos);
 835         return 0;
 836 }
 837
 838 // getvelocity(self)
 839 int ObjectRef::l_getvelocity(lua_State *L)
 840 {
 841         NO_MAP_LOCK_REQUIRED;
 842         ObjectRef *ref = checkobject(L, 1);
 843         LuaEntitySAO *co = getluaobject(ref);
 844         if (co == NULL) return 0;
 845         // Do it
 846         v3f v = co->getVelocity();
 847         pushFloatPos(L, v);
 848         return 1;
 849 }
 850
 851 // setacceleration(self, {x=num, y=num, z=num})
 852 int ObjectRef::l_setacceleration(lua_State *L)
 853 {
 854         NO_MAP_LOCK_REQUIRED;
 855         ObjectRef *ref = checkobject(L, 1);
 856         LuaEntitySAO *co = getluaobject(ref);
 857         if (co == NULL) return 0;
 858         // pos
 859         v3f pos = checkFloatPos(L, 2);
 860         // Do it
 861         co->setAcceleration(pos);
 862         return 0;
 863 }
 864
 865 // getacceleration(self)
 866 int ObjectRef::l_getacceleration(lua_State *L)
 867 {
 868         NO_MAP_LOCK_REQUIRED;
 869         ObjectRef *ref = checkobject(L, 1);
 870         LuaEntitySAO *co = getluaobject(ref);
 871         if (co == NULL) return 0;
 872         // Do it
 873         v3f v = co->getAcceleration();
 874         pushFloatPos(L, v);
 875         return 1;
 876 }
 877
 878 // setyaw(self, radians)
 879 int ObjectRef::l_setyaw(lua_State *L)
 880 {
 881         NO_MAP_LOCK_REQUIRED;
 882         ObjectRef *ref = checkobject(L, 1);
 883         LuaEntitySAO *co = getluaobject(ref);
 884         if (co == NULL) return 0;
 885         float yaw = luaL_checknumber(L, 2) * core::RADTODEG;
 886         // Do it
 887         co->setYaw(yaw);
 888         return 0;
 889 }
 890
 891 // getyaw(self)
 892 int ObjectRef::l_getyaw(lua_State *L)
 893 {
 894         NO_MAP_LOCK_REQUIRED;
 895         ObjectRef *ref = checkobject(L, 1);
 896         LuaEntitySAO *co = getluaobject(ref);
 897         if (co == NULL) return 0;
 898         // Do it
 899         float yaw = co->getYaw() * core::DEGTORAD;
 900         lua_pushnumber(L, yaw);
 901         return 1;
 902 }
 903
 904 // settexturemod(self, mod)
 905 int ObjectRef::l_settexturemod(lua_State *L)
 906 {
 907         NO_MAP_LOCK_REQUIRED;
 908         ObjectRef *ref = checkobject(L, 1);
 909         LuaEntitySAO *co = getluaobject(ref);
 910         if (co == NULL) return 0;
 911         // Do it
 912         std::string mod = luaL_checkstring(L, 2);
 913         co->setTextureMod(mod);
 914         return 0;
 915 }
 916
 917 // setsprite(self, p={x=0,y=0}, num_frames=1, framelength=0.2,
 918 //           select_horiz_by_yawpitch=false)
 919 int ObjectRef::l_setsprite(lua_State *L)
 920 {
 921         NO_MAP_LOCK_REQUIRED;
 922         ObjectRef *ref = checkobject(L, 1);
 923         LuaEntitySAO *co = getluaobject(ref);
 924         if (co == NULL) return 0;
 925         // Do it
 926         v2s16 p(0,0);
 927         if (!lua_isnil(L, 2))
 928                 p = read_v2s16(L, 2);
 929         int num_frames = 1;
 930         if (!lua_isnil(L, 3))
 931                 num_frames = lua_tonumber(L, 3);
 932         float framelength = 0.2;
 933         if (!lua_isnil(L, 4))
 934                 framelength = lua_tonumber(L, 4);
 935         bool select_horiz_by_yawpitch = false;
 936         if (!lua_isnil(L, 5))
 937                 select_horiz_by_yawpitch = lua_toboolean(L, 5);
 938         co->setSprite(p, num_frames, framelength, select_horiz_by_yawpitch);
 939         return 0;
 940 }
 941
 942 // DEPRECATED
 943 // get_entity_name(self)
 944 int ObjectRef::l_get_entity_name(lua_State *L)
 945 {
 946         NO_MAP_LOCK_REQUIRED;
 947         ObjectRef *ref = checkobject(L, 1);
 948         LuaEntitySAO *co = getluaobject(ref);
 949         log_deprecated(L,"Deprecated call to \"get_entity_name");
 950         if (co == NULL) return 0;
 951         // Do it
 952         std::string name = co->getName();
 953         lua_pushstring(L, name.c_str());
 954         return 1;
 955 }
 956
 957 // get_luaentity(self)
 958 int ObjectRef::l_get_luaentity(lua_State *L)
 959 {
 960         NO_MAP_LOCK_REQUIRED;
 961         ObjectRef *ref = checkobject(L, 1);
 962         LuaEntitySAO *co = getluaobject(ref);
 963         if (co == NULL) return 0;
 964         // Do it
 965         luaentity_get(L, co->getId());
 966         return 1;
 967 }
 968
 969 /* Player-only */
 970
 971 // is_player_connected(self)
 972 int ObjectRef::l_is_player_connected(lua_State *L)
 973 {
 974         NO_MAP_LOCK_REQUIRED;
 975         ObjectRef *ref = checkobject(L, 1);
 976         Player *player = getplayer(ref);
 977         lua_pushboolean(L, (player != NULL && player->peer_id != 0));
 978         return 1;
 979 }
 980
 981 // get_player_name(self)
 982 int ObjectRef::l_get_player_name(lua_State *L)
 983 {
 984         NO_MAP_LOCK_REQUIRED;
 985         ObjectRef *ref = checkobject(L, 1);
 986         Player *player = getplayer(ref);
 987         if (player == NULL) {
 988                 lua_pushlstring(L, "", 0);
 989                 return 1;
 990         }
 991         // Do it
 992         lua_pushstring(L, player->getName());
 993         return 1;
 994 }
 995
 996 // get_player_velocity(self)
 997 int ObjectRef::l_get_player_velocity(lua_State *L)
 998 {
 999         NO_MAP_LOCK_REQUIRED;
1000         ObjectRef *ref = checkobject(L, 1);
1001         Player *player = getplayer(ref);
1002         if (player == NULL) {
1003                 lua_pushnil(L);
1004                 return 1;
1005         }
1006         // Do it
1007         push_v3f(L, player->getSpeed() / BS);
1008         return 1;
1009 }
1010
1011 // get_look_dir(self)
1012 int ObjectRef::l_get_look_dir(lua_State *L)
1013 {
1014         NO_MAP_LOCK_REQUIRED;
1015         ObjectRef *ref = checkobject(L, 1);
1016         Player *player = getplayer(ref);
1017         if (player == NULL) return 0;
1018         // Do it
1019         float pitch = player->getRadPitch();
1020         float yaw = player->getRadYaw();
1021         v3f v(cos(pitch)*cos(yaw), sin(pitch), cos(pitch)*sin(yaw));
1022         push_v3f(L, v);
1023         return 1;
1024 }
1025
1026 // get_look_pitch(self)
1027 int ObjectRef::l_get_look_pitch(lua_State *L)
1028 {
1029         NO_MAP_LOCK_REQUIRED;
1030         ObjectRef *ref = checkobject(L, 1);
1031         Player *player = getplayer(ref);
1032         if (player == NULL) return 0;
1033         // Do it
1034         lua_pushnumber(L, player->getRadPitch());
1035         return 1;
1036 }
1037
1038 // get_look_yaw(self)
1039 int ObjectRef::l_get_look_yaw(lua_State *L)
1040 {
1041         NO_MAP_LOCK_REQUIRED;
1042         ObjectRef *ref = checkobject(L, 1);
1043         Player *player = getplayer(ref);
1044         if (player == NULL) return 0;
1045         // Do it
1046         lua_pushnumber(L, player->getRadYaw());
1047         return 1;
1048 }
1049
1050 // set_look_pitch(self, radians)
1051 int ObjectRef::l_set_look_pitch(lua_State *L)
1052 {
1053         NO_MAP_LOCK_REQUIRED;
1054         ObjectRef *ref = checkobject(L, 1);
1055         PlayerSAO* co = getplayersao(ref);
1056         if (co == NULL) return 0;
1057         float pitch = luaL_checknumber(L, 2) * core::RADTODEG;
1058         // Do it
1059         co->setPitch(pitch);
1060         return 1;
1061 }
1062
1063 // set_look_yaw(self, radians)
1064 int ObjectRef::l_set_look_yaw(lua_State *L)
1065 {
1066         NO_MAP_LOCK_REQUIRED;
1067         ObjectRef *ref = checkobject(L, 1);
1068         PlayerSAO* co = getplayersao(ref);
1069         if (co == NULL) return 0;
1070         float yaw = luaL_checknumber(L, 2) * core::RADTODEG;
1071         // Do it
1072         co->setYaw(yaw);
1073         return 1;
1074 }
1075
1076 // set_breath(self, breath)
1077 int ObjectRef::l_set_breath(lua_State *L)
1078 {
1079         NO_MAP_LOCK_REQUIRED;
1080         ObjectRef *ref = checkobject(L, 1);
1081         PlayerSAO* co = getplayersao(ref);
1082         if (co == NULL) return 0;
1083         u16 breath = luaL_checknumber(L, 2);
1084         // Do it
1085         co->setBreath(breath);
1086
1087         // If the object is a player sent the breath to client
1088         if (co->getType() == ACTIVEOBJECT_TYPE_PLAYER)
1089                         getServer(L)->SendPlayerBreath(((PlayerSAO*)co)->getPeerID());
1090
1091         return 0;
1092 }
1093
1094 // get_breath(self)
1095 int ObjectRef::l_get_breath(lua_State *L)
1096 {
1097         NO_MAP_LOCK_REQUIRED;
1098         ObjectRef *ref = checkobject(L, 1);
1099         PlayerSAO* co = getplayersao(ref);
1100         if (co == NULL) return 0;
1101         // Do it
1102         u16 breath = co->getBreath();
1103         lua_pushinteger (L, breath);
1104         return 1;
1105 }
1106
1107 // set_inventory_formspec(self, formspec)
1108 int ObjectRef::l_set_inventory_formspec(lua_State *L)
1109 {
1110         NO_MAP_LOCK_REQUIRED;
1111         ObjectRef *ref = checkobject(L, 1);
1112         Player *player = getplayer(ref);
1113         if (player == NULL) return 0;
1114         std::string formspec = luaL_checkstring(L, 2);
1115
1116         player->inventory_formspec = formspec;
1117         getServer(L)->reportInventoryFormspecModified(player->getName());
1118         lua_pushboolean(L, true);
1119         return 1;
1120 }
1121
1122 // get_inventory_formspec(self) -> formspec
1123 int ObjectRef::l_get_inventory_formspec(lua_State *L)
1124 {
1125         NO_MAP_LOCK_REQUIRED;
1126         ObjectRef *ref = checkobject(L, 1);
1127         Player *player = getplayer(ref);
1128         if (player == NULL) return 0;
1129
1130         std::string formspec = player->inventory_formspec;
1131         lua_pushlstring(L, formspec.c_str(), formspec.size());
1132         return 1;
1133 }
1134
1135 // get_player_control(self)
1136 int ObjectRef::l_get_player_control(lua_State *L)
1137 {
1138         NO_MAP_LOCK_REQUIRED;
1139         ObjectRef *ref = checkobject(L, 1);
1140         Player *player = getplayer(ref);
1141         if (player == NULL) {
1142                 lua_pushlstring(L, "", 0);
1143                 return 1;
1144         }
1145         // Do it
1146         PlayerControl control = player->getPlayerControl();
1147         lua_newtable(L);
1148         lua_pushboolean(L, control.up);
1149         lua_setfield(L, -2, "up");
1150         lua_pushboolean(L, control.down);
1151         lua_setfield(L, -2, "down");
1152         lua_pushboolean(L, control.left);
1153         lua_setfield(L, -2, "left");
1154         lua_pushboolean(L, control.right);
1155         lua_setfield(L, -2, "right");
1156         lua_pushboolean(L, control.jump);
1157         lua_setfield(L, -2, "jump");
1158         lua_pushboolean(L, control.aux1);
1159         lua_setfield(L, -2, "aux1");
1160         lua_pushboolean(L, control.sneak);
1161         lua_setfield(L, -2, "sneak");
1162         lua_pushboolean(L, control.LMB);
1163         lua_setfield(L, -2, "LMB");
1164         lua_pushboolean(L, control.RMB);
1165         lua_setfield(L, -2, "RMB");
1166         return 1;
1167 }
1168
1169 // get_player_control_bits(self)
1170 int ObjectRef::l_get_player_control_bits(lua_State *L)
1171 {
1172         NO_MAP_LOCK_REQUIRED;
1173         ObjectRef *ref = checkobject(L, 1);
1174         Player *player = getplayer(ref);
1175         if (player == NULL) {
1176                 lua_pushlstring(L, "", 0);
1177                 return 1;
1178         }
1179         // Do it
1180         lua_pushnumber(L, player->keyPressed);
1181         return 1;
1182 }
1183
1184 // hud_add(self, form)
1185 int ObjectRef::l_hud_add(lua_State *L)
1186 {
1187         NO_MAP_LOCK_REQUIRED;
1188         ObjectRef *ref = checkobject(L, 1);
1189         Player *player = getplayer(ref);
1190         if (player == NULL)
1191                 return 0;
1192
1193         HudElement *elem = new HudElement;
1194
1195         elem->type = (HudElementType)getenumfield(L, 2, "hud_elem_type",
1196                                                                 es_HudElementType, HUD_ELEM_TEXT);
1197
1198         lua_getfield(L, 2, "position");
1199         elem->pos = lua_istable(L, -1) ? read_v2f(L, -1) : v2f();
1200         lua_pop(L, 1);
1201
1202         lua_getfield(L, 2, "scale");
1203         elem->scale = lua_istable(L, -1) ? read_v2f(L, -1) : v2f();
1204         lua_pop(L, 1);
1205
1206         lua_getfield(L, 2, "size");
1207         elem->size = lua_istable(L, -1) ? read_v2s32(L, -1) : v2s32();
1208         lua_pop(L, 1);
1209
1210         elem->name   = getstringfield_default(L, 2, "name", "");
1211         elem->text   = getstringfield_default(L, 2, "text", "");
1212         elem->number = getintfield_default(L, 2, "number", 0);
1213         elem->item   = getintfield_default(L, 2, "item", 0);
1214         elem->dir    = getintfield_default(L, 2, "direction", 0);
1215
1216         // Deprecated, only for compatibility's sake
1217         if (elem->dir == 0)
1218                 elem->dir = getintfield_default(L, 2, "dir", 0);
1219
1220         lua_getfield(L, 2, "alignment");
1221         elem->align = lua_istable(L, -1) ? read_v2f(L, -1) : v2f();
1222         lua_pop(L, 1);
1223
1224         lua_getfield(L, 2, "offset");
1225         elem->offset = lua_istable(L, -1) ? read_v2f(L, -1) : v2f();
1226         lua_pop(L, 1);
1227
1228         lua_getfield(L, 2, "world_pos");
1229         elem->world_pos = lua_istable(L, -1) ? read_v3f(L, -1) : v3f();
1230         lua_pop(L, 1);
1231
1232         /* check for known deprecated element usage */
1233         if ((elem->type  == HUD_ELEM_STATBAR) && (elem->size == v2s32())) {
1234                 log_deprecated(L,"Deprecated usage of statbar without size!");
1235         }
1236
1237         u32 id = getServer(L)->hudAdd(player, elem);
1238         if (id == U32_MAX) {
1239                 delete elem;
1240                 return 0;
1241         }
1242
1243         lua_pushnumber(L, id);
1244         return 1;
1245 }
1246
1247 // hud_remove(self, id)
1248 int ObjectRef::l_hud_remove(lua_State *L)
1249 {
1250         NO_MAP_LOCK_REQUIRED;
1251         ObjectRef *ref = checkobject(L, 1);
1252         Player *player = getplayer(ref);
1253         if (player == NULL)
1254                 return 0;
1255
1256         u32 id = -1;
1257         if (!lua_isnil(L, 2))
1258                 id = lua_tonumber(L, 2);
1259
1260         if (!getServer(L)->hudRemove(player, id))
1261                 return 0;
1262
1263         lua_pushboolean(L, true);
1264         return 1;
1265 }
1266
1267 // hud_change(self, id, stat, data)
1268 int ObjectRef::l_hud_change(lua_State *L)
1269 {
1270         NO_MAP_LOCK_REQUIRED;
1271         ObjectRef *ref = checkobject(L, 1);
1272         Player *player = getplayer(ref);
1273         if (player == NULL)
1274                 return 0;
1275
1276         u32 id = lua_isnumber(L, 2) ? lua_tonumber(L, 2) : -1;
1277
1278         HudElement *e = player->getHud(id);
1279         if (!e)
1280                 return 0;
1281
1282         HudElementStat stat = HUD_STAT_NUMBER;
1283         if (lua_isstring(L, 3)) {
1284                 int statint;
1285                 std::string statstr = lua_tostring(L, 3);
1286                 stat = string_to_enum(es_HudElementStat, statint, statstr) ?
1287                                 (HudElementStat)statint : HUD_STAT_NUMBER;
1288         }
1289
1290         void *value = NULL;
1291         switch (stat) {
1292                 case HUD_STAT_POS:
1293                         e->pos = read_v2f(L, 4);
1294                         value = &e->pos;
1295                         break;
1296                 case HUD_STAT_NAME:
1297                         e->name = luaL_checkstring(L, 4);
1298                         value = &e->name;
1299                         break;
1300                 case HUD_STAT_SCALE:
1301                         e->scale = read_v2f(L, 4);
1302                         value = &e->scale;
1303                         break;
1304                 case HUD_STAT_TEXT:
1305                         e->text = luaL_checkstring(L, 4);
1306                         value = &e->text;
1307                         break;
1308                 case HUD_STAT_NUMBER:
1309                         e->number = luaL_checknumber(L, 4);
1310                         value = &e->number;
1311                         break;
1312                 case HUD_STAT_ITEM:
1313                         e->item = luaL_checknumber(L, 4);
1314                         value = &e->item;
1315                         break;
1316                 case HUD_STAT_DIR:
1317                         e->dir = luaL_checknumber(L, 4);
1318                         value = &e->dir;
1319                         break;
1320                 case HUD_STAT_ALIGN:
1321                         e->align = read_v2f(L, 4);
1322                         value = &e->align;
1323                         break;
1324                 case HUD_STAT_OFFSET:
1325                         e->offset = read_v2f(L, 4);
1326                         value = &e->offset;
1327                         break;
1328                 case HUD_STAT_WORLD_POS:
1329                         e->world_pos = read_v3f(L, 4);
1330                         value = &e->world_pos;
1331                         break;
1332                 case HUD_STAT_SIZE:
1333                         e->size = read_v2s32(L, 4);
1334                         value = &e->size;
1335                         break;
1336         }
1337
1338         getServer(L)->hudChange(player, id, stat, value);
1339
1340         lua_pushboolean(L, true);
1341         return 1;
1342 }
1343
1344 // hud_get(self, id)
1345 int ObjectRef::l_hud_get(lua_State *L)
1346 {
1347         NO_MAP_LOCK_REQUIRED;
1348         ObjectRef *ref = checkobject(L, 1);
1349         Player *player = getplayer(ref);
1350         if (player == NULL)
1351                 return 0;
1352
1353         u32 id = lua_tonumber(L, -1);
1354
1355         HudElement *e = player->getHud(id);
1356         if (!e)
1357                 return 0;
1358
1359         lua_newtable(L);
1360
1361         lua_pushstring(L, es_HudElementType[(u8)e->type].str);
1362         lua_setfield(L, -2, "type");
1363
1364         push_v2f(L, e->pos);
1365         lua_setfield(L, -2, "position");
1366
1367         lua_pushstring(L, e->name.c_str());
1368         lua_setfield(L, -2, "name");
1369
1370         push_v2f(L, e->scale);
1371         lua_setfield(L, -2, "scale");
1372
1373         lua_pushstring(L, e->text.c_str());
1374         lua_setfield(L, -2, "text");
1375
1376         lua_pushnumber(L, e->number);
1377         lua_setfield(L, -2, "number");
1378
1379         lua_pushnumber(L, e->item);
1380         lua_setfield(L, -2, "item");
1381
1382         lua_pushnumber(L, e->dir);
1383         lua_setfield(L, -2, "direction");
1384
1385         // Deprecated, only for compatibility's sake
1386         lua_pushnumber(L, e->dir);
1387         lua_setfield(L, -2, "dir");
1388
1389         push_v3f(L, e->world_pos);
1390         lua_setfield(L, -2, "world_pos");
1391
1392         return 1;
1393 }
1394
1395 // hud_set_flags(self, flags)
1396 int ObjectRef::l_hud_set_flags(lua_State *L)
1397 {
1398         NO_MAP_LOCK_REQUIRED;
1399         ObjectRef *ref = checkobject(L, 1);
1400         Player *player = getplayer(ref);
1401         if (player == NULL)
1402                 return 0;
1403
1404         u32 flags = 0;
1405         u32 mask  = 0;
1406         bool flag;
1407
1408         const EnumString *esp = es_HudBuiltinElement;
1409         for (int i = 0; esp[i].str; i++) {
1410                 if (getboolfield(L, 2, esp[i].str, flag)) {
1411                         flags |= esp[i].num * flag;
1412                         mask  |= esp[i].num;
1413                 }
1414         }
1415         if (!getServer(L)->hudSetFlags(player, flags, mask))
1416                 return 0;
1417
1418         lua_pushboolean(L, true);
1419         return 1;
1420 }
1421
1422 int ObjectRef::l_hud_get_flags(lua_State *L)
1423 {
1424         NO_MAP_LOCK_REQUIRED;
1425         ObjectRef *ref = checkobject(L, 1);
1426         Player *player = getplayer(ref);
1427         if (player == NULL)
1428                 return 0;
1429
1430         lua_newtable(L);
1431         lua_pushboolean(L, player->hud_flags & HUD_FLAG_HOTBAR_VISIBLE);
1432         lua_setfield(L, -2, "hotbar");
1433         lua_pushboolean(L, player->hud_flags & HUD_FLAG_HEALTHBAR_VISIBLE);
1434         lua_setfield(L, -2, "healthbar");
1435         lua_pushboolean(L, player->hud_flags & HUD_FLAG_CROSSHAIR_VISIBLE);
1436         lua_setfield(L, -2, "crosshair");
1437         lua_pushboolean(L, player->hud_flags & HUD_FLAG_WIELDITEM_VISIBLE);
1438         lua_setfield(L, -2, "wielditem");
1439         lua_pushboolean(L, player->hud_flags & HUD_FLAG_BREATHBAR_VISIBLE);
1440         lua_setfield(L, -2, "breathbar");
1441         lua_pushboolean(L, player->hud_flags & HUD_FLAG_MINIMAP_VISIBLE);
1442         lua_setfield(L, -2, "minimap");
1443
1444         return 1;
1445 }
1446
1447 // hud_set_hotbar_itemcount(self, hotbar_itemcount)
1448 int ObjectRef::l_hud_set_hotbar_itemcount(lua_State *L)
1449 {
1450         NO_MAP_LOCK_REQUIRED;
1451         ObjectRef *ref = checkobject(L, 1);
1452         Player *player = getplayer(ref);
1453         if (player == NULL)
1454                 return 0;
1455
1456         s32 hotbar_itemcount = lua_tonumber(L, 2);
1457
1458         if (!getServer(L)->hudSetHotbarItemcount(player, hotbar_itemcount))
1459                 return 0;
1460
1461         lua_pushboolean(L, true);
1462         return 1;
1463 }
1464
1465 // hud_get_hotbar_itemcount(self)
1466 int ObjectRef::l_hud_get_hotbar_itemcount(lua_State *L)
1467 {
1468         NO_MAP_LOCK_REQUIRED;
1469         ObjectRef *ref = checkobject(L, 1);
1470         Player *player = getplayer(ref);
1471         if (player == NULL)
1472                 return 0;
1473
1474         s32 hotbar_itemcount = getServer(L)->hudGetHotbarItemcount(player);
1475
1476         lua_pushnumber(L, hotbar_itemcount);
1477         return 1;
1478 }
1479
1480 // hud_set_hotbar_image(self, name)
1481 int ObjectRef::l_hud_set_hotbar_image(lua_State *L)
1482 {
1483         NO_MAP_LOCK_REQUIRED;
1484         ObjectRef *ref = checkobject(L, 1);
1485         Player *player = getplayer(ref);
1486         if (player == NULL)
1487                 return 0;
1488
1489         std::string name = lua_tostring(L, 2);
1490
1491         getServer(L)->hudSetHotbarImage(player, name);
1492         return 1;
1493 }
1494
1495 // hud_get_hotbar_image(self)
1496 int ObjectRef::l_hud_get_hotbar_image(lua_State *L)
1497 {
1498         NO_MAP_LOCK_REQUIRED;
1499         ObjectRef *ref = checkobject(L, 1);
1500         Player *player = getplayer(ref);
1501         if (player == NULL)
1502                 return 0;
1503
1504         std::string name = getServer(L)->hudGetHotbarImage(player);
1505         lua_pushlstring(L, name.c_str(), name.size());
1506         return 1;
1507 }
1508
1509 // hud_set_hotbar_selected_image(self, name)
1510 int ObjectRef::l_hud_set_hotbar_selected_image(lua_State *L)
1511 {
1512         NO_MAP_LOCK_REQUIRED;
1513         ObjectRef *ref = checkobject(L, 1);
1514         Player *player = getplayer(ref);
1515         if (player == NULL)
1516                 return 0;
1517
1518         std::string name = lua_tostring(L, 2);
1519
1520         getServer(L)->hudSetHotbarSelectedImage(player, name);
1521         return 1;
1522 }
1523
1524 // hud_get_hotbar_selected_image(self)
1525 int ObjectRef::l_hud_get_hotbar_selected_image(lua_State *L)
1526 {
1527         NO_MAP_LOCK_REQUIRED;
1528         ObjectRef *ref = checkobject(L, 1);
1529         Player *player = getplayer(ref);
1530         if (player == NULL)
1531                 return 0;
1532
1533         std::string name = getServer(L)->hudGetHotbarSelectedImage(player);
1534         lua_pushlstring(L, name.c_str(), name.size());
1535         return 1;
1536 }
1537
1538 // set_sky(self, bgcolor, type, list)
1539 int ObjectRef::l_set_sky(lua_State *L)
1540 {
1541         NO_MAP_LOCK_REQUIRED;
1542         ObjectRef *ref = checkobject(L, 1);
1543         Player *player = getplayer(ref);
1544         if (player == NULL)
1545                 return 0;
1546
1547         video::SColor bgcolor(255,255,255,255);
1548         read_color(L, 2, &bgcolor);
1549
1550         std::string type = luaL_checkstring(L, 3);
1551
1552         std::vector<std::string> params;
1553         if (lua_istable(L, 4)) {
1554                 int table = lua_gettop(L);
1555                 lua_pushnil(L);
1556                 while (lua_next(L, table) != 0) {
1557                         // key at index -2 and value at index -1
1558                         if (lua_isstring(L, -1))
1559                                 params.push_back(lua_tostring(L, -1));
1560                         else
1561                                 params.push_back("");
1562                         // removes value, keeps key for next iteration
1563                         lua_pop(L, 1);
1564                 }
1565         }
1566
1567         if (type == "skybox" && params.size() != 6)
1568                 throw LuaError("skybox expects 6 textures");
1569
1570         if (!getServer(L)->setSky(player, bgcolor, type, params))
1571                 return 0;
1572
1573         lua_pushboolean(L, true);
1574         return 1;
1575 }
1576
1577 // get_sky(self)
1578 int ObjectRef::l_get_sky(lua_State *L)
1579 {
1580         NO_MAP_LOCK_REQUIRED;
1581         ObjectRef *ref = checkobject(L, 1);
1582         Player *player = getplayer(ref);
1583         if (player == NULL)
1584                 return 0;
1585         video::SColor bgcolor(255, 255, 255, 255);
1586         std::string type;
1587         std::vector<std::string> params;
1588
1589         player->getSky(&bgcolor, &type, &params);
1590         type = type == "" ? "regular" : type;
1591
1592         push_ARGB8(L, bgcolor);
1593         lua_pushlstring(L, type.c_str(), type.size());
1594         lua_newtable(L);
1595         s16 i = 1;
1596         for (std::vector<std::string>::iterator it = params.begin();
1597                         it != params.end(); ++it) {
1598                 lua_pushlstring(L, it->c_str(), it->size());
1599                 lua_rawseti(L, -2, i);
1600                 i++;
1601         }
1602         return 3;
1603 }
1604
1605 // override_day_night_ratio(self, brightness=0...1)
1606 int ObjectRef::l_override_day_night_ratio(lua_State *L)
1607 {
1608         NO_MAP_LOCK_REQUIRED;
1609         ObjectRef *ref = checkobject(L, 1);
1610         Player *player = getplayer(ref);
1611         if (player == NULL)
1612                 return 0;
1613
1614         bool do_override = false;
1615         float ratio = 0.0f;
1616         if (!lua_isnil(L, 2)) {
1617                 do_override = true;
1618                 ratio = luaL_checknumber(L, 2);
1619         }
1620
1621         if (!getServer(L)->overrideDayNightRatio(player, do_override, ratio))
1622                 return 0;
1623
1624         lua_pushboolean(L, true);
1625         return 1;
1626 }
1627
1628 // get_day_night_ratio(self)
1629 int ObjectRef::l_get_day_night_ratio(lua_State *L)
1630 {
1631         NO_MAP_LOCK_REQUIRED;
1632         ObjectRef *ref = checkobject(L, 1);
1633         Player *player = getplayer(ref);
1634         if (player == NULL)
1635                 return 0;
1636
1637         bool do_override;
1638         float ratio;
1639         player->getDayNightRatio(&do_override, &ratio);
1640
1641         if (do_override)
1642                 lua_pushnumber(L, ratio);
1643         else
1644                 lua_pushnil(L);
1645
1646         return 1;
1647 }
1648
1649 ObjectRef::ObjectRef(ServerActiveObject *object):
1650         m_object(object)
1651 {
1652         //infostream<<"ObjectRef created for id="<<m_object->getId()<<std::endl;
1653 }
1654
1655 ObjectRef::~ObjectRef()
1656 {
1657         /*if (m_object)
1658                 infostream<<"ObjectRef destructing for id="
1659                                 <<m_object->getId()<<std::endl;
1660         else
1661                 infostream<<"ObjectRef destructing for id=unknown"<<std::endl;*/
1662 }
1663
1664 // Creates an ObjectRef and leaves it on top of stack
1665 // Not callable from Lua; all references are created on the C side.
1666 void ObjectRef::create(lua_State *L, ServerActiveObject *object)
1667 {
1668         ObjectRef *o = new ObjectRef(object);
1669         //infostream<<"ObjectRef::create: o="<<o<<std::endl;
1670         *(void **)(lua_newuserdata(L, sizeof(void *))) = o;
1671         luaL_getmetatable(L, className);
1672         lua_setmetatable(L, -2);
1673 }
1674
1675 void ObjectRef::set_null(lua_State *L)
1676 {
1677         ObjectRef *o = checkobject(L, -1);
1678         o->m_object = NULL;
1679 }
1680
1681 void ObjectRef::Register(lua_State *L)
1682 {
1683         lua_newtable(L);
1684         int methodtable = lua_gettop(L);
1685         luaL_newmetatable(L, className);
1686         int metatable = lua_gettop(L);
1687
1688         lua_pushliteral(L, "__metatable");
1689         lua_pushvalue(L, methodtable);
1690         lua_settable(L, metatable);  // hide metatable from Lua getmetatable()
1691
1692         lua_pushliteral(L, "__index");
1693         lua_pushvalue(L, methodtable);
1694         lua_settable(L, metatable);
1695
1696         lua_pushliteral(L, "__gc");
1697         lua_pushcfunction(L, gc_object);
1698         lua_settable(L, metatable);
1699
1700         lua_pop(L, 1);  // drop metatable
1701
1702         luaL_openlib(L, 0, methods, 0);  // fill methodtable
1703         lua_pop(L, 1);  // drop methodtable
1704
1705         // Cannot be created from Lua
1706         //lua_register(L, className, create_object);
1707 }
1708
1709 const char ObjectRef::className[] = "ObjectRef";
1710 const luaL_reg ObjectRef::methods[] = {
1711         // ServerActiveObject
1712         luamethod(ObjectRef, remove),
1713         luamethod(ObjectRef, getpos),
1714         luamethod(ObjectRef, setpos),
1715         luamethod(ObjectRef, moveto),
1716         luamethod(ObjectRef, punch),
1717         luamethod(ObjectRef, right_click),
1718         luamethod(ObjectRef, set_hp),
1719         luamethod(ObjectRef, get_hp),
1720         luamethod(ObjectRef, get_inventory),
1721         luamethod(ObjectRef, get_wield_list),
1722         luamethod(ObjectRef, get_wield_index),
1723         luamethod(ObjectRef, get_wielded_item),
1724         luamethod(ObjectRef, set_wielded_item),
1725         luamethod(ObjectRef, set_armor_groups),
1726         luamethod(ObjectRef, get_armor_groups),
1727         luamethod(ObjectRef, set_animation),
1728         luamethod(ObjectRef, get_animation),
1729         luamethod(ObjectRef, set_bone_position),
1730         luamethod(ObjectRef, get_bone_position),
1731         luamethod(ObjectRef, set_attach),
1732         luamethod(ObjectRef, get_attach),
1733         luamethod(ObjectRef, set_detach),
1734         luamethod(ObjectRef, set_properties),
1735         luamethod(ObjectRef, get_properties),
1736         luamethod(ObjectRef, set_nametag_attributes),
1737         luamethod(ObjectRef, get_nametag_attributes),
1738         // LuaEntitySAO-only
1739         luamethod(ObjectRef, setvelocity),
1740         luamethod(ObjectRef, getvelocity),
1741         luamethod(ObjectRef, setacceleration),
1742         luamethod(ObjectRef, getacceleration),
1743         luamethod(ObjectRef, setyaw),
1744         luamethod(ObjectRef, getyaw),
1745         luamethod(ObjectRef, settexturemod),
1746         luamethod(ObjectRef, setsprite),
1747         luamethod(ObjectRef, get_entity_name),
1748         luamethod(ObjectRef, get_luaentity),
1749         // Player-only
1750         luamethod(ObjectRef, is_player),
1751         luamethod(ObjectRef, is_player_connected),
1752         luamethod(ObjectRef, get_player_name),
1753         luamethod(ObjectRef, get_player_velocity),
1754         luamethod(ObjectRef, get_look_dir),
1755         luamethod(ObjectRef, get_look_pitch),
1756         luamethod(ObjectRef, get_look_yaw),
1757         luamethod(ObjectRef, set_look_yaw),
1758         luamethod(ObjectRef, set_look_pitch),
1759         luamethod(ObjectRef, get_breath),
1760         luamethod(ObjectRef, set_breath),
1761         luamethod(ObjectRef, set_inventory_formspec),
1762         luamethod(ObjectRef, get_inventory_formspec),
1763         luamethod(ObjectRef, get_player_control),
1764         luamethod(ObjectRef, get_player_control_bits),
1765         luamethod(ObjectRef, set_physics_override),
1766         luamethod(ObjectRef, get_physics_override),
1767         luamethod(ObjectRef, hud_add),
1768         luamethod(ObjectRef, hud_remove),
1769         luamethod(ObjectRef, hud_change),
1770         luamethod(ObjectRef, hud_get),
1771         luamethod(ObjectRef, hud_set_flags),
1772         luamethod(ObjectRef, hud_get_flags),
1773         luamethod(ObjectRef, hud_set_hotbar_itemcount),
1774         luamethod(ObjectRef, hud_get_hotbar_itemcount),
1775         luamethod(ObjectRef, hud_set_hotbar_image),
1776         luamethod(ObjectRef, hud_get_hotbar_image),
1777         luamethod(ObjectRef, hud_set_hotbar_selected_image),
1778         luamethod(ObjectRef, hud_get_hotbar_selected_image),
1779         luamethod(ObjectRef, set_sky),
1780         luamethod(ObjectRef, get_sky),
1781         luamethod(ObjectRef, override_day_night_ratio),
1782         luamethod(ObjectRef, get_day_night_ratio),
1783         luamethod(ObjectRef, set_local_animation),
1784         luamethod(ObjectRef, get_local_animation),
1785         luamethod(ObjectRef, set_eye_offset),
1786         luamethod(ObjectRef, get_eye_offset),
1787         {0,0}
1788 };