src/scriptapi_nodemeta.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 "scriptapi.h"
  21 #include "scriptapi_nodemeta.h"
  22 #include "map.h"
  23 #include "script.h"
  24 #include "scriptapi_types.h"
  25 #include "scriptapi_inventory.h"
  26 #include "scriptapi_common.h"
  27 #include "scriptapi_item.h"
  28 #include "scriptapi_object.h"
  29
  30
  31 /*
  32         NodeMetaRef
  33 */
  34 NodeMetaRef* NodeMetaRef::checkobject(lua_State *L, int narg)
  35 {
  36         luaL_checktype(L, narg, LUA_TUSERDATA);
  37         void *ud = luaL_checkudata(L, narg, className);
  38         if(!ud) luaL_typerror(L, narg, className);
  39         return *(NodeMetaRef**)ud;  // unbox pointer
  40 }
  41
  42 NodeMetadata* NodeMetaRef::getmeta(NodeMetaRef *ref, bool auto_create)
  43 {
  44         NodeMetadata *meta = ref->m_env->getMap().getNodeMetadata(ref->m_p);
  45         if(meta == NULL && auto_create)
  46         {
  47                 meta = new NodeMetadata(ref->m_env->getGameDef());
  48                 ref->m_env->getMap().setNodeMetadata(ref->m_p, meta);
  49         }
  50         return meta;
  51 }
  52
  53 void NodeMetaRef::reportMetadataChange(NodeMetaRef *ref)
  54 {
  55         // NOTE: This same code is in rollback_interface.cpp
  56         // Inform other things that the metadata has changed
  57         v3s16 blockpos = getNodeBlockPos(ref->m_p);
  58         MapEditEvent event;
  59         event.type = MEET_BLOCK_NODE_METADATA_CHANGED;
  60         event.p = blockpos;
  61         ref->m_env->getMap().dispatchEvent(&event);
  62         // Set the block to be saved
  63         MapBlock *block = ref->m_env->getMap().getBlockNoCreateNoEx(blockpos);
  64         if(block)
  65                 block->raiseModified(MOD_STATE_WRITE_NEEDED,
  66                                 "NodeMetaRef::reportMetadataChange");
  67 }
  68
  69 // Exported functions
  70
  71 // garbage collector
  72 int NodeMetaRef::gc_object(lua_State *L) {
  73         NodeMetaRef *o = *(NodeMetaRef **)(lua_touserdata(L, 1));
  74         delete o;
  75         return 0;
  76 }
  77
  78 // get_string(self, name)
  79 int NodeMetaRef::l_get_string(lua_State *L)
  80 {
  81         NodeMetaRef *ref = checkobject(L, 1);
  82         std::string name = luaL_checkstring(L, 2);
  83
  84         NodeMetadata *meta = getmeta(ref, false);
  85         if(meta == NULL){
  86                 lua_pushlstring(L, "", 0);
  87                 return 1;
  88         }
  89         std::string str = meta->getString(name);
  90         lua_pushlstring(L, str.c_str(), str.size());
  91         return 1;
  92 }
  93
  94 // set_string(self, name, var)
  95 int NodeMetaRef::l_set_string(lua_State *L)
  96 {
  97         NodeMetaRef *ref = checkobject(L, 1);
  98         std::string name = luaL_checkstring(L, 2);
  99         size_t len = 0;
 100         const char *s = lua_tolstring(L, 3, &len);
 101         std::string str(s, len);
 102
 103         NodeMetadata *meta = getmeta(ref, !str.empty());
 104         if(meta == NULL || str == meta->getString(name))
 105                 return 0;
 106         meta->setString(name, str);
 107         reportMetadataChange(ref);
 108         return 0;
 109 }
 110
 111 // get_int(self, name)
 112 int NodeMetaRef::l_get_int(lua_State *L)
 113 {
 114         NodeMetaRef *ref = checkobject(L, 1);
 115         std::string name = lua_tostring(L, 2);
 116
 117         NodeMetadata *meta = getmeta(ref, false);
 118         if(meta == NULL){
 119                 lua_pushnumber(L, 0);
 120                 return 1;
 121         }
 122         std::string str = meta->getString(name);
 123         lua_pushnumber(L, stoi(str));
 124         return 1;
 125 }
 126
 127 // set_int(self, name, var)
 128 int NodeMetaRef::l_set_int(lua_State *L)
 129 {
 130         NodeMetaRef *ref = checkobject(L, 1);
 131         std::string name = lua_tostring(L, 2);
 132         int a = lua_tointeger(L, 3);
 133         std::string str = itos(a);
 134
 135         NodeMetadata *meta = getmeta(ref, true);
 136         if(meta == NULL || str == meta->getString(name))
 137                 return 0;
 138         meta->setString(name, str);
 139         reportMetadataChange(ref);
 140         return 0;
 141 }
 142
 143 // get_float(self, name)
 144 int NodeMetaRef::l_get_float(lua_State *L)
 145 {
 146         NodeMetaRef *ref = checkobject(L, 1);
 147         std::string name = lua_tostring(L, 2);
 148
 149         NodeMetadata *meta = getmeta(ref, false);
 150         if(meta == NULL){
 151                 lua_pushnumber(L, 0);
 152                 return 1;
 153         }
 154         std::string str = meta->getString(name);
 155         lua_pushnumber(L, stof(str));
 156         return 1;
 157 }
 158
 159 // set_float(self, name, var)
 160 int NodeMetaRef::l_set_float(lua_State *L)
 161 {
 162         NodeMetaRef *ref = checkobject(L, 1);
 163         std::string name = lua_tostring(L, 2);
 164         float a = lua_tonumber(L, 3);
 165         std::string str = ftos(a);
 166
 167         NodeMetadata *meta = getmeta(ref, true);
 168         if(meta == NULL || str == meta->getString(name))
 169                 return 0;
 170         meta->setString(name, str);
 171         reportMetadataChange(ref);
 172         return 0;
 173 }
 174
 175 // get_inventory(self)
 176 int NodeMetaRef::l_get_inventory(lua_State *L)
 177 {
 178         NodeMetaRef *ref = checkobject(L, 1);
 179         getmeta(ref, true);  // try to ensure the metadata exists
 180         InvRef::createNodeMeta(L, ref->m_p);
 181         return 1;
 182 }
 183
 184 // to_table(self)
 185 int NodeMetaRef::l_to_table(lua_State *L)
 186 {
 187         NodeMetaRef *ref = checkobject(L, 1);
 188
 189         NodeMetadata *meta = getmeta(ref, true);
 190         if(meta == NULL){
 191                 lua_pushnil(L);
 192                 return 1;
 193         }
 194         lua_newtable(L);
 195         // fields
 196         lua_newtable(L);
 197         {
 198                 std::map<std::string, std::string> fields = meta->getStrings();
 199                 for(std::map<std::string, std::string>::const_iterator
 200                                 i = fields.begin(); i != fields.end(); i++){
 201                         const std::string &name = i->first;
 202                         const std::string &value = i->second;
 203                         lua_pushlstring(L, name.c_str(), name.size());
 204                         lua_pushlstring(L, value.c_str(), value.size());
 205                         lua_settable(L, -3);
 206                 }
 207         }
 208         lua_setfield(L, -2, "fields");
 209         // inventory
 210         lua_newtable(L);
 211         Inventory *inv = meta->getInventory();
 212         if(inv){
 213                 std::vector<const InventoryList*> lists = inv->getLists();
 214                 for(std::vector<const InventoryList*>::const_iterator
 215                                 i = lists.begin(); i != lists.end(); i++){
 216                         inventory_get_list_to_lua(inv, (*i)->getName().c_str(), L);
 217                         lua_setfield(L, -2, (*i)->getName().c_str());
 218                 }
 219         }
 220         lua_setfield(L, -2, "inventory");
 221         return 1;
 222 }
 223
 224 // from_table(self, table)
 225 int NodeMetaRef::l_from_table(lua_State *L)
 226 {
 227         NodeMetaRef *ref = checkobject(L, 1);
 228         int base = 2;
 229
 230         if(lua_isnil(L, base)){
 231                 // No metadata
 232                 ref->m_env->getMap().removeNodeMetadata(ref->m_p);
 233                 lua_pushboolean(L, true);
 234                 return 1;
 235         }
 236
 237         // Has metadata; clear old one first
 238         ref->m_env->getMap().removeNodeMetadata(ref->m_p);
 239         // Create new metadata
 240         NodeMetadata *meta = getmeta(ref, true);
 241         // Set fields
 242         lua_getfield(L, base, "fields");
 243         int fieldstable = lua_gettop(L);
 244         lua_pushnil(L);
 245         while(lua_next(L, fieldstable) != 0){
 246                 // key at index -2 and value at index -1
 247                 std::string name = lua_tostring(L, -2);
 248                 size_t cl;
 249                 const char *cs = lua_tolstring(L, -1, &cl);
 250                 std::string value(cs, cl);
 251                 meta->setString(name, value);
 252                 lua_pop(L, 1); // removes value, keeps key for next iteration
 253         }
 254         // Set inventory
 255         Inventory *inv = meta->getInventory();
 256         lua_getfield(L, base, "inventory");
 257         int inventorytable = lua_gettop(L);
 258         lua_pushnil(L);
 259         while(lua_next(L, inventorytable) != 0){
 260                 // key at index -2 and value at index -1
 261                 std::string name = lua_tostring(L, -2);
 262                 inventory_set_list_from_lua(inv, name.c_str(), L, -1);
 263                 lua_pop(L, 1); // removes value, keeps key for next iteration
 264         }
 265         reportMetadataChange(ref);
 266         lua_pushboolean(L, true);
 267         return 1;
 268 }
 269
 270
 271 NodeMetaRef::NodeMetaRef(v3s16 p, ServerEnvironment *env):
 272         m_p(p),
 273         m_env(env)
 274 {
 275 }
 276
 277 NodeMetaRef::~NodeMetaRef()
 278 {
 279 }
 280
 281 // Creates an NodeMetaRef and leaves it on top of stack
 282 // Not callable from Lua; all references are created on the C side.
 283 void NodeMetaRef::create(lua_State *L, v3s16 p, ServerEnvironment *env)
 284 {
 285         NodeMetaRef *o = new NodeMetaRef(p, env);
 286         //infostream<<"NodeMetaRef::create: o="<<o<<std::endl;
 287         *(void **)(lua_newuserdata(L, sizeof(void *))) = o;
 288         luaL_getmetatable(L, className);
 289         lua_setmetatable(L, -2);
 290 }
 291
 292 void NodeMetaRef::Register(lua_State *L)
 293 {
 294         lua_newtable(L);
 295         int methodtable = lua_gettop(L);
 296         luaL_newmetatable(L, className);
 297         int metatable = lua_gettop(L);
 298
 299         lua_pushliteral(L, "__metatable");
 300         lua_pushvalue(L, methodtable);
 301         lua_settable(L, metatable);  // hide metatable from Lua getmetatable()
 302
 303         lua_pushliteral(L, "__index");
 304         lua_pushvalue(L, methodtable);
 305         lua_settable(L, metatable);
 306
 307         lua_pushliteral(L, "__gc");
 308         lua_pushcfunction(L, gc_object);
 309         lua_settable(L, metatable);
 310
 311         lua_pop(L, 1);  // drop metatable
 312
 313         luaL_openlib(L, 0, methods, 0);  // fill methodtable
 314         lua_pop(L, 1);  // drop methodtable
 315
 316         // Cannot be created from Lua
 317         //lua_register(L, className, create_object);
 318 }
 319
 320 const char NodeMetaRef::className[] = "NodeMetaRef";
 321 const luaL_reg NodeMetaRef::methods[] = {
 322         luamethod(NodeMetaRef, get_string),
 323         luamethod(NodeMetaRef, set_string),
 324         luamethod(NodeMetaRef, get_int),
 325         luamethod(NodeMetaRef, set_int),
 326         luamethod(NodeMetaRef, get_float),
 327         luamethod(NodeMetaRef, set_float),
 328         luamethod(NodeMetaRef, get_inventory),
 329         luamethod(NodeMetaRef, to_table),
 330         luamethod(NodeMetaRef, from_table),
 331         {0,0}
 332 };
 333
 334 /*
 335         Node metadata inventory callbacks
 336 */
 337
 338 // Return number of accepted items to be moved
 339 int scriptapi_nodemeta_inventory_allow_move(lua_State *L, v3s16 p,
 340                 const std::string &from_list, int from_index,
 341                 const std::string &to_list, int to_index,
 342                 int count, ServerActiveObject *player)
 343 {
 344         realitycheck(L);
 345         assert(lua_checkstack(L, 20));
 346         StackUnroller stack_unroller(L);
 347
 348         INodeDefManager *ndef = get_server(L)->ndef();
 349
 350         // If node doesn't exist, we don't know what callback to call
 351         MapNode node = get_env(L)->getMap().getNodeNoEx(p);
 352         if(node.getContent() == CONTENT_IGNORE)
 353                 return 0;
 354
 355         // Push callback function on stack
 356         if(!get_item_callback(L, ndef->get(node).name.c_str(),
 357                         "allow_metadata_inventory_move"))
 358                 return count;
 359
 360         // function(pos, from_list, from_index, to_list, to_index, count, player)
 361         // pos
 362         push_v3s16(L, p);
 363         // from_list
 364         lua_pushstring(L, from_list.c_str());
 365         // from_index
 366         lua_pushinteger(L, from_index + 1);
 367         // to_list
 368         lua_pushstring(L, to_list.c_str());
 369         // to_index
 370         lua_pushinteger(L, to_index + 1);
 371         // count
 372         lua_pushinteger(L, count);
 373         // player
 374         objectref_get_or_create(L, player);
 375         if(lua_pcall(L, 7, 1, 0))
 376                 script_error(L, "error: %s", lua_tostring(L, -1));
 377         if(!lua_isnumber(L, -1))
 378                 throw LuaError(L, "allow_metadata_inventory_move should return a number");
 379         return luaL_checkinteger(L, -1);
 380 }
 381
 382 // Return number of accepted items to be put
 383 int scriptapi_nodemeta_inventory_allow_put(lua_State *L, v3s16 p,
 384                 const std::string &listname, int index, ItemStack &stack,
 385                 ServerActiveObject *player)
 386 {
 387         realitycheck(L);
 388         assert(lua_checkstack(L, 20));
 389         StackUnroller stack_unroller(L);
 390
 391         INodeDefManager *ndef = get_server(L)->ndef();
 392
 393         // If node doesn't exist, we don't know what callback to call
 394         MapNode node = get_env(L)->getMap().getNodeNoEx(p);
 395         if(node.getContent() == CONTENT_IGNORE)
 396                 return 0;
 397
 398         // Push callback function on stack
 399         if(!get_item_callback(L, ndef->get(node).name.c_str(),
 400                         "allow_metadata_inventory_put"))
 401                 return stack.count;
 402
 403         // Call function(pos, listname, index, stack, player)
 404         // pos
 405         push_v3s16(L, p);
 406         // listname
 407         lua_pushstring(L, listname.c_str());
 408         // index
 409         lua_pushinteger(L, index + 1);
 410         // stack
 411         LuaItemStack::create(L, stack);
 412         // player
 413         objectref_get_or_create(L, player);
 414         if(lua_pcall(L, 5, 1, 0))
 415                 script_error(L, "error: %s", lua_tostring(L, -1));
 416         if(!lua_isnumber(L, -1))
 417                 throw LuaError(L, "allow_metadata_inventory_put should return a number");
 418         return luaL_checkinteger(L, -1);
 419 }
 420
 421 // Return number of accepted items to be taken
 422 int scriptapi_nodemeta_inventory_allow_take(lua_State *L, v3s16 p,
 423                 const std::string &listname, int index, ItemStack &stack,
 424                 ServerActiveObject *player)
 425 {
 426         realitycheck(L);
 427         assert(lua_checkstack(L, 20));
 428         StackUnroller stack_unroller(L);
 429
 430         INodeDefManager *ndef = get_server(L)->ndef();
 431
 432         // If node doesn't exist, we don't know what callback to call
 433         MapNode node = get_env(L)->getMap().getNodeNoEx(p);
 434         if(node.getContent() == CONTENT_IGNORE)
 435                 return 0;
 436
 437         // Push callback function on stack
 438         if(!get_item_callback(L, ndef->get(node).name.c_str(),
 439                         "allow_metadata_inventory_take"))
 440                 return stack.count;
 441
 442         // Call function(pos, listname, index, count, player)
 443         // pos
 444         push_v3s16(L, p);
 445         // listname
 446         lua_pushstring(L, listname.c_str());
 447         // index
 448         lua_pushinteger(L, index + 1);
 449         // stack
 450         LuaItemStack::create(L, stack);
 451         // player
 452         objectref_get_or_create(L, player);
 453         if(lua_pcall(L, 5, 1, 0))
 454                 script_error(L, "error: %s", lua_tostring(L, -1));
 455         if(!lua_isnumber(L, -1))
 456                 throw LuaError(L, "allow_metadata_inventory_take should return a number");
 457         return luaL_checkinteger(L, -1);
 458 }
 459
 460 // Report moved items
 461 void scriptapi_nodemeta_inventory_on_move(lua_State *L, v3s16 p,
 462                 const std::string &from_list, int from_index,
 463                 const std::string &to_list, int to_index,
 464                 int count, ServerActiveObject *player)
 465 {
 466         realitycheck(L);
 467         assert(lua_checkstack(L, 20));
 468         StackUnroller stack_unroller(L);
 469
 470         INodeDefManager *ndef = get_server(L)->ndef();
 471
 472         // If node doesn't exist, we don't know what callback to call
 473         MapNode node = get_env(L)->getMap().getNodeNoEx(p);
 474         if(node.getContent() == CONTENT_IGNORE)
 475                 return;
 476
 477         // Push callback function on stack
 478         if(!get_item_callback(L, ndef->get(node).name.c_str(),
 479                         "on_metadata_inventory_move"))
 480                 return;
 481
 482         // function(pos, from_list, from_index, to_list, to_index, count, player)
 483         // pos
 484         push_v3s16(L, p);
 485         // from_list
 486         lua_pushstring(L, from_list.c_str());
 487         // from_index
 488         lua_pushinteger(L, from_index + 1);
 489         // to_list
 490         lua_pushstring(L, to_list.c_str());
 491         // to_index
 492         lua_pushinteger(L, to_index + 1);
 493         // count
 494         lua_pushinteger(L, count);
 495         // player
 496         objectref_get_or_create(L, player);
 497         if(lua_pcall(L, 7, 0, 0))
 498                 script_error(L, "error: %s", lua_tostring(L, -1));
 499 }
 500
 501 // Report put items
 502 void scriptapi_nodemeta_inventory_on_put(lua_State *L, v3s16 p,
 503                 const std::string &listname, int index, ItemStack &stack,
 504                 ServerActiveObject *player)
 505 {
 506         realitycheck(L);
 507         assert(lua_checkstack(L, 20));
 508         StackUnroller stack_unroller(L);
 509
 510         INodeDefManager *ndef = get_server(L)->ndef();
 511
 512         // If node doesn't exist, we don't know what callback to call
 513         MapNode node = get_env(L)->getMap().getNodeNoEx(p);
 514         if(node.getContent() == CONTENT_IGNORE)
 515                 return;
 516
 517         // Push callback function on stack
 518         if(!get_item_callback(L, ndef->get(node).name.c_str(),
 519                         "on_metadata_inventory_put"))
 520                 return;
 521
 522         // Call function(pos, listname, index, stack, player)
 523         // pos
 524         push_v3s16(L, p);
 525         // listname
 526         lua_pushstring(L, listname.c_str());
 527         // index
 528         lua_pushinteger(L, index + 1);
 529         // stack
 530         LuaItemStack::create(L, stack);
 531         // player
 532         objectref_get_or_create(L, player);
 533         if(lua_pcall(L, 5, 0, 0))
 534                 script_error(L, "error: %s", lua_tostring(L, -1));
 535 }
 536
 537 // Report taken items
 538 void scriptapi_nodemeta_inventory_on_take(lua_State *L, v3s16 p,
 539                 const std::string &listname, int index, ItemStack &stack,
 540                 ServerActiveObject *player)
 541 {
 542         realitycheck(L);
 543         assert(lua_checkstack(L, 20));
 544         StackUnroller stack_unroller(L);
 545
 546         INodeDefManager *ndef = get_server(L)->ndef();
 547
 548         // If node doesn't exist, we don't know what callback to call
 549         MapNode node = get_env(L)->getMap().getNodeNoEx(p);
 550         if(node.getContent() == CONTENT_IGNORE)
 551                 return;
 552
 553         // Push callback function on stack
 554         if(!get_item_callback(L, ndef->get(node).name.c_str(),
 555                         "on_metadata_inventory_take"))
 556                 return;
 557
 558         // Call function(pos, listname, index, stack, player)
 559         // pos
 560         push_v3s16(L, p);
 561         // listname
 562         lua_pushstring(L, listname.c_str());
 563         // index
 564         lua_pushinteger(L, index + 1);
 565         // stack
 566         LuaItemStack::create(L, stack);
 567         // player
 568         objectref_get_or_create(L, player);
 569         if(lua_pcall(L, 5, 0, 0))
 570                 script_error(L, "error: %s", lua_tostring(L, -1));
 571 }