src/script/lua_api/l_mainmenu.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 sapier
   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_mainmenu.h"
  21 #include "lua_api/l_internal.h"
  22 #include "common/c_content.h"
  23 #include "cpp_api/s_async.h"
  24 #include "gui/guiEngine.h"
  25 #include "gui/guiMainMenu.h"
  26 #include "gui/guiKeyChangeMenu.h"
  27 #include "gui/guiPathSelectMenu.h"
  28 #include "version.h"
  29 #include "porting.h"
  30 #include "filesys.h"
  31 #include "convert_json.h"
  32 #include "content/packages.h"
  33 #include "content/content.h"
  34 #include "content/subgames.h"
  35 #include "serverlist.h"
  36 #include "mapgen/mapgen.h"
  37 #include "settings.h"
  38
  39 #include <IFileArchive.h>
  40 #include <IFileSystem.h>
  41 #include "client/renderingengine.h"
  42 #include "network/networkprotocol.h"
  43
  44
  45 /******************************************************************************/
  46 std::string ModApiMainMenu::getTextData(lua_State *L, std::string name)
  47 {
  48         lua_getglobal(L, "gamedata");
  49
  50         lua_getfield(L, -1, name.c_str());
  51
  52         if(lua_isnil(L, -1))
  53                 return "";
  54
  55         return luaL_checkstring(L, -1);
  56 }
  57
  58 /******************************************************************************/
  59 int ModApiMainMenu::getIntegerData(lua_State *L, std::string name,bool& valid)
  60 {
  61         lua_getglobal(L, "gamedata");
  62
  63         lua_getfield(L, -1, name.c_str());
  64
  65         if(lua_isnil(L, -1)) {
  66                 valid = false;
  67                 return -1;
  68                 }
  69
  70         valid = true;
  71         return luaL_checkinteger(L, -1);
  72 }
  73
  74 /******************************************************************************/
  75 int ModApiMainMenu::getBoolData(lua_State *L, std::string name,bool& valid)
  76 {
  77         lua_getglobal(L, "gamedata");
  78
  79         lua_getfield(L, -1, name.c_str());
  80
  81         if(lua_isnil(L, -1)) {
  82                 valid = false;
  83                 return false;
  84                 }
  85
  86         valid = true;
  87         return readParam<bool>(L, -1);
  88 }
  89
  90 /******************************************************************************/
  91 int ModApiMainMenu::l_update_formspec(lua_State *L)
  92 {
  93         GUIEngine* engine = getGuiEngine(L);
  94         sanity_check(engine != NULL);
  95
  96         if (engine->m_startgame)
  97                 return 0;
  98
  99         //read formspec
 100         std::string formspec(luaL_checkstring(L, 1));
 101
 102         if (engine->m_formspecgui != 0) {
 103                 engine->m_formspecgui->setForm(formspec);
 104         }
 105
 106         return 0;
 107 }
 108
 109 /******************************************************************************/
 110 int ModApiMainMenu::l_set_formspec_prepend(lua_State *L)
 111 {
 112         GUIEngine *engine = getGuiEngine(L);
 113         sanity_check(engine != NULL);
 114
 115         if (engine->m_startgame)
 116                 return 0;
 117
 118         std::string formspec(luaL_checkstring(L, 1));
 119         engine->setFormspecPrepend(formspec);
 120
 121         return 0;
 122 }
 123
 124 /******************************************************************************/
 125 int ModApiMainMenu::l_start(lua_State *L)
 126 {
 127         GUIEngine* engine = getGuiEngine(L);
 128         sanity_check(engine != NULL);
 129
 130         //update c++ gamedata from lua table
 131
 132         bool valid = false;
 133
 134         MainMenuData *data = engine->m_data;
 135
 136         data->selected_world = getIntegerData(L, "selected_world",valid) -1;
 137         data->simple_singleplayer_mode = getBoolData(L,"singleplayer",valid);
 138         data->do_reconnect = getBoolData(L, "do_reconnect", valid);
 139         if (!data->do_reconnect) {
 140                 data->name     = getTextData(L,"playername");
 141                 data->password = getTextData(L,"password");
 142                 data->address  = getTextData(L,"address");
 143                 data->port     = getTextData(L,"port");
 144         }
 145         data->serverdescription = getTextData(L,"serverdescription");
 146         data->servername        = getTextData(L,"servername");
 147
 148         //close menu next time
 149         engine->m_startgame = true;
 150         return 0;
 151 }
 152
 153 /******************************************************************************/
 154 int ModApiMainMenu::l_close(lua_State *L)
 155 {
 156         GUIEngine* engine = getGuiEngine(L);
 157         sanity_check(engine != NULL);
 158
 159         engine->m_kill = true;
 160         return 0;
 161 }
 162
 163 /******************************************************************************/
 164 int ModApiMainMenu::l_set_background(lua_State *L)
 165 {
 166         GUIEngine* engine = getGuiEngine(L);
 167         sanity_check(engine != NULL);
 168
 169         std::string backgroundlevel(luaL_checkstring(L, 1));
 170         std::string texturename(luaL_checkstring(L, 2));
 171
 172         bool tile_image = false;
 173         bool retval     = false;
 174         unsigned int minsize = 16;
 175
 176         if (!lua_isnone(L, 3)) {
 177                 tile_image = readParam<bool>(L, 3);
 178         }
 179
 180         if (!lua_isnone(L, 4)) {
 181                 minsize = lua_tonumber(L, 4);
 182         }
 183
 184         if (backgroundlevel == "background") {
 185                 retval |= engine->setTexture(TEX_LAYER_BACKGROUND, texturename,
 186                                 tile_image, minsize);
 187         }
 188
 189         if (backgroundlevel == "overlay") {
 190                 retval |= engine->setTexture(TEX_LAYER_OVERLAY, texturename,
 191                                 tile_image, minsize);
 192         }
 193
 194         if (backgroundlevel == "header") {
 195                 retval |= engine->setTexture(TEX_LAYER_HEADER,  texturename,
 196                                 tile_image, minsize);
 197         }
 198
 199         if (backgroundlevel == "footer") {
 200                 retval |= engine->setTexture(TEX_LAYER_FOOTER, texturename,
 201                                 tile_image, minsize);
 202         }
 203
 204         lua_pushboolean(L,retval);
 205         return 1;
 206 }
 207
 208 /******************************************************************************/
 209 int ModApiMainMenu::l_set_clouds(lua_State *L)
 210 {
 211         GUIEngine* engine = getGuiEngine(L);
 212         sanity_check(engine != NULL);
 213
 214         bool value = readParam<bool>(L,1);
 215
 216         engine->m_clouds_enabled = value;
 217
 218         return 0;
 219 }
 220
 221 /******************************************************************************/
 222 int ModApiMainMenu::l_get_textlist_index(lua_State *L)
 223 {
 224         // get_table_index accepts both tables and textlists
 225         return l_get_table_index(L);
 226 }
 227
 228 /******************************************************************************/
 229 int ModApiMainMenu::l_get_table_index(lua_State *L)
 230 {
 231         GUIEngine* engine = getGuiEngine(L);
 232         sanity_check(engine != NULL);
 233
 234         std::string tablename(luaL_checkstring(L, 1));
 235         GUITable *table = engine->m_menu->getTable(tablename);
 236         s32 selection = table ? table->getSelected() : 0;
 237
 238         if (selection >= 1)
 239                 lua_pushinteger(L, selection);
 240         else
 241                 lua_pushnil(L);
 242         return 1;
 243 }
 244
 245 /******************************************************************************/
 246 int ModApiMainMenu::l_get_worlds(lua_State *L)
 247 {
 248         std::vector<WorldSpec> worlds = getAvailableWorlds();
 249
 250         lua_newtable(L);
 251         int top = lua_gettop(L);
 252         unsigned int index = 1;
 253
 254         for (const WorldSpec &world : worlds) {
 255                 lua_pushnumber(L,index);
 256
 257                 lua_newtable(L);
 258                 int top_lvl2 = lua_gettop(L);
 259
 260                 lua_pushstring(L,"path");
 261                 lua_pushstring(L, world.path.c_str());
 262                 lua_settable(L, top_lvl2);
 263
 264                 lua_pushstring(L,"name");
 265                 lua_pushstring(L, world.name.c_str());
 266                 lua_settable(L, top_lvl2);
 267
 268                 lua_pushstring(L,"gameid");
 269                 lua_pushstring(L, world.gameid.c_str());
 270                 lua_settable(L, top_lvl2);
 271
 272                 lua_settable(L, top);
 273                 index++;
 274         }
 275         return 1;
 276 }
 277
 278 /******************************************************************************/
 279 int ModApiMainMenu::l_get_favorites(lua_State *L)
 280 {
 281         std::string listtype = "local";
 282
 283         if (!lua_isnone(L, 1)) {
 284                 listtype = luaL_checkstring(L, 1);
 285         }
 286
 287         std::vector<ServerListSpec> servers;
 288
 289         if(listtype == "online") {
 290                 servers = ServerList::getOnline();
 291         } else {
 292                 servers = ServerList::getLocal();
 293         }
 294
 295         lua_newtable(L);
 296         int top = lua_gettop(L);
 297         unsigned int index = 1;
 298
 299         for (const Json::Value &server : servers) {
 300
 301                 lua_pushnumber(L, index);
 302
 303                 lua_newtable(L);
 304                 int top_lvl2 = lua_gettop(L);
 305
 306                 if (!server["clients"].asString().empty()) {
 307                         std::string clients_raw = server["clients"].asString();
 308                         char* endptr = 0;
 309                         int numbervalue = strtol(clients_raw.c_str(), &endptr,10);
 310
 311                         if ((!clients_raw.empty()) && (*endptr == 0)) {
 312                                 lua_pushstring(L, "clients");
 313                                 lua_pushnumber(L, numbervalue);
 314                                 lua_settable(L, top_lvl2);
 315                         }
 316                 }
 317
 318                 if (!server["clients_max"].asString().empty()) {
 319
 320                         std::string clients_max_raw = server["clients_max"].asString();
 321                         char* endptr = 0;
 322                         int numbervalue = strtol(clients_max_raw.c_str(), &endptr,10);
 323
 324                         if ((!clients_max_raw.empty()) && (*endptr == 0)) {
 325                                 lua_pushstring(L, "clients_max");
 326                                 lua_pushnumber(L, numbervalue);
 327                                 lua_settable(L, top_lvl2);
 328                         }
 329                 }
 330
 331                 if (!server["version"].asString().empty()) {
 332                         lua_pushstring(L, "version");
 333                         std::string topush = server["version"].asString();
 334                         lua_pushstring(L, topush.c_str());
 335                         lua_settable(L, top_lvl2);
 336                 }
 337
 338                 if (!server["proto_min"].asString().empty()) {
 339                         lua_pushstring(L, "proto_min");
 340                         lua_pushinteger(L, server["proto_min"].asInt());
 341                         lua_settable(L, top_lvl2);
 342                 }
 343
 344                 if (!server["proto_max"].asString().empty()) {
 345                         lua_pushstring(L, "proto_max");
 346                         lua_pushinteger(L, server["proto_max"].asInt());
 347                         lua_settable(L, top_lvl2);
 348                 }
 349
 350                 if (!server["password"].asString().empty()) {
 351                         lua_pushstring(L, "password");
 352                         lua_pushboolean(L, server["password"].asBool());
 353                         lua_settable(L, top_lvl2);
 354                 }
 355
 356                 if (!server["creative"].asString().empty()) {
 357                         lua_pushstring(L, "creative");
 358                         lua_pushboolean(L, server["creative"].asBool());
 359                         lua_settable(L, top_lvl2);
 360                 }
 361
 362                 if (!server["damage"].asString().empty()) {
 363                         lua_pushstring(L, "damage");
 364                         lua_pushboolean(L, server["damage"].asBool());
 365                         lua_settable(L, top_lvl2);
 366                 }
 367
 368                 if (!server["pvp"].asString().empty()) {
 369                         lua_pushstring(L, "pvp");
 370                         lua_pushboolean(L, server["pvp"].asBool());
 371                         lua_settable(L, top_lvl2);
 372                 }
 373
 374                 if (!server["description"].asString().empty()) {
 375                         lua_pushstring(L, "description");
 376                         std::string topush = server["description"].asString();
 377                         lua_pushstring(L, topush.c_str());
 378                         lua_settable(L, top_lvl2);
 379                 }
 380
 381                 if (!server["name"].asString().empty()) {
 382                         lua_pushstring(L, "name");
 383                         std::string topush = server["name"].asString();
 384                         lua_pushstring(L, topush.c_str());
 385                         lua_settable(L, top_lvl2);
 386                 }
 387
 388                 if (!server["address"].asString().empty()) {
 389                         lua_pushstring(L, "address");
 390                         std::string topush = server["address"].asString();
 391                         lua_pushstring(L, topush.c_str());
 392                         lua_settable(L, top_lvl2);
 393                 }
 394
 395                 if (!server["port"].asString().empty()) {
 396                         lua_pushstring(L, "port");
 397                         std::string topush = server["port"].asString();
 398                         lua_pushstring(L, topush.c_str());
 399                         lua_settable(L, top_lvl2);
 400                 }
 401
 402                 if (server.isMember("ping")) {
 403                         float ping = server["ping"].asFloat();
 404                         lua_pushstring(L, "ping");
 405                         lua_pushnumber(L, ping);
 406                         lua_settable(L, top_lvl2);
 407                 }
 408
 409                 if (server["clients_list"].isArray()) {
 410                         unsigned int index_lvl2 = 1;
 411                         lua_pushstring(L, "clients_list");
 412                         lua_newtable(L);
 413                         int top_lvl3 = lua_gettop(L);
 414                         for (const Json::Value &client : server["clients_list"]) {
 415                                 lua_pushnumber(L, index_lvl2);
 416                                 std::string topush = client.asString();
 417                                 lua_pushstring(L, topush.c_str());
 418                                 lua_settable(L, top_lvl3);
 419                                 index_lvl2++;
 420                         }
 421                         lua_settable(L, top_lvl2);
 422                 }
 423
 424                 if (server["mods"].isArray()) {
 425                         unsigned int index_lvl2 = 1;
 426                         lua_pushstring(L, "mods");
 427                         lua_newtable(L);
 428                         int top_lvl3 = lua_gettop(L);
 429                         for (const Json::Value &mod : server["mods"]) {
 430
 431                                 lua_pushnumber(L, index_lvl2);
 432                                 std::string topush = mod.asString();
 433                                 lua_pushstring(L, topush.c_str());
 434                                 lua_settable(L, top_lvl3);
 435                                 index_lvl2++;
 436                         }
 437                         lua_settable(L, top_lvl2);
 438                 }
 439
 440                 lua_settable(L, top);
 441                 index++;
 442         }
 443         return 1;
 444 }
 445
 446 /******************************************************************************/
 447 int ModApiMainMenu::l_delete_favorite(lua_State *L)
 448 {
 449         std::vector<ServerListSpec> servers;
 450
 451         std::string listtype = "local";
 452
 453         if (!lua_isnone(L,2)) {
 454                 listtype = luaL_checkstring(L,2);
 455         }
 456
 457         if ((listtype != "local") &&
 458                 (listtype != "online"))
 459                 return 0;
 460
 461
 462         if(listtype == "online") {
 463                 servers = ServerList::getOnline();
 464         } else {
 465                 servers = ServerList::getLocal();
 466         }
 467
 468         int fav_idx     = luaL_checkinteger(L,1) -1;
 469
 470         if ((fav_idx >= 0) &&
 471                         (fav_idx < (int) servers.size())) {
 472
 473                 ServerList::deleteEntry(servers[fav_idx]);
 474         }
 475
 476         return 0;
 477 }
 478
 479 /******************************************************************************/
 480 int ModApiMainMenu::l_get_games(lua_State *L)
 481 {
 482         std::vector<SubgameSpec> games = getAvailableGames();
 483
 484         lua_newtable(L);
 485         int top = lua_gettop(L);
 486         unsigned int index = 1;
 487
 488         for (const SubgameSpec &game : games) {
 489                 lua_pushnumber(L, index);
 490                 lua_newtable(L);
 491                 int top_lvl2 = lua_gettop(L);
 492
 493                 lua_pushstring(L,  "id");
 494                 lua_pushstring(L,  game.id.c_str());
 495                 lua_settable(L,    top_lvl2);
 496
 497                 lua_pushstring(L,  "path");
 498                 lua_pushstring(L,  game.path.c_str());
 499                 lua_settable(L,    top_lvl2);
 500
 501                 lua_pushstring(L,  "type");
 502                 lua_pushstring(L,  "game");
 503                 lua_settable(L,    top_lvl2);
 504
 505                 lua_pushstring(L,  "gamemods_path");
 506                 lua_pushstring(L,  game.gamemods_path.c_str());
 507                 lua_settable(L,    top_lvl2);
 508
 509                 lua_pushstring(L,  "name");
 510                 lua_pushstring(L,  game.name.c_str());
 511                 lua_settable(L,    top_lvl2);
 512
 513                 lua_pushstring(L,  "author");
 514                 lua_pushstring(L,  game.author.c_str());
 515                 lua_settable(L,    top_lvl2);
 516
 517                 lua_pushstring(L,  "release");
 518                 lua_pushinteger(L, game.release);
 519                 lua_settable(L,    top_lvl2);
 520
 521                 lua_pushstring(L,  "menuicon_path");
 522                 lua_pushstring(L,  game.menuicon_path.c_str());
 523                 lua_settable(L,    top_lvl2);
 524
 525                 lua_pushstring(L, "addon_mods_paths");
 526                 lua_newtable(L);
 527                 int table2 = lua_gettop(L);
 528                 int internal_index = 1;
 529                 for (const std::string &addon_mods_path : game.addon_mods_paths) {
 530                         lua_pushnumber(L, internal_index);
 531                         lua_pushstring(L, addon_mods_path.c_str());
 532                         lua_settable(L,   table2);
 533                         internal_index++;
 534                 }
 535                 lua_settable(L, top_lvl2);
 536                 lua_settable(L, top);
 537                 index++;
 538         }
 539         return 1;
 540 }
 541
 542 /******************************************************************************/
 543 int ModApiMainMenu::l_get_content_info(lua_State *L)
 544 {
 545         std::string path = luaL_checkstring(L, 1);
 546
 547         ContentSpec spec;
 548         spec.path = path;
 549         parseContentInfo(spec);
 550
 551         lua_newtable(L);
 552
 553         lua_pushstring(L, spec.name.c_str());
 554         lua_setfield(L, -2, "name");
 555
 556         lua_pushstring(L, spec.type.c_str());
 557         lua_setfield(L, -2, "type");
 558
 559         lua_pushstring(L, spec.author.c_str());
 560         lua_setfield(L, -2, "author");
 561
 562         lua_pushinteger(L, spec.release);
 563         lua_setfield(L, -2, "release");
 564
 565         lua_pushstring(L, spec.desc.c_str());
 566         lua_setfield(L, -2, "description");
 567
 568         lua_pushstring(L, spec.path.c_str());
 569         lua_setfield(L, -2, "path");
 570
 571         if (spec.type == "mod") {
 572                 ModSpec spec;
 573                 spec.path = path;
 574                 parseModContents(spec);
 575
 576                 // Dependencies
 577                 lua_newtable(L);
 578                 int i = 1;
 579                 for (const auto &dep : spec.depends) {
 580                         lua_pushstring(L, dep.c_str());
 581                         lua_rawseti(L, -2, i++);
 582                 }
 583                 lua_setfield(L, -2, "depends");
 584
 585                 // Optional Dependencies
 586                 lua_newtable(L);
 587                 i = 1;
 588                 for (const auto &dep : spec.optdepends) {
 589                         lua_pushstring(L, dep.c_str());
 590                         lua_rawseti(L, -2, i++);
 591                 }
 592                 lua_setfield(L, -2, "optional_depends");
 593         }
 594
 595         return 1;
 596 }
 597
 598 /******************************************************************************/
 599 int ModApiMainMenu::l_show_keys_menu(lua_State *L)
 600 {
 601         GUIEngine* engine = getGuiEngine(L);
 602         sanity_check(engine != NULL);
 603
 604         GUIKeyChangeMenu *kmenu = new GUIKeyChangeMenu(RenderingEngine::get_gui_env(),
 605                         engine->m_parent,
 606                         -1,
 607                         engine->m_menumanager,
 608                         engine->m_texture_source);
 609         kmenu->drop();
 610         return 0;
 611 }
 612
 613 /******************************************************************************/
 614 int ModApiMainMenu::l_create_world(lua_State *L)
 615 {
 616         const char *name        = luaL_checkstring(L, 1);
 617         int gameidx                     = luaL_checkinteger(L,2) -1;
 618
 619         std::string path = porting::path_user + DIR_DELIM
 620                         "worlds" + DIR_DELIM
 621                         + name;
 622
 623         std::vector<SubgameSpec> games = getAvailableGames();
 624
 625         if ((gameidx >= 0) &&
 626                         (gameidx < (int) games.size())) {
 627
 628                 // Create world if it doesn't exist
 629                 if (!loadGameConfAndInitWorld(path, games[gameidx])) {
 630                         lua_pushstring(L, "Failed to initialize world");
 631                 } else {
 632                         lua_pushnil(L);
 633                 }
 634         } else {
 635                 lua_pushstring(L, "Invalid game index");
 636         }
 637         return 1;
 638 }
 639
 640 /******************************************************************************/
 641 int ModApiMainMenu::l_delete_world(lua_State *L)
 642 {
 643         int world_id = luaL_checkinteger(L, 1) - 1;
 644         std::vector<WorldSpec> worlds = getAvailableWorlds();
 645         if (world_id < 0 || world_id >= (int) worlds.size()) {
 646                 lua_pushstring(L, "Invalid world index");
 647                 return 1;
 648         }
 649         const WorldSpec &spec = worlds[world_id];
 650         if (!fs::RecursiveDelete(spec.path)) {
 651                 lua_pushstring(L, "Failed to delete world");
 652                 return 1;
 653         }
 654         return 0;
 655 }
 656
 657 /******************************************************************************/
 658 int ModApiMainMenu::l_set_topleft_text(lua_State *L)
 659 {
 660         GUIEngine* engine = getGuiEngine(L);
 661         sanity_check(engine != NULL);
 662
 663         std::string text;
 664
 665         if (!lua_isnone(L,1) && !lua_isnil(L,1))
 666                 text = luaL_checkstring(L, 1);
 667
 668         engine->setTopleftText(text);
 669         return 0;
 670 }
 671
 672 /******************************************************************************/
 673 int ModApiMainMenu::l_get_mapgen_names(lua_State *L)
 674 {
 675         std::vector<const char *> names;
 676         bool include_hidden = lua_isboolean(L, 1) && readParam<bool>(L, 1);
 677         Mapgen::getMapgenNames(&names, include_hidden);
 678
 679         lua_newtable(L);
 680         for (size_t i = 0; i != names.size(); i++) {
 681                 lua_pushstring(L, names[i]);
 682                 lua_rawseti(L, -2, i + 1);
 683         }
 684
 685         return 1;
 686 }
 687
 688
 689 /******************************************************************************/
 690 int ModApiMainMenu::l_get_modpath(lua_State *L)
 691 {
 692         std::string modpath = fs::RemoveRelativePathComponents(
 693                 porting::path_user + DIR_DELIM + "mods" + DIR_DELIM);
 694         lua_pushstring(L, modpath.c_str());
 695         return 1;
 696 }
 697
 698 /******************************************************************************/
 699 int ModApiMainMenu::l_get_clientmodpath(lua_State *L)
 700 {
 701         std::string modpath = fs::RemoveRelativePathComponents(
 702                 porting::path_user + DIR_DELIM + "clientmods" + DIR_DELIM);
 703         lua_pushstring(L, modpath.c_str());
 704         return 1;
 705 }
 706
 707 /******************************************************************************/
 708 int ModApiMainMenu::l_get_gamepath(lua_State *L)
 709 {
 710         std::string gamepath = fs::RemoveRelativePathComponents(
 711                 porting::path_user + DIR_DELIM + "games" + DIR_DELIM);
 712         lua_pushstring(L, gamepath.c_str());
 713         return 1;
 714 }
 715
 716 /******************************************************************************/
 717 int ModApiMainMenu::l_get_texturepath(lua_State *L)
 718 {
 719         std::string gamepath = fs::RemoveRelativePathComponents(
 720                 porting::path_user + DIR_DELIM + "textures");
 721         lua_pushstring(L, gamepath.c_str());
 722         return 1;
 723 }
 724
 725 int ModApiMainMenu::l_get_texturepath_share(lua_State *L)
 726 {
 727         std::string gamepath = fs::RemoveRelativePathComponents(
 728                 porting::path_share + DIR_DELIM + "textures");
 729         lua_pushstring(L, gamepath.c_str());
 730         return 1;
 731 }
 732
 733 int ModApiMainMenu::l_get_cache_path(lua_State *L)
 734 {
 735         lua_pushstring(L, fs::RemoveRelativePathComponents(porting::path_cache).c_str());
 736         return 1;
 737 }
 738
 739 /******************************************************************************/
 740 int ModApiMainMenu::l_create_dir(lua_State *L) {
 741         const char *path = luaL_checkstring(L, 1);
 742
 743         if (ModApiMainMenu::mayModifyPath(path)) {
 744                 lua_pushboolean(L, fs::CreateAllDirs(path));
 745                 return 1;
 746         }
 747
 748         lua_pushboolean(L, false);
 749         return 1;
 750 }
 751
 752 /******************************************************************************/
 753 int ModApiMainMenu::l_delete_dir(lua_State *L)
 754 {
 755         const char *path = luaL_checkstring(L, 1);
 756
 757         std::string absolute_path = fs::RemoveRelativePathComponents(path);
 758
 759         if (ModApiMainMenu::mayModifyPath(absolute_path)) {
 760                 lua_pushboolean(L, fs::RecursiveDelete(absolute_path));
 761                 return 1;
 762         }
 763
 764         lua_pushboolean(L, false);
 765         return 1;
 766 }
 767
 768 /******************************************************************************/
 769 int ModApiMainMenu::l_copy_dir(lua_State *L)
 770 {
 771         const char *source      = luaL_checkstring(L, 1);
 772         const char *destination = luaL_checkstring(L, 2);
 773
 774         bool keep_source = true;
 775
 776         if ((!lua_isnone(L,3)) &&
 777                         (!lua_isnil(L,3))) {
 778                 keep_source = readParam<bool>(L,3);
 779         }
 780
 781         std::string absolute_destination = fs::RemoveRelativePathComponents(destination);
 782         std::string absolute_source = fs::RemoveRelativePathComponents(source);
 783
 784         if ((ModApiMainMenu::mayModifyPath(absolute_destination))) {
 785                 bool retval = fs::CopyDir(absolute_source,absolute_destination);
 786
 787                 if (retval && (!keep_source)) {
 788
 789                         retval &= fs::RecursiveDelete(absolute_source);
 790                 }
 791                 lua_pushboolean(L,retval);
 792                 return 1;
 793         }
 794         lua_pushboolean(L,false);
 795         return 1;
 796 }
 797
 798 /******************************************************************************/
 799 int ModApiMainMenu::l_extract_zip(lua_State *L)
 800 {
 801         const char *zipfile     = luaL_checkstring(L, 1);
 802         const char *destination = luaL_checkstring(L, 2);
 803
 804         std::string absolute_destination = fs::RemoveRelativePathComponents(destination);
 805
 806         if (ModApiMainMenu::mayModifyPath(absolute_destination)) {
 807                 fs::CreateAllDirs(absolute_destination);
 808
 809                 io::IFileSystem *fs = RenderingEngine::get_filesystem();
 810
 811                 if (!fs->addFileArchive(zipfile, false, false, io::EFAT_ZIP)) {
 812                         lua_pushboolean(L,false);
 813                         return 1;
 814                 }
 815
 816                 sanity_check(fs->getFileArchiveCount() > 0);
 817
 818                 /**********************************************************************/
 819                 /* WARNING this is not threadsafe!!                                   */
 820                 /**********************************************************************/
 821                 io::IFileArchive* opened_zip =
 822                         fs->getFileArchive(fs->getFileArchiveCount()-1);
 823
 824                 const io::IFileList* files_in_zip = opened_zip->getFileList();
 825
 826                 unsigned int number_of_files = files_in_zip->getFileCount();
 827
 828                 for (unsigned int i=0; i < number_of_files; i++) {
 829                         std::string fullpath = destination;
 830                         fullpath += DIR_DELIM;
 831                         fullpath += files_in_zip->getFullFileName(i).c_str();
 832                         std::string fullpath_dir = fs::RemoveLastPathComponent(fullpath);
 833
 834                         if (!files_in_zip->isDirectory(i)) {
 835                                 if (!fs::PathExists(fullpath_dir) && !fs::CreateAllDirs(fullpath_dir)) {
 836                                         fs->removeFileArchive(fs->getFileArchiveCount()-1);
 837                                         lua_pushboolean(L,false);
 838                                         return 1;
 839                                 }
 840
 841                                 io::IReadFile* toread = opened_zip->createAndOpenFile(i);
 842
 843                                 FILE *targetfile = fopen(fullpath.c_str(),"wb");
 844
 845                                 if (targetfile == NULL) {
 846                                         fs->removeFileArchive(fs->getFileArchiveCount()-1);
 847                                         lua_pushboolean(L,false);
 848                                         return 1;
 849                                 }
 850
 851                                 char read_buffer[1024];
 852                                 long total_read = 0;
 853
 854                                 while (total_read < toread->getSize()) {
 855
 856                                         unsigned int bytes_read =
 857                                                         toread->read(read_buffer,sizeof(read_buffer));
 858                                         if ((bytes_read == 0 ) ||
 859                                                 (fwrite(read_buffer, 1, bytes_read, targetfile) != bytes_read))
 860                                         {
 861                                                 fclose(targetfile);
 862                                                 fs->removeFileArchive(fs->getFileArchiveCount()-1);
 863                                                 lua_pushboolean(L,false);
 864                                                 return 1;
 865                                         }
 866                                         total_read += bytes_read;
 867                                 }
 868
 869                                 fclose(targetfile);
 870                         }
 871
 872                 }
 873
 874                 fs->removeFileArchive(fs->getFileArchiveCount()-1);
 875                 lua_pushboolean(L,true);
 876                 return 1;
 877         }
 878
 879         lua_pushboolean(L,false);
 880         return 1;
 881 }
 882
 883 /******************************************************************************/
 884 int ModApiMainMenu::l_get_mainmenu_path(lua_State *L)
 885 {
 886         GUIEngine* engine = getGuiEngine(L);
 887         sanity_check(engine != NULL);
 888
 889         lua_pushstring(L,engine->getScriptDir().c_str());
 890         return 1;
 891 }
 892
 893 /******************************************************************************/
 894 bool ModApiMainMenu::mayModifyPath(const std::string &path)
 895 {
 896         if (fs::PathStartsWith(path, fs::TempPath()))
 897                 return true;
 898
 899         if (fs::PathStartsWith(path, fs::RemoveRelativePathComponents(porting::path_user + DIR_DELIM "games")))
 900                 return true;
 901
 902         if (fs::PathStartsWith(path, fs::RemoveRelativePathComponents(porting::path_user + DIR_DELIM "mods")))
 903                 return true;
 904
 905         if (fs::PathStartsWith(path, fs::RemoveRelativePathComponents(porting::path_user + DIR_DELIM "textures")))
 906                 return true;
 907
 908         if (fs::PathStartsWith(path, fs::RemoveRelativePathComponents(porting::path_user + DIR_DELIM "worlds")))
 909                 return true;
 910
 911         if (fs::PathStartsWith(path, fs::RemoveRelativePathComponents(porting::path_cache)))
 912                 return true;
 913
 914         return false;
 915 }
 916
 917
 918 /******************************************************************************/
 919 int ModApiMainMenu::l_may_modify_path(lua_State *L)
 920 {
 921         const char *target = luaL_checkstring(L, 1);
 922         std::string absolute_destination = fs::RemoveRelativePathComponents(target);
 923         lua_pushboolean(L, ModApiMainMenu::mayModifyPath(absolute_destination));
 924         return 1;
 925 }
 926
 927 /******************************************************************************/
 928 int ModApiMainMenu::l_show_path_select_dialog(lua_State *L)
 929 {
 930         GUIEngine* engine = getGuiEngine(L);
 931         sanity_check(engine != NULL);
 932
 933         const char *formname= luaL_checkstring(L, 1);
 934         const char *title       = luaL_checkstring(L, 2);
 935         bool is_file_select = readParam<bool>(L, 3);
 936
 937         GUIFileSelectMenu* fileOpenMenu =
 938                 new GUIFileSelectMenu(RenderingEngine::get_gui_env(),
 939                                 engine->m_parent,
 940                                 -1,
 941                                 engine->m_menumanager,
 942                                 title,
 943                                 formname,
 944                                 is_file_select);
 945         fileOpenMenu->setTextDest(engine->m_buttonhandler);
 946         fileOpenMenu->drop();
 947         return 0;
 948 }
 949
 950 /******************************************************************************/
 951 int ModApiMainMenu::l_download_file(lua_State *L)
 952 {
 953         const char *url    = luaL_checkstring(L, 1);
 954         const char *target = luaL_checkstring(L, 2);
 955
 956         //check path
 957         std::string absolute_destination = fs::RemoveRelativePathComponents(target);
 958
 959         if (ModApiMainMenu::mayModifyPath(absolute_destination)) {
 960                 if (GUIEngine::downloadFile(url,absolute_destination)) {
 961                         lua_pushboolean(L,true);
 962                         return 1;
 963                 }
 964         } else {
 965                 errorstream << "DOWNLOAD denied: " << absolute_destination
 966                                 << " isn't a allowed path" << std::endl;
 967         }
 968         lua_pushboolean(L,false);
 969         return 1;
 970 }
 971
 972 /******************************************************************************/
 973 int ModApiMainMenu::l_get_video_drivers(lua_State *L)
 974 {
 975         std::vector<irr::video::E_DRIVER_TYPE> drivers = RenderingEngine::getSupportedVideoDrivers();
 976
 977         lua_newtable(L);
 978         for (u32 i = 0; i != drivers.size(); i++) {
 979                 const char *name  = RenderingEngine::getVideoDriverName(drivers[i]);
 980                 const char *fname = RenderingEngine::getVideoDriverFriendlyName(drivers[i]);
 981
 982                 lua_newtable(L);
 983                 lua_pushstring(L, name);
 984                 lua_setfield(L, -2, "name");
 985                 lua_pushstring(L, fname);
 986                 lua_setfield(L, -2, "friendly_name");
 987
 988                 lua_rawseti(L, -2, i + 1);
 989         }
 990
 991         return 1;
 992 }
 993
 994 /******************************************************************************/
 995 int ModApiMainMenu::l_get_video_modes(lua_State *L)
 996 {
 997         std::vector<core::vector3d<u32> > videomodes
 998                 = RenderingEngine::getSupportedVideoModes();
 999
1000         lua_newtable(L);
1001         for (u32 i = 0; i != videomodes.size(); i++) {
1002                 lua_newtable(L);
1003                 lua_pushnumber(L, videomodes[i].X);
1004                 lua_setfield(L, -2, "w");
1005                 lua_pushnumber(L, videomodes[i].Y);
1006                 lua_setfield(L, -2, "h");
1007                 lua_pushnumber(L, videomodes[i].Z);
1008                 lua_setfield(L, -2, "depth");
1009
1010                 lua_rawseti(L, -2, i + 1);
1011         }
1012
1013         return 1;
1014 }
1015
1016 /******************************************************************************/
1017 int ModApiMainMenu::l_gettext(lua_State *L)
1018 {
1019         std::string text = strgettext(std::string(luaL_checkstring(L, 1)));
1020         lua_pushstring(L, text.c_str());
1021
1022         return 1;
1023 }
1024
1025 /******************************************************************************/
1026 int ModApiMainMenu::l_get_screen_info(lua_State *L)
1027 {
1028         lua_newtable(L);
1029         int top = lua_gettop(L);
1030         lua_pushstring(L,"density");
1031         lua_pushnumber(L,RenderingEngine::getDisplayDensity());
1032         lua_settable(L, top);
1033
1034         lua_pushstring(L,"display_width");
1035         lua_pushnumber(L,RenderingEngine::getDisplaySize().X);
1036         lua_settable(L, top);
1037
1038         lua_pushstring(L,"display_height");
1039         lua_pushnumber(L,RenderingEngine::getDisplaySize().Y);
1040         lua_settable(L, top);
1041
1042         const v2u32 &window_size = RenderingEngine::get_instance()->getWindowSize();
1043         lua_pushstring(L,"window_width");
1044         lua_pushnumber(L, window_size.X);
1045         lua_settable(L, top);
1046
1047         lua_pushstring(L,"window_height");
1048         lua_pushnumber(L, window_size.Y);
1049         lua_settable(L, top);
1050         return 1;
1051 }
1052
1053 /******************************************************************************/
1054 int ModApiMainMenu::l_get_min_supp_proto(lua_State *L)
1055 {
1056         lua_pushinteger(L, CLIENT_PROTOCOL_VERSION_MIN);
1057         return 1;
1058 }
1059
1060 int ModApiMainMenu::l_get_max_supp_proto(lua_State *L)
1061 {
1062         lua_pushinteger(L, CLIENT_PROTOCOL_VERSION_MAX);
1063         return 1;
1064 }
1065
1066 /******************************************************************************/
1067 int ModApiMainMenu::l_open_url(lua_State *L)
1068 {
1069         std::string url = luaL_checkstring(L, 1);
1070         lua_pushboolean(L, porting::openURL(url));
1071         return 1;
1072 }
1073
1074 /******************************************************************************/
1075 int ModApiMainMenu::l_do_async_callback(lua_State *L)
1076 {
1077         GUIEngine* engine = getGuiEngine(L);
1078
1079         size_t func_length, param_length;
1080         const char* serialized_func_raw = luaL_checklstring(L, 1, &func_length);
1081
1082         const char* serialized_param_raw = luaL_checklstring(L, 2, &param_length);
1083
1084         sanity_check(serialized_func_raw != NULL);
1085         sanity_check(serialized_param_raw != NULL);
1086
1087         std::string serialized_func = std::string(serialized_func_raw, func_length);
1088         std::string serialized_param = std::string(serialized_param_raw, param_length);
1089
1090         lua_pushinteger(L, engine->queueAsync(serialized_func, serialized_param));
1091
1092         return 1;
1093 }
1094
1095 /******************************************************************************/
1096 void ModApiMainMenu::Initialize(lua_State *L, int top)
1097 {
1098         API_FCT(update_formspec);
1099         API_FCT(set_formspec_prepend);
1100         API_FCT(set_clouds);
1101         API_FCT(get_textlist_index);
1102         API_FCT(get_table_index);
1103         API_FCT(get_worlds);
1104         API_FCT(get_games);
1105         API_FCT(get_content_info);
1106         API_FCT(start);
1107         API_FCT(close);
1108         API_FCT(get_favorites);
1109         API_FCT(show_keys_menu);
1110         API_FCT(create_world);
1111         API_FCT(delete_world);
1112         API_FCT(delete_favorite);
1113         API_FCT(set_background);
1114         API_FCT(set_topleft_text);
1115         API_FCT(get_mapgen_names);
1116         API_FCT(get_modpath);
1117         API_FCT(get_clientmodpath);
1118         API_FCT(get_gamepath);
1119         API_FCT(get_texturepath);
1120         API_FCT(get_texturepath_share);
1121         API_FCT(get_cache_path);
1122         API_FCT(create_dir);
1123         API_FCT(delete_dir);
1124         API_FCT(copy_dir);
1125         API_FCT(extract_zip);
1126         API_FCT(may_modify_path);
1127         API_FCT(get_mainmenu_path);
1128         API_FCT(show_path_select_dialog);
1129         API_FCT(download_file);
1130         API_FCT(gettext);
1131         API_FCT(get_video_drivers);
1132         API_FCT(get_video_modes);
1133         API_FCT(get_screen_info);
1134         API_FCT(get_min_supp_proto);
1135         API_FCT(get_max_supp_proto);
1136         API_FCT(open_url);
1137         API_FCT(do_async_callback);
1138 }
1139
1140 /******************************************************************************/
1141 void ModApiMainMenu::InitializeAsync(lua_State *L, int top)
1142 {
1143         API_FCT(get_worlds);
1144         API_FCT(get_games);
1145         API_FCT(get_favorites);
1146         API_FCT(get_mapgen_names);
1147         API_FCT(get_modpath);
1148         API_FCT(get_clientmodpath);
1149         API_FCT(get_gamepath);
1150         API_FCT(get_texturepath);
1151         API_FCT(get_texturepath_share);
1152         API_FCT(get_cache_path);
1153         API_FCT(create_dir);
1154         API_FCT(delete_dir);
1155         API_FCT(copy_dir);
1156         //API_FCT(extract_zip); //TODO remove dependency to GuiEngine
1157         API_FCT(may_modify_path);
1158         API_FCT(download_file);
1159         //API_FCT(gettext); (gettext lib isn't threadsafe)
1160 }