src/script/lua_api/l_client.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4 Copyright (C) 2017 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU Lesser General Public License as published by
   8 the Free Software Foundation; either version 2.1 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU Lesser General Public License for more details.
  15
  16 You should have received a copy of the GNU Lesser General Public License along
  17 with this program; if not, write to the Free Software Foundation, Inc.,
  18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 */
  20
  21 #include "l_client.h"
  22 #include "chatmessage.h"
  23 #include "client/client.h"
  24 #include "client/clientevent.h"
  25 #include "client/sound.h"
  26 #include "client/clientenvironment.h"
  27 #include "client/game.h"
  28 #include "common/c_content.h"
  29 #include "common/c_converter.h"
  30 #include "cpp_api/s_base.h"
  31 #include "gettext.h"
  32 #include "l_internal.h"
  33 #include "l_clientobject.h"
  34 #include "lua_api/l_nodemeta.h"
  35 #include "gui/mainmenumanager.h"
  36 #include "map.h"
  37 #include "util/string.h"
  38 #include "nodedef.h"
  39 #include "client/keycode.h"
  40
  41 #define checkCSMRestrictionFlag(flag) \
  42         ( getClient(L)->checkCSMRestrictionFlag(CSMRestrictionFlags::flag) )
  43
  44 // Not the same as FlagDesc, which contains an `u32 flag`
  45 struct CSMFlagDesc {
  46         const char *name;
  47         u64 flag;
  48 };
  49
  50 /*
  51         FIXME: This should eventually be moved somewhere else
  52         It also needs to be kept in sync with the definition of CSMRestrictionFlags
  53         in network/networkprotocol.h
  54 */
  55 const static CSMFlagDesc flagdesc_csm_restriction[] = {
  56         {"load_client_mods",  CSM_RF_LOAD_CLIENT_MODS},
  57         {"chat_messages",     CSM_RF_CHAT_MESSAGES},
  58         {"read_itemdefs",     CSM_RF_READ_ITEMDEFS},
  59         {"read_nodedefs",     CSM_RF_READ_NODEDEFS},
  60         {"lookup_nodes",      CSM_RF_LOOKUP_NODES},
  61         {"read_playerinfo",   CSM_RF_READ_PLAYERINFO},
  62         {NULL,      0}
  63 };
  64
  65 // get_current_modname()
  66 int ModApiClient::l_get_current_modname(lua_State *L)
  67 {
  68         lua_rawgeti(L, LUA_REGISTRYINDEX, CUSTOM_RIDX_CURRENT_MOD_NAME);
  69         return 1;
  70 }
  71
  72 // get_modpath(modname)
  73 int ModApiClient::l_get_modpath(lua_State *L)
  74 {
  75         std::string modname = readParam<std::string>(L, 1);
  76         // Client mods use a virtual filesystem, see Client::scanModSubfolder()
  77         std::string path = modname + ":";
  78         lua_pushstring(L, path.c_str());
  79         return 1;
  80 }
  81
  82 // get_last_run_mod()
  83 int ModApiClient::l_get_last_run_mod(lua_State *L)
  84 {
  85         lua_rawgeti(L, LUA_REGISTRYINDEX, CUSTOM_RIDX_CURRENT_MOD_NAME);
  86         std::string current_mod = readParam<std::string>(L, -1, "");
  87         if (current_mod.empty()) {
  88                 lua_pop(L, 1);
  89                 lua_pushstring(L, getScriptApiBase(L)->getOrigin().c_str());
  90         }
  91         return 1;
  92 }
  93
  94 // set_last_run_mod(modname)
  95 int ModApiClient::l_set_last_run_mod(lua_State *L)
  96 {
  97         if (!lua_isstring(L, 1))
  98                 return 0;
  99
 100         const char *mod = lua_tostring(L, 1);
 101         getScriptApiBase(L)->setOriginDirect(mod);
 102         lua_pushboolean(L, true);
 103         return 1;
 104 }
 105
 106 // print(text)
 107 int ModApiClient::l_print(lua_State *L)
 108 {
 109         NO_MAP_LOCK_REQUIRED;
 110         std::string text = luaL_checkstring(L, 1);
 111         rawstream << text << std::endl;
 112         return 0;
 113 }
 114
 115 // display_chat_message(message)
 116 int ModApiClient::l_display_chat_message(lua_State *L)
 117 {
 118         if (!lua_isstring(L, 1))
 119                 return 0;
 120
 121         std::string message = luaL_checkstring(L, 1);
 122         getClient(L)->pushToChatQueue(new ChatMessage(utf8_to_wide(message)));
 123         lua_pushboolean(L, true);
 124         return 1;
 125 }
 126
 127 // send_chat_message(message)
 128 int ModApiClient::l_send_chat_message(lua_State *L)
 129 {
 130         if (!lua_isstring(L, 1))
 131                 return 0;
 132
 133         // If server disabled this API, discard
 134
 135         if (checkCSMRestrictionFlag(CSM_RF_CHAT_MESSAGES))
 136                 return 0;
 137
 138         std::string message = luaL_checkstring(L, 1);
 139         getClient(L)->sendChatMessage(utf8_to_wide(message));
 140         return 0;
 141 }
 142
 143 // clear_out_chat_queue()
 144 int ModApiClient::l_clear_out_chat_queue(lua_State *L)
 145 {
 146         getClient(L)->clearOutChatQueue();
 147         return 0;
 148 }
 149
 150 // get_player_names()
 151 int ModApiClient::l_get_player_names(lua_State *L)
 152 {
 153         if (checkCSMRestrictionFlag(CSM_RF_READ_PLAYERINFO))
 154                 return 0;
 155
 156         const std::list<std::string> &plist = getClient(L)->getConnectedPlayerNames();
 157         lua_createtable(L, plist.size(), 0);
 158         int newTable = lua_gettop(L);
 159         int index = 1;
 160         std::list<std::string>::const_iterator iter;
 161         for (iter = plist.begin(); iter != plist.end(); ++iter) {
 162                 lua_pushstring(L, (*iter).c_str());
 163                 lua_rawseti(L, newTable, index);
 164                 index++;
 165         }
 166         return 1;
 167 }
 168
 169 // show_formspec(formspec)
 170 int ModApiClient::l_show_formspec(lua_State *L)
 171 {
 172         if (!lua_isstring(L, 1) || !lua_isstring(L, 2))
 173                 return 0;
 174
 175         ClientEvent *event = new ClientEvent();
 176         event->type = CE_SHOW_LOCAL_FORMSPEC;
 177         event->show_formspec.formname = new std::string(luaL_checkstring(L, 1));
 178         event->show_formspec.formspec = new std::string(luaL_checkstring(L, 2));
 179         getClient(L)->pushToEventQueue(event);
 180         lua_pushboolean(L, true);
 181         return 1;
 182 }
 183
 184 // send_respawn()
 185 int ModApiClient::l_send_respawn(lua_State *L)
 186 {
 187         getClient(L)->sendRespawn();
 188         return 0;
 189 }
 190
 191 // disconnect()
 192 int ModApiClient::l_disconnect(lua_State *L)
 193 {
 194         // Stops badly written Lua code form causing boot loops
 195         if (getClient(L)->isShutdown()) {
 196                 lua_pushboolean(L, false);
 197                 return 1;
 198         }
 199
 200         g_gamecallback->disconnect();
 201         lua_pushboolean(L, true);
 202         return 1;
 203 }
 204
 205 // gettext(text)
 206 int ModApiClient::l_gettext(lua_State *L)
 207 {
 208         std::string text = strgettext(std::string(luaL_checkstring(L, 1)));
 209         lua_pushstring(L, text.c_str());
 210
 211         return 1;
 212 }
 213
 214 // get_node_or_nil(pos)
 215 // pos = {x=num, y=num, z=num}
 216 int ModApiClient::l_get_node_or_nil(lua_State *L)
 217 {
 218         // pos
 219         v3s16 pos = read_v3s16(L, 1);
 220
 221         // Do it
 222         bool pos_ok;
 223         MapNode n = getClient(L)->CSMGetNode(pos, &pos_ok);
 224         if (pos_ok) {
 225                 // Return node
 226                 pushnode(L, n, getClient(L)->ndef());
 227         } else {
 228                 lua_pushnil(L);
 229         }
 230         return 1;
 231 }
 232
 233 // get_langauge()
 234 int ModApiClient::l_get_language(lua_State *L)
 235 {
 236 #ifdef _WIN32
 237         char *locale = setlocale(LC_ALL, NULL);
 238 #else
 239         char *locale = setlocale(LC_MESSAGES, NULL);
 240 #endif
 241         std::string lang = gettext("LANG_CODE");
 242         if (lang == "LANG_CODE")
 243                 lang = "";
 244
 245         lua_pushstring(L, locale);
 246         lua_pushstring(L, lang.c_str());
 247         return 2;
 248 }
 249
 250 // get_meta(pos)
 251 int ModApiClient::l_get_meta(lua_State *L)
 252 {
 253         v3s16 p = read_v3s16(L, 1);
 254
 255         // check restrictions first
 256         bool pos_ok;
 257         getClient(L)->CSMGetNode(p, &pos_ok);
 258         if (!pos_ok)
 259                 return 0;
 260
 261         NodeMetadata *meta = getEnv(L)->getMap().getNodeMetadata(p);
 262         NodeMetaRef::createClient(L, meta);
 263         return 1;
 264 }
 265
 266 // sound_play(spec, parameters)
 267 int ModApiClient::l_sound_play(lua_State *L)
 268 {
 269         ISoundManager *sound = getClient(L)->getSoundManager();
 270
 271         SimpleSoundSpec spec;
 272         read_soundspec(L, 1, spec);
 273
 274         float gain = 1.0f;
 275         float pitch = 1.0f;
 276         bool looped = false;
 277         s32 handle;
 278
 279         if (lua_istable(L, 2)) {
 280                 getfloatfield(L, 2, "gain", gain);
 281                 getfloatfield(L, 2, "pitch", pitch);
 282                 getboolfield(L, 2, "loop", looped);
 283
 284                 lua_getfield(L, 2, "pos");
 285                 if (!lua_isnil(L, -1)) {
 286                         v3f pos = read_v3f(L, -1) * BS;
 287                         lua_pop(L, 1);
 288                         handle = sound->playSoundAt(
 289                                         spec.name, looped, gain * spec.gain, pos, pitch);
 290                         lua_pushinteger(L, handle);
 291                         return 1;
 292                 }
 293         }
 294
 295         handle = sound->playSound(spec.name, looped, gain * spec.gain, spec.fade, pitch);
 296         lua_pushinteger(L, handle);
 297
 298         return 1;
 299 }
 300
 301 // sound_stop(handle)
 302 int ModApiClient::l_sound_stop(lua_State *L)
 303 {
 304         s32 handle = luaL_checkinteger(L, 1);
 305
 306         getClient(L)->getSoundManager()->stopSound(handle);
 307
 308         return 0;
 309 }
 310
 311 // sound_fade(handle, step, gain)
 312 int ModApiClient::l_sound_fade(lua_State *L)
 313 {
 314         s32 handle = luaL_checkinteger(L, 1);
 315         float step = readParam<float>(L, 2);
 316         float gain = readParam<float>(L, 3);
 317         getClient(L)->getSoundManager()->fadeSound(handle, step, gain);
 318         return 0;
 319 }
 320
 321 // get_server_info()
 322 int ModApiClient::l_get_server_info(lua_State *L)
 323 {
 324         Client *client = getClient(L);
 325         Address serverAddress = client->getServerAddress();
 326         lua_newtable(L);
 327         lua_pushstring(L, client->getAddressName().c_str());
 328         lua_setfield(L, -2, "address");
 329         lua_pushstring(L, serverAddress.serializeString().c_str());
 330         lua_setfield(L, -2, "ip");
 331         lua_pushinteger(L, serverAddress.getPort());
 332         lua_setfield(L, -2, "port");
 333         lua_pushinteger(L, client->getProtoVersion());
 334         lua_setfield(L, -2, "protocol_version");
 335         return 1;
 336 }
 337
 338 // get_item_def(itemstring)
 339 int ModApiClient::l_get_item_def(lua_State *L)
 340 {
 341         IGameDef *gdef = getGameDef(L);
 342         assert(gdef);
 343
 344         IItemDefManager *idef = gdef->idef();
 345         assert(idef);
 346
 347         if (checkCSMRestrictionFlag(CSM_RF_READ_ITEMDEFS))
 348                 return 0;
 349
 350         if (!lua_isstring(L, 1))
 351                 return 0;
 352
 353         std::string name = readParam<std::string>(L, 1);
 354         if (!idef->isKnown(name))
 355                 return 0;
 356         const ItemDefinition &def = idef->get(name);
 357
 358         push_item_definition_full(L, def);
 359
 360         return 1;
 361 }
 362
 363 // get_node_def(nodename)
 364 int ModApiClient::l_get_node_def(lua_State *L)
 365 {
 366         IGameDef *gdef = getGameDef(L);
 367         assert(gdef);
 368
 369         const NodeDefManager *ndef = gdef->ndef();
 370         assert(ndef);
 371
 372         if (!lua_isstring(L, 1))
 373                 return 0;
 374
 375         if (checkCSMRestrictionFlag(CSM_RF_READ_NODEDEFS))
 376                 return 0;
 377
 378         std::string name = readParam<std::string>(L, 1);
 379         const ContentFeatures &cf = ndef->get(ndef->getId(name));
 380         if (cf.name != name) // Unknown node. | name = <whatever>, cf.name = ignore
 381                 return 0;
 382
 383         push_content_features(L, cf);
 384
 385         return 1;
 386 }
 387
 388 // get_privilege_list()
 389 int ModApiClient::l_get_privilege_list(lua_State *L)
 390 {
 391         const Client *client = getClient(L);
 392         lua_newtable(L);
 393         for (const std::string &priv : client->getPrivilegeList()) {
 394                 lua_pushboolean(L, true);
 395                 lua_setfield(L, -2, priv.c_str());
 396         }
 397         return 1;
 398 }
 399
 400 // get_builtin_path()
 401 int ModApiClient::l_get_builtin_path(lua_State *L)
 402 {
 403         lua_pushstring(L, BUILTIN_MOD_NAME ":");
 404         return 1;
 405 }
 406
 407 // get_csm_restrictions()
 408 int ModApiClient::l_get_csm_restrictions(lua_State *L)
 409 {
 410         u64 flags = getClient(L)->getCSMRestrictionFlags();
 411         const CSMFlagDesc *flagdesc = flagdesc_csm_restriction;
 412
 413         lua_newtable(L);
 414         for (int i = 0; flagdesc[i].name; i++) {
 415                 setboolfield(L, -1, flagdesc[i].name, !!(flags & flagdesc[i].flag));
 416         }
 417         return 1;
 418 }
 419
 420 // send_damage(damage)
 421 int ModApiClient::l_send_damage(lua_State *L)
 422 {
 423         u16 damage = luaL_checknumber(L, 1);
 424         getClient(L)->sendDamage(damage);
 425         return 0;
 426 }
 427
 428 // place_node(pos)
 429 int ModApiClient::l_place_node(lua_State *L)
 430 {
 431         Client *client = getClient(L);
 432         ClientMap &map = client->getEnv().getClientMap();
 433         LocalPlayer *player = client->getEnv().getLocalPlayer();
 434         ItemStack selected_item, hand_item;
 435         player->getWieldedItem(&selected_item, &hand_item);
 436         const ItemDefinition &selected_def = selected_item.getDefinition(getGameDef(L)->idef());
 437         v3s16 pos = read_v3s16(L, 1);
 438         PointedThing pointed;
 439         pointed.type = POINTEDTHING_NODE;
 440         pointed.node_abovesurface = pos;
 441         pointed.node_undersurface = pos;
 442         NodeMetadata *meta = map.getNodeMetadata(pos);
 443         g_game->nodePlacement(selected_def, selected_item, pos, pos, pointed, meta);
 444         return 0;
 445 }
 446
 447 // dig_node(pos)
 448 int ModApiClient::l_dig_node(lua_State *L)
 449 {
 450         Client *client = getClient(L);
 451         v3s16 pos = read_v3s16(L, 1);
 452         PointedThing pointed;
 453         pointed.type = POINTEDTHING_NODE;
 454         pointed.node_abovesurface = pos;
 455         pointed.node_undersurface = pos;
 456         client->interact(INTERACT_START_DIGGING, pointed);
 457         client->interact(INTERACT_DIGGING_COMPLETED, pointed);
 458         return 0;
 459 }
 460
 461 // get_inventory(location)
 462 int ModApiClient::l_get_inventory(lua_State *L)
 463 {
 464         Client *client = getClient(L);
 465         InventoryLocation inventory_location;
 466         Inventory *inventory;
 467         std::string location;
 468
 469         location = readParam<std::string>(L, 1);
 470
 471         try {
 472                 inventory_location.deSerialize(location);
 473                 inventory = client->getInventory(inventory_location);
 474                 push_inventory(L, inventory);
 475         } catch (SerializationError &) {
 476                 lua_pushnil(L);
 477         }
 478
 479         return 1;
 480 }
 481
 482 // set_keypress(key_setting, pressed) -> returns true on success
 483 int ModApiClient::l_set_keypress(lua_State *L)
 484 {
 485         std::string setting_name = "keymap_" + readParam<std::string>(L, 1);
 486         bool pressed = lua_isboolean(L, 2) && readParam<bool>(L, 2);
 487         try {
 488                 KeyPress keyCode = getKeySetting(setting_name.c_str());
 489                 if (pressed)
 490                         g_game->input->setKeypress(keyCode);
 491                 else
 492                         g_game->input->unsetKeypress(keyCode);
 493                 lua_pushboolean(L, true);
 494         } catch (SettingNotFoundException &) {
 495                 lua_pushboolean(L, false);
 496         }
 497         return 1;
 498 }
 499
 500 // drop_selected_item()
 501 int ModApiClient::l_drop_selected_item(lua_State *L)
 502 {
 503         g_game->dropSelectedItem();
 504         return 0;
 505 }
 506
 507 // get_objects_inside_radius(pos, radius)
 508 int ModApiClient::l_get_objects_inside_radius(lua_State *L)
 509 {
 510         ClientEnvironment &env = getClient(L)->getEnv();
 511
 512         v3f pos = checkFloatPos(L, 1);
 513         float radius = readParam<float>(L, 2) * BS;
 514
 515         std::vector<DistanceSortedActiveObject> objs;
 516         env.getActiveObjects(pos, radius, objs);
 517
 518         int i = 0;
 519         lua_createtable(L, objs.size(), 0);
 520         for (const auto obj : objs) {
 521                 ClientObjectRef::create(L, obj.obj);                                                    // TODO: getObjectRefOrCreate
 522                 lua_rawseti(L, -2, ++i);
 523         }
 524         return 1;
 525 }
 526
 527 void ModApiClient::Initialize(lua_State *L, int top)
 528 {
 529         API_FCT(get_current_modname);
 530         API_FCT(get_modpath);
 531         API_FCT(print);
 532         API_FCT(display_chat_message);
 533         API_FCT(send_chat_message);
 534         API_FCT(clear_out_chat_queue);
 535         API_FCT(get_player_names);
 536         API_FCT(set_last_run_mod);
 537         API_FCT(get_last_run_mod);
 538         API_FCT(show_formspec);
 539         API_FCT(send_respawn);
 540         API_FCT(gettext);
 541         API_FCT(get_node_or_nil);
 542         API_FCT(disconnect);
 543         API_FCT(get_meta);
 544         API_FCT(sound_play);
 545         API_FCT(sound_stop);
 546         API_FCT(sound_fade);
 547         API_FCT(get_server_info);
 548         API_FCT(get_item_def);
 549         API_FCT(get_node_def);
 550         API_FCT(get_privilege_list);
 551         API_FCT(get_builtin_path);
 552         API_FCT(get_language);
 553         API_FCT(get_csm_restrictions);
 554         API_FCT(send_damage);
 555         API_FCT(place_node);
 556         API_FCT(dig_node);
 557         API_FCT(get_inventory);
 558         API_FCT(set_keypress);
 559         API_FCT(drop_selected_item);
 560         API_FCT(get_objects_inside_radius);
 561 }