src/main.cpp

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010-2011 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 General Public License as published by
   7 the Free Software Foundation; either version 2 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 General Public License for more details.
  14
  15 You should have received a copy of the GNU 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 #ifdef NDEBUG
  21         /*#ifdef _WIN32
  22                 #pragma message ("Disabling unit tests")
  23         #else
  24                 #warning "Disabling unit tests"
  25         #endif*/
  26         // Disable unit tests
  27         #define ENABLE_TESTS 0
  28 #else
  29         // Enable unit tests
  30         #define ENABLE_TESTS 1
  31 #endif
  32
  33 #ifdef _MSC_VER
  34 #ifndef SERVER // Dedicated server isn't linked with Irrlicht
  35         #pragma comment(lib, "Irrlicht.lib")
  36         // This would get rid of the console window
  37         //#pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup")
  38 #endif
  39         #pragma comment(lib, "zlibwapi.lib")
  40         #pragma comment(lib, "Shell32.lib")
  41 #endif
  42
  43 #include "irrlicht.h" // createDevice
  44
  45 #include "main.h"
  46 #include "mainmenumanager.h"
  47 #include <iostream>
  48 #include <fstream>
  49 #include <locale.h>
  50 #include "common_irrlicht.h"
  51 #include "debug.h"
  52 #include "test.h"
  53 #include "server.h"
  54 #include "constants.h"
  55 #include "porting.h"
  56 #include "gettime.h"
  57 #include "guiMessageMenu.h"
  58 #include "filesys.h"
  59 #include "config.h"
  60 #include "guiMainMenu.h"
  61 #include "game.h"
  62 #include "keycode.h"
  63 #include "tile.h"
  64 #include "chat.h"
  65 #include "defaultsettings.h"
  66 #include "gettext.h"
  67 #include "settings.h"
  68 #include "profiler.h"
  69 #include "log.h"
  70 #include "mods.h"
  71 #include "utility_string.h"
  72
  73 /*
  74         Settings.
  75         These are loaded from the config file.
  76 */
  77 Settings main_settings;
  78 Settings *g_settings = &main_settings;
  79
  80 // Global profiler
  81 Profiler main_profiler;
  82 Profiler *g_profiler = &main_profiler;
  83
  84 /*
  85         Debug streams
  86 */
  87
  88 // Connection
  89 std::ostream *dout_con_ptr = &dummyout;
  90 std::ostream *derr_con_ptr = &verbosestream;
  91 //std::ostream *dout_con_ptr = &infostream;
  92 //std::ostream *derr_con_ptr = &errorstream;
  93
  94 // Server
  95 std::ostream *dout_server_ptr = &infostream;
  96 std::ostream *derr_server_ptr = &errorstream;
  97
  98 // Client
  99 std::ostream *dout_client_ptr = &infostream;
 100 std::ostream *derr_client_ptr = &errorstream;
 101
 102 #ifndef SERVER
 103 /*
 104         Random stuff
 105 */
 106
 107 /* mainmenumanager.h */
 108
 109 gui::IGUIEnvironment* guienv = NULL;
 110 gui::IGUIStaticText *guiroot = NULL;
 111 MainMenuManager g_menumgr;
 112
 113 bool noMenuActive()
 114 {
 115         return (g_menumgr.menuCount() == 0);
 116 }
 117
 118 // Passed to menus to allow disconnecting and exiting
 119 MainGameCallback *g_gamecallback = NULL;
 120 #endif
 121
 122 /*
 123         gettime.h implementation
 124 */
 125
 126 #ifdef SERVER
 127
 128 u32 getTimeMs()
 129 {
 130         /* Use imprecise system calls directly (from porting.h) */
 131         return porting::getTimeMs();
 132 }
 133
 134 #else
 135
 136 // A small helper class
 137 class TimeGetter
 138 {
 139 public:
 140         virtual u32 getTime() = 0;
 141 };
 142
 143 // A precise irrlicht one
 144 class IrrlichtTimeGetter: public TimeGetter
 145 {
 146 public:
 147         IrrlichtTimeGetter(IrrlichtDevice *device):
 148                 m_device(device)
 149         {}
 150         u32 getTime()
 151         {
 152                 if(m_device == NULL)
 153                         return 0;
 154                 return m_device->getTimer()->getRealTime();
 155         }
 156 private:
 157         IrrlichtDevice *m_device;
 158 };
 159 // Not so precise one which works without irrlicht
 160 class SimpleTimeGetter: public TimeGetter
 161 {
 162 public:
 163         u32 getTime()
 164         {
 165                 return porting::getTimeMs();
 166         }
 167 };
 168
 169 // A pointer to a global instance of the time getter
 170 // TODO: why?
 171 TimeGetter *g_timegetter = NULL;
 172
 173 u32 getTimeMs()
 174 {
 175         if(g_timegetter == NULL)
 176                 return 0;
 177         return g_timegetter->getTime();
 178 }
 179
 180 #endif
 181
 182 class StderrLogOutput: public ILogOutput
 183 {
 184 public:
 185         /* line: Full line with timestamp, level and thread */
 186         void printLog(const std::string &line)
 187         {
 188                 std::cerr<<line<<std::endl;
 189         }
 190 } main_stderr_log_out;
 191
 192 class DstreamNoStderrLogOutput: public ILogOutput
 193 {
 194 public:
 195         /* line: Full line with timestamp, level and thread */
 196         void printLog(const std::string &line)
 197         {
 198                 dstream_no_stderr<<line<<std::endl;
 199         }
 200 } main_dstream_no_stderr_log_out;
 201
 202 #ifndef SERVER
 203
 204 /*
 205         Event handler for Irrlicht
 206
 207         NOTE: Everything possible should be moved out from here,
 208               probably to InputHandler and the_game
 209 */
 210
 211 class MyEventReceiver : public IEventReceiver
 212 {
 213 public:
 214         // This is the one method that we have to implement
 215         virtual bool OnEvent(const SEvent& event)
 216         {
 217                 /*
 218                         React to nothing here if a menu is active
 219                 */
 220                 if(noMenuActive() == false)
 221                 {
 222                         return false;
 223                 }
 224
 225                 // Remember whether each key is down or up
 226                 if(event.EventType == irr::EET_KEY_INPUT_EVENT)
 227                 {
 228                         if(event.KeyInput.PressedDown) {
 229                                 keyIsDown.set(event.KeyInput);
 230                                 keyWasDown.set(event.KeyInput);
 231                         } else {
 232                                 keyIsDown.unset(event.KeyInput);
 233                         }
 234                 }
 235
 236                 if(event.EventType == irr::EET_MOUSE_INPUT_EVENT)
 237                 {
 238                         if(noMenuActive() == false)
 239                         {
 240                                 left_active = false;
 241                                 middle_active = false;
 242                                 right_active = false;
 243                         }
 244                         else
 245                         {
 246                                 left_active = event.MouseInput.isLeftPressed();
 247                                 middle_active = event.MouseInput.isMiddlePressed();
 248                                 right_active = event.MouseInput.isRightPressed();
 249
 250                                 if(event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)
 251                                 {
 252                                         leftclicked = true;
 253                                 }
 254                                 if(event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN)
 255                                 {
 256                                         rightclicked = true;
 257                                 }
 258                                 if(event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP)
 259                                 {
 260                                         leftreleased = true;
 261                                 }
 262                                 if(event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP)
 263                                 {
 264                                         rightreleased = true;
 265                                 }
 266                                 if(event.MouseInput.Event == EMIE_MOUSE_WHEEL)
 267                                 {
 268                                         mouse_wheel += event.MouseInput.Wheel;
 269                                 }
 270                         }
 271                 }
 272
 273                 return false;
 274         }
 275
 276         bool IsKeyDown(const KeyPress &keyCode) const
 277         {
 278                 return keyIsDown[keyCode];
 279         }
 280
 281         // Checks whether a key was down and resets the state
 282         bool WasKeyDown(const KeyPress &keyCode)
 283         {
 284                 bool b = keyWasDown[keyCode];
 285                 if (b)
 286                         keyWasDown.unset(keyCode);
 287                 return b;
 288         }
 289
 290         s32 getMouseWheel()
 291         {
 292                 s32 a = mouse_wheel;
 293                 mouse_wheel = 0;
 294                 return a;
 295         }
 296
 297         void clearInput()
 298         {
 299                 keyIsDown.clear();
 300                 keyWasDown.clear();
 301
 302                 leftclicked = false;
 303                 rightclicked = false;
 304                 leftreleased = false;
 305                 rightreleased = false;
 306
 307                 left_active = false;
 308                 middle_active = false;
 309                 right_active = false;
 310
 311                 mouse_wheel = 0;
 312         }
 313
 314         MyEventReceiver()
 315         {
 316                 clearInput();
 317         }
 318
 319         bool leftclicked;
 320         bool rightclicked;
 321         bool leftreleased;
 322         bool rightreleased;
 323
 324         bool left_active;
 325         bool middle_active;
 326         bool right_active;
 327
 328         s32 mouse_wheel;
 329
 330 private:
 331         IrrlichtDevice *m_device;
 332
 333         // The current state of keys
 334         KeyList keyIsDown;
 335         // Whether a key has been pressed or not
 336         KeyList keyWasDown;
 337 };
 338
 339 /*
 340         Separated input handler
 341 */
 342
 343 class RealInputHandler : public InputHandler
 344 {
 345 public:
 346         RealInputHandler(IrrlichtDevice *device, MyEventReceiver *receiver):
 347                 m_device(device),
 348                 m_receiver(receiver)
 349         {
 350         }
 351         virtual bool isKeyDown(const KeyPress &keyCode)
 352         {
 353                 return m_receiver->IsKeyDown(keyCode);
 354         }
 355         virtual bool wasKeyDown(const KeyPress &keyCode)
 356         {
 357                 return m_receiver->WasKeyDown(keyCode);
 358         }
 359         virtual v2s32 getMousePos()
 360         {
 361                 return m_device->getCursorControl()->getPosition();
 362         }
 363         virtual void setMousePos(s32 x, s32 y)
 364         {
 365                 m_device->getCursorControl()->setPosition(x, y);
 366         }
 367
 368         virtual bool getLeftState()
 369         {
 370                 return m_receiver->left_active;
 371         }
 372         virtual bool getRightState()
 373         {
 374                 return m_receiver->right_active;
 375         }
 376
 377         virtual bool getLeftClicked()
 378         {
 379                 return m_receiver->leftclicked;
 380         }
 381         virtual bool getRightClicked()
 382         {
 383                 return m_receiver->rightclicked;
 384         }
 385         virtual void resetLeftClicked()
 386         {
 387                 m_receiver->leftclicked = false;
 388         }
 389         virtual void resetRightClicked()
 390         {
 391                 m_receiver->rightclicked = false;
 392         }
 393
 394         virtual bool getLeftReleased()
 395         {
 396                 return m_receiver->leftreleased;
 397         }
 398         virtual bool getRightReleased()
 399         {
 400                 return m_receiver->rightreleased;
 401         }
 402         virtual void resetLeftReleased()
 403         {
 404                 m_receiver->leftreleased = false;
 405         }
 406         virtual void resetRightReleased()
 407         {
 408                 m_receiver->rightreleased = false;
 409         }
 410
 411         virtual s32 getMouseWheel()
 412         {
 413                 return m_receiver->getMouseWheel();
 414         }
 415
 416         void clear()
 417         {
 418                 m_receiver->clearInput();
 419         }
 420 private:
 421         IrrlichtDevice *m_device;
 422         MyEventReceiver *m_receiver;
 423 };
 424
 425 class RandomInputHandler : public InputHandler
 426 {
 427 public:
 428         RandomInputHandler()
 429         {
 430                 leftdown = false;
 431                 rightdown = false;
 432                 leftclicked = false;
 433                 rightclicked = false;
 434                 leftreleased = false;
 435                 rightreleased = false;
 436                 keydown.clear();
 437         }
 438         virtual bool isKeyDown(const KeyPress &keyCode)
 439         {
 440                 return keydown[keyCode];
 441         }
 442         virtual bool wasKeyDown(const KeyPress &keyCode)
 443         {
 444                 return false;
 445         }
 446         virtual v2s32 getMousePos()
 447         {
 448                 return mousepos;
 449         }
 450         virtual void setMousePos(s32 x, s32 y)
 451         {
 452                 mousepos = v2s32(x,y);
 453         }
 454
 455         virtual bool getLeftState()
 456         {
 457                 return leftdown;
 458         }
 459         virtual bool getRightState()
 460         {
 461                 return rightdown;
 462         }
 463
 464         virtual bool getLeftClicked()
 465         {
 466                 return leftclicked;
 467         }
 468         virtual bool getRightClicked()
 469         {
 470                 return rightclicked;
 471         }
 472         virtual void resetLeftClicked()
 473         {
 474                 leftclicked = false;
 475         }
 476         virtual void resetRightClicked()
 477         {
 478                 rightclicked = false;
 479         }
 480
 481         virtual bool getLeftReleased()
 482         {
 483                 return leftreleased;
 484         }
 485         virtual bool getRightReleased()
 486         {
 487                 return rightreleased;
 488         }
 489         virtual void resetLeftReleased()
 490         {
 491                 leftreleased = false;
 492         }
 493         virtual void resetRightReleased()
 494         {
 495                 rightreleased = false;
 496         }
 497
 498         virtual s32 getMouseWheel()
 499         {
 500                 return 0;
 501         }
 502
 503         virtual void step(float dtime)
 504         {
 505                 {
 506                         static float counter1 = 0;
 507                         counter1 -= dtime;
 508                         if(counter1 < 0.0)
 509                         {
 510                                 counter1 = 0.1*Rand(1, 40);
 511                                 keydown.toggle(getKeySetting("keymap_jump"));
 512                         }
 513                 }
 514                 {
 515                         static float counter1 = 0;
 516                         counter1 -= dtime;
 517                         if(counter1 < 0.0)
 518                         {
 519                                 counter1 = 0.1*Rand(1, 40);
 520                                 keydown.toggle(getKeySetting("keymap_special1"));
 521                         }
 522                 }
 523                 {
 524                         static float counter1 = 0;
 525                         counter1 -= dtime;
 526                         if(counter1 < 0.0)
 527                         {
 528                                 counter1 = 0.1*Rand(1, 40);
 529                                 keydown.toggle(getKeySetting("keymap_forward"));
 530                         }
 531                 }
 532                 {
 533                         static float counter1 = 0;
 534                         counter1 -= dtime;
 535                         if(counter1 < 0.0)
 536                         {
 537                                 counter1 = 0.1*Rand(1, 40);
 538                                 keydown.toggle(getKeySetting("keymap_left"));
 539                         }
 540                 }
 541                 {
 542                         static float counter1 = 0;
 543                         counter1 -= dtime;
 544                         if(counter1 < 0.0)
 545                         {
 546                                 counter1 = 0.1*Rand(1, 20);
 547                                 mousespeed = v2s32(Rand(-20,20), Rand(-15,20));
 548                         }
 549                 }
 550                 {
 551                         static float counter1 = 0;
 552                         counter1 -= dtime;
 553                         if(counter1 < 0.0)
 554                         {
 555                                 counter1 = 0.1*Rand(1, 30);
 556                                 leftdown = !leftdown;
 557                                 if(leftdown)
 558                                         leftclicked = true;
 559                                 if(!leftdown)
 560                                         leftreleased = true;
 561                         }
 562                 }
 563                 {
 564                         static float counter1 = 0;
 565                         counter1 -= dtime;
 566                         if(counter1 < 0.0)
 567                         {
 568                                 counter1 = 0.1*Rand(1, 15);
 569                                 rightdown = !rightdown;
 570                                 if(rightdown)
 571                                         rightclicked = true;
 572                                 if(!rightdown)
 573                                         rightreleased = true;
 574                         }
 575                 }
 576                 mousepos += mousespeed;
 577         }
 578
 579         s32 Rand(s32 min, s32 max)
 580         {
 581                 return (myrand()%(max-min+1))+min;
 582         }
 583 private:
 584         KeyList keydown;
 585         v2s32 mousepos;
 586         v2s32 mousespeed;
 587         bool leftdown;
 588         bool rightdown;
 589         bool leftclicked;
 590         bool rightclicked;
 591         bool leftreleased;
 592         bool rightreleased;
 593 };
 594
 595 void drawMenuBackground(video::IVideoDriver* driver)
 596 {
 597         core::dimension2d<u32> screensize = driver->getScreenSize();
 598
 599         video::ITexture *bgtexture =
 600                         driver->getTexture(getTexturePath("menubg.png").c_str());
 601         if(bgtexture)
 602         {
 603                 s32 scaledsize = 128;
 604
 605                 // The important difference between destsize and screensize is
 606                 // that destsize is rounded to whole scaled pixels.
 607                 // These formulas use component-wise multiplication and division of v2u32.
 608                 v2u32 texturesize = bgtexture->getSize();
 609                 v2u32 sourcesize = texturesize * screensize / scaledsize + v2u32(1,1);
 610                 v2u32 destsize = scaledsize * sourcesize / texturesize;
 611
 612                 // Default texture wrapping mode in Irrlicht is ETC_REPEAT.
 613                 driver->draw2DImage(bgtexture,
 614                         core::rect<s32>(0, 0, destsize.X, destsize.Y),
 615                         core::rect<s32>(0, 0, sourcesize.X, sourcesize.Y),
 616                         NULL, NULL, true);
 617         }
 618
 619         video::ITexture *logotexture =
 620                         driver->getTexture(getTexturePath("menulogo.png").c_str());
 621         if(logotexture)
 622         {
 623                 v2s32 logosize(logotexture->getOriginalSize().Width,
 624                                 logotexture->getOriginalSize().Height);
 625                 logosize *= 4;
 626
 627                 video::SColor bgcolor(255,50,50,50);
 628                 core::rect<s32> bgrect(0, screensize.Height-logosize.Y-20,
 629                                 screensize.Width, screensize.Height);
 630                 driver->draw2DRectangle(bgcolor, bgrect, NULL);
 631
 632                 core::rect<s32> rect(0,0,logosize.X,logosize.Y);
 633                 rect += v2s32(screensize.Width/2,screensize.Height-10-logosize.Y);
 634                 rect -= v2s32(logosize.X/2, 0);
 635                 driver->draw2DImage(logotexture, rect,
 636                         core::rect<s32>(core::position2d<s32>(0,0),
 637                         core::dimension2di(logotexture->getSize())),
 638                         NULL, NULL, true);
 639         }
 640 }
 641
 642 #endif
 643
 644 // These are defined global so that they're not optimized too much.
 645 // Can't change them to volatile.
 646 s16 temp16;
 647 f32 tempf;
 648 v3f tempv3f1;
 649 v3f tempv3f2;
 650 std::string tempstring;
 651 std::string tempstring2;
 652
 653 void SpeedTests()
 654 {
 655         {
 656                 infostream<<"The following test should take around 20ms."<<std::endl;
 657                 TimeTaker timer("Testing std::string speed");
 658                 const u32 jj = 10000;
 659                 for(u32 j=0; j<jj; j++)
 660                 {
 661                         tempstring = "";
 662                         tempstring2 = "";
 663                         const u32 ii = 10;
 664                         for(u32 i=0; i<ii; i++){
 665                                 tempstring2 += "asd";
 666                         }
 667                         for(u32 i=0; i<ii+1; i++){
 668                                 tempstring += "asd";
 669                                 if(tempstring == tempstring2)
 670                                         break;
 671                         }
 672                 }
 673         }
 674
 675         infostream<<"All of the following tests should take around 100ms each."
 676                         <<std::endl;
 677
 678         {
 679                 TimeTaker timer("Testing floating-point conversion speed");
 680                 tempf = 0.001;
 681                 for(u32 i=0; i<4000000; i++){
 682                         temp16 += tempf;
 683                         tempf += 0.001;
 684                 }
 685         }
 686
 687         {
 688                 TimeTaker timer("Testing floating-point vector speed");
 689
 690                 tempv3f1 = v3f(1,2,3);
 691                 tempv3f2 = v3f(4,5,6);
 692                 for(u32 i=0; i<10000000; i++){
 693                         tempf += tempv3f1.dotProduct(tempv3f2);
 694                         tempv3f2 += v3f(7,8,9);
 695                 }
 696         }
 697
 698         {
 699                 TimeTaker timer("Testing core::map speed");
 700
 701                 core::map<v2s16, f32> map1;
 702                 tempf = -324;
 703                 const s16 ii=300;
 704                 for(s16 y=0; y<ii; y++){
 705                         for(s16 x=0; x<ii; x++){
 706                                 map1.insert(v2s16(x,y), tempf);
 707                                 tempf += 1;
 708                         }
 709                 }
 710                 for(s16 y=ii-1; y>=0; y--){
 711                         for(s16 x=0; x<ii; x++){
 712                                 tempf = map1[v2s16(x,y)];
 713                         }
 714                 }
 715         }
 716
 717         {
 718                 infostream<<"Around 5000/ms should do well here."<<std::endl;
 719                 TimeTaker timer("Testing mutex speed");
 720
 721                 JMutex m;
 722                 m.Init();
 723                 u32 n = 0;
 724                 u32 i = 0;
 725                 do{
 726                         n += 10000;
 727                         for(; i<n; i++){
 728                                 m.Lock();
 729                                 m.Unlock();
 730                         }
 731                 }
 732                 // Do at least 10ms
 733                 while(timer.getTime() < 10);
 734
 735                 u32 dtime = timer.stop();
 736                 u32 per_ms = n / dtime;
 737                 infostream<<"Done. "<<dtime<<"ms, "
 738                                 <<per_ms<<"/ms"<<std::endl;
 739         }
 740 }
 741
 742 int main(int argc, char *argv[])
 743 {
 744         /*
 745                 Initialization
 746         */
 747
 748         log_add_output_maxlev(&main_stderr_log_out, LMT_ACTION);
 749         log_add_output_all_levs(&main_dstream_no_stderr_log_out);
 750
 751         log_register_thread("main");
 752
 753         // Set locale. This is for forcing '.' as the decimal point.
 754         std::locale::global(std::locale("C"));
 755         // This enables printing all characters in bitmap font
 756         setlocale(LC_CTYPE, "en_US");
 757
 758         /*
 759                 Parse command line
 760         */
 761
 762         // List all allowed options
 763         core::map<std::string, ValueSpec> allowed_options;
 764         allowed_options.insert("help", ValueSpec(VALUETYPE_FLAG,
 765                         "Show allowed options"));
 766         allowed_options.insert("config", ValueSpec(VALUETYPE_STRING,
 767                         "Load configuration from specified file"));
 768         allowed_options.insert("port", ValueSpec(VALUETYPE_STRING,
 769                         "Set network port (UDP) to use"));
 770         allowed_options.insert("disable-unittests", ValueSpec(VALUETYPE_FLAG,
 771                         "Disable unit tests"));
 772         allowed_options.insert("enable-unittests", ValueSpec(VALUETYPE_FLAG,
 773                         "Enable unit tests"));
 774         allowed_options.insert("map-dir", ValueSpec(VALUETYPE_STRING,
 775                         "Map directory (where everything in the world is stored)"));
 776         allowed_options.insert("info-on-stderr", ValueSpec(VALUETYPE_FLAG,
 777                         "Print more information to console (deprecated; use --verbose)"));
 778         allowed_options.insert("verbose", ValueSpec(VALUETYPE_FLAG,
 779                         "Print more information to console"));
 780 #ifndef SERVER
 781         allowed_options.insert("speedtests", ValueSpec(VALUETYPE_FLAG,
 782                         "Run speed tests"));
 783         allowed_options.insert("address", ValueSpec(VALUETYPE_STRING,
 784                         "Address to connect to"));
 785         allowed_options.insert("random-input", ValueSpec(VALUETYPE_FLAG,
 786                         "Enable random user input, for testing"));
 787         allowed_options.insert("server", ValueSpec(VALUETYPE_FLAG,
 788                         "Run server directly"));
 789 #endif
 790
 791         Settings cmd_args;
 792
 793         bool ret = cmd_args.parseCommandLine(argc, argv, allowed_options);
 794
 795         if(ret == false || cmd_args.getFlag("help"))
 796         {
 797                 dstream<<"Allowed options:"<<std::endl;
 798                 for(core::map<std::string, ValueSpec>::Iterator
 799                                 i = allowed_options.getIterator();
 800                                 i.atEnd() == false; i++)
 801                 {
 802                         std::ostringstream os1(std::ios::binary);
 803                         os1<<"  --"<<i.getNode()->getKey();
 804                         if(i.getNode()->getValue().type == VALUETYPE_FLAG)
 805                                 {}
 806                         else
 807                                 os1<<" <value>";
 808                         dstream<<padStringRight(os1.str(), 24);
 809
 810                         if(i.getNode()->getValue().help != NULL)
 811                                 dstream<<i.getNode()->getValue().help;
 812                         dstream<<std::endl;
 813                 }
 814
 815                 return cmd_args.getFlag("help") ? 0 : 1;
 816         }
 817
 818         /*
 819                 Low-level initialization
 820         */
 821
 822         if(cmd_args.getFlag("verbose") ||
 823                         cmd_args.getFlag("info-on-stderr") ||
 824                         cmd_args.getFlag("speedtests"))
 825                 log_add_output(&main_stderr_log_out, LMT_INFO);
 826
 827         porting::signal_handler_init();
 828         bool &kill = *porting::signal_handler_killstatus();
 829
 830         porting::initializePaths();
 831
 832         // Create user data directory
 833         fs::CreateDir(porting::path_user);
 834
 835         init_gettext((porting::path_share+DIR_DELIM+".."+DIR_DELIM+"locale").c_str());
 836
 837         // Initialize debug streams
 838 #ifdef RUN_IN_PLACE
 839         std::string debugfile = DEBUGFILE;
 840 #else
 841         std::string debugfile = porting::path_user+DIR_DELIM+DEBUGFILE;
 842 #endif
 843         bool disable_stderr = false;
 844         debugstreams_init(disable_stderr, debugfile.c_str());
 845         // Initialize debug stacks
 846         debug_stacks_init();
 847
 848         DSTACK(__FUNCTION_NAME);
 849
 850         dstream<<"path_share = "<<porting::path_share<<std::endl;
 851         dstream<<"path_user  = "<<porting::path_user<<std::endl;
 852
 853         // Debug handler
 854         BEGIN_DEBUG_EXCEPTION_HANDLER
 855
 856         // Print startup message
 857         actionstream<<PROJECT_NAME<<
 858                         " with SER_FMT_VER_HIGHEST="<<(int)SER_FMT_VER_HIGHEST
 859                         <<", "<<BUILD_INFO
 860                         <<std::endl;
 861
 862         /*
 863                 Basic initialization
 864         */
 865
 866         // Initialize default settings
 867         set_default_settings(g_settings);
 868
 869         // Initialize sockets
 870         sockets_init();
 871         atexit(sockets_cleanup);
 872
 873         /*
 874                 Read config file
 875         */
 876
 877         // Path of configuration file in use
 878         std::string configpath = "";
 879
 880         if(cmd_args.exists("config"))
 881         {
 882                 bool r = g_settings->readConfigFile(cmd_args.get("config").c_str());
 883                 if(r == false)
 884                 {
 885                         errorstream<<"Could not read configuration from \""
 886                                         <<cmd_args.get("config")<<"\""<<std::endl;
 887                         return 1;
 888                 }
 889                 configpath = cmd_args.get("config");
 890         }
 891         else
 892         {
 893                 core::array<std::string> filenames;
 894                 filenames.push_back(porting::path_user +
 895                                 DIR_DELIM + "minetest.conf");
 896                 // Legacy configuration file location
 897                 filenames.push_back(porting::path_user +
 898                                 DIR_DELIM + ".." + DIR_DELIM + "minetest.conf");
 899 #ifdef RUN_IN_PLACE
 900                 // Try also from a lower level (to aid having the same configuration
 901                 // for many RUN_IN_PLACE installs)
 902                 filenames.push_back(porting::path_user +
 903                                 DIR_DELIM + ".." + DIR_DELIM + ".." + DIR_DELIM + "minetest.conf");
 904 #endif
 905
 906                 for(u32 i=0; i<filenames.size(); i++)
 907                 {
 908                         bool r = g_settings->readConfigFile(filenames[i].c_str());
 909                         if(r)
 910                         {
 911                                 configpath = filenames[i];
 912                                 break;
 913                         }
 914                 }
 915
 916                 // If no path found, use the first one (menu creates the file)
 917                 if(configpath == "")
 918                         configpath = filenames[0];
 919         }
 920
 921         // Initialize random seed
 922         srand(time(0));
 923         mysrand(time(0));
 924
 925         /*
 926                 Run unit tests
 927         */
 928
 929         if((ENABLE_TESTS && cmd_args.getFlag("disable-unittests") == false)
 930                         || cmd_args.getFlag("enable-unittests") == true)
 931         {
 932                 run_tests();
 933         }
 934
 935         /*
 936                 Game parameters
 937         */
 938
 939         // Port
 940         u16 port = 30000;
 941         if(cmd_args.exists("port"))
 942                 port = cmd_args.getU16("port");
 943         else if(g_settings->exists("port"))
 944                 port = g_settings->getU16("port");
 945         if(port == 0)
 946                 port = 30000;
 947
 948         // Map directory
 949         std::string map_dir = porting::path_user + DIR_DELIM + "server" + DIR_DELIM + "worlds" + DIR_DELIM + "world";
 950         if(cmd_args.exists("map-dir"))
 951                 map_dir = cmd_args.get("map-dir");
 952         else if(g_settings->exists("map-dir"))
 953                 map_dir = g_settings->get("map-dir");
 954         else{
 955                 // No map-dir option was specified.
 956                 // Check if the world is found from the default directory, and if
 957                 // not, see if the legacy world directory exists.
 958                 std::string legacy_map_dir = porting::path_user+DIR_DELIM+".."+DIR_DELIM+"world";
 959                 if(!fs::PathExists(map_dir) && fs::PathExists(legacy_map_dir)){
 960                         errorstream<<"Warning: Using legacy world directory \""
 961                                         <<legacy_map_dir<<"\""<<std::endl;
 962                         map_dir = legacy_map_dir;
 963                 }
 964         }
 965
 966         // Run dedicated server if asked to or no other option
 967 #ifdef SERVER
 968         bool run_dedicated_server = true;
 969 #else
 970         bool run_dedicated_server = cmd_args.getFlag("server");
 971 #endif
 972         if(run_dedicated_server)
 973         {
 974                 DSTACK("Dedicated server branch");
 975
 976                 // Create time getter if built with Irrlicht
 977 #ifndef SERVER
 978                 g_timegetter = new SimpleTimeGetter();
 979 #endif
 980
 981                 // Create server
 982                 Server server(map_dir, configpath, "mesetint");
 983                 server.start(port);
 984
 985                 // Run server
 986                 dedicated_server_loop(server, kill);
 987
 988                 return 0;
 989         }
 990
 991 #ifndef SERVER // Exclude from dedicated server build
 992
 993         /*
 994                 More parameters
 995         */
 996
 997         // Address to connect to
 998         std::string address = "";
 999
1000         if(cmd_args.exists("address"))
1001         {
1002                 address = cmd_args.get("address");
1003         }
1004         else
1005         {
1006                 address = g_settings->get("address");
1007         }
1008
1009         std::string playername = g_settings->get("name");
1010
1011         /*
1012                 Device initialization
1013         */
1014
1015         // Resolution selection
1016
1017         bool fullscreen = false;
1018         u16 screenW = g_settings->getU16("screenW");
1019         u16 screenH = g_settings->getU16("screenH");
1020
1021         // Determine driver
1022
1023         video::E_DRIVER_TYPE driverType;
1024
1025         std::string driverstring = g_settings->get("video_driver");
1026
1027         if(driverstring == "null")
1028                 driverType = video::EDT_NULL;
1029         else if(driverstring == "software")
1030                 driverType = video::EDT_SOFTWARE;
1031         else if(driverstring == "burningsvideo")
1032                 driverType = video::EDT_BURNINGSVIDEO;
1033         else if(driverstring == "direct3d8")
1034                 driverType = video::EDT_DIRECT3D8;
1035         else if(driverstring == "direct3d9")
1036                 driverType = video::EDT_DIRECT3D9;
1037         else if(driverstring == "opengl")
1038                 driverType = video::EDT_OPENGL;
1039         else
1040         {
1041                 errorstream<<"WARNING: Invalid video_driver specified; defaulting "
1042                                 "to opengl"<<std::endl;
1043                 driverType = video::EDT_OPENGL;
1044         }
1045
1046         /*
1047                 Create device and exit if creation failed
1048         */
1049
1050         MyEventReceiver receiver;
1051
1052         IrrlichtDevice *device;
1053         device = createDevice(driverType,
1054                         core::dimension2d<u32>(screenW, screenH),
1055                         16, fullscreen, false, false, &receiver);
1056
1057         if (device == 0)
1058                 return 1; // could not create selected driver.
1059
1060         /*
1061                 Continue initialization
1062         */
1063
1064         video::IVideoDriver* driver = device->getVideoDriver();
1065
1066         // Disable mipmaps (because some of them look ugly)
1067         driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);
1068
1069         /*
1070                 This changes the minimum allowed number of vertices in a VBO.
1071                 Default is 500.
1072         */
1073         //driver->setMinHardwareBufferVertexCount(50);
1074
1075         // Set the window caption
1076         device->setWindowCaption(L"Minetest [Main Menu]");
1077
1078         // Create time getter
1079         g_timegetter = new IrrlichtTimeGetter(device);
1080
1081         // Create game callback for menus
1082         g_gamecallback = new MainGameCallback(device);
1083
1084         /*
1085                 Speed tests (done after irrlicht is loaded to get timer)
1086         */
1087         if(cmd_args.getFlag("speedtests"))
1088         {
1089                 dstream<<"Running speed tests"<<std::endl;
1090                 SpeedTests();
1091                 return 0;
1092         }
1093
1094         device->setResizable(true);
1095
1096         bool random_input = g_settings->getBool("random_input")
1097                         || cmd_args.getFlag("random-input");
1098         InputHandler *input = NULL;
1099         if(random_input)
1100                 input = new RandomInputHandler();
1101         else
1102                 input = new RealInputHandler(device, &receiver);
1103
1104         scene::ISceneManager* smgr = device->getSceneManager();
1105
1106         guienv = device->getGUIEnvironment();
1107         gui::IGUISkin* skin = guienv->getSkin();
1108         gui::IGUIFont* font = guienv->getFont(getTexturePath("fontlucida.png").c_str());
1109         if(font)
1110                 skin->setFont(font);
1111         else
1112                 errorstream<<"WARNING: Font file was not found."
1113                                 " Using default font."<<std::endl;
1114         // If font was not found, this will get us one
1115         font = skin->getFont();
1116         assert(font);
1117
1118         u32 text_height = font->getDimension(L"Hello, world!").Height;
1119         infostream<<"text_height="<<text_height<<std::endl;
1120
1121         //skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255,0,0,0));
1122         skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255,255,255,255));
1123         //skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(0,0,0,0));
1124         //skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(0,0,0,0));
1125         skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(255,0,0,0));
1126         skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(255,0,0,0));
1127
1128         /*
1129                 GUI stuff
1130         */
1131
1132         ChatBackend chat_backend;
1133
1134         /*
1135                 If an error occurs, this is set to something and the
1136                 menu-game loop is restarted. It is then displayed before
1137                 the menu.
1138         */
1139         std::wstring error_message = L"";
1140
1141         // The password entered during the menu screen,
1142         std::string password;
1143
1144         /*
1145                 Menu-game loop
1146         */
1147         while(device->run() && kill == false)
1148         {
1149
1150                 // This is used for catching disconnects
1151                 try
1152                 {
1153
1154                         /*
1155                                 Clear everything from the GUIEnvironment
1156                         */
1157                         guienv->clear();
1158
1159                         /*
1160                                 We need some kind of a root node to be able to add
1161                                 custom gui elements directly on the screen.
1162                                 Otherwise they won't be automatically drawn.
1163                         */
1164                         guiroot = guienv->addStaticText(L"",
1165                                         core::rect<s32>(0, 0, 10000, 10000));
1166
1167                         /*
1168                                 Out-of-game menu loop.
1169
1170                                 Loop quits when menu returns proper parameters.
1171                         */
1172                         while(kill == false)
1173                         {
1174                                 // Cursor can be non-visible when coming from the game
1175                                 device->getCursorControl()->setVisible(true);
1176                                 // Some stuff are left to scene manager when coming from the game
1177                                 // (map at least?)
1178                                 smgr->clear();
1179                                 // Reset or hide the debug gui texts
1180                                 /*guitext->setText(L"Minetest-c55");
1181                                 guitext2->setVisible(false);
1182                                 guitext_info->setVisible(false);
1183                                 guitext_chat->setVisible(false);*/
1184
1185                                 // Initialize menu data
1186                                 MainMenuData menudata;
1187                                 menudata.address = narrow_to_wide(address);
1188                                 menudata.name = narrow_to_wide(playername);
1189                                 menudata.port = narrow_to_wide(itos(port));
1190                                 menudata.fancy_trees = g_settings->getBool("new_style_leaves");
1191                                 menudata.smooth_lighting = g_settings->getBool("smooth_lighting");
1192                                 menudata.clouds_3d = g_settings->getBool("enable_3d_clouds");
1193                                 menudata.opaque_water = g_settings->getBool("opaque_water");
1194                                 menudata.creative_mode = g_settings->getBool("creative_mode");
1195                                 menudata.enable_damage = g_settings->getBool("enable_damage");
1196
1197                                 GUIMainMenu *menu =
1198                                                 new GUIMainMenu(guienv, guiroot, -1,
1199                                                         &g_menumgr, &menudata, g_gamecallback);
1200                                 menu->allowFocusRemoval(true);
1201
1202                                 if(error_message != L"")
1203                                 {
1204                                         errorstream<<"error_message = "
1205                                                         <<wide_to_narrow(error_message)<<std::endl;
1206
1207                                         GUIMessageMenu *menu2 =
1208                                                         new GUIMessageMenu(guienv, guiroot, -1,
1209                                                                 &g_menumgr, error_message.c_str());
1210                                         menu2->drop();
1211                                         error_message = L"";
1212                                 }
1213
1214                                 video::IVideoDriver* driver = device->getVideoDriver();
1215
1216                                 infostream<<"Created main menu"<<std::endl;
1217
1218                                 while(device->run() && kill == false)
1219                                 {
1220                                         if(menu->getStatus() == true)
1221                                                 break;
1222
1223                                         //driver->beginScene(true, true, video::SColor(255,0,0,0));
1224                                         driver->beginScene(true, true, video::SColor(255,128,128,128));
1225
1226                                         drawMenuBackground(driver);
1227
1228                                         guienv->drawAll();
1229
1230                                         driver->endScene();
1231
1232                                         // On some computers framerate doesn't seem to be
1233                                         // automatically limited
1234                                         sleep_ms(25);
1235                                 }
1236
1237                                 // Break out of menu-game loop to shut down cleanly
1238                                 if(device->run() == false || kill == true)
1239                                         break;
1240
1241                                 infostream<<"Dropping main menu"<<std::endl;
1242
1243                                 menu->drop();
1244
1245                                 // Delete map if requested
1246                                 if(menudata.delete_map)
1247                                 {
1248                                         bool r = fs::RecursiveDeleteContent(map_dir);
1249                                         if(r == false)
1250                                                 error_message = L"Delete failed";
1251                                         continue;
1252                                 }
1253
1254                                 playername = wide_to_narrow(menudata.name);
1255
1256                                 password = translatePassword(playername, menudata.password);
1257
1258                                 //infostream<<"Main: password hash: '"<<password<<"'"<<std::endl;
1259
1260                                 address = wide_to_narrow(menudata.address);
1261                                 int newport = stoi(wide_to_narrow(menudata.port));
1262                                 if(newport != 0)
1263                                         port = newport;
1264                                 g_settings->set("new_style_leaves", itos(menudata.fancy_trees));
1265                                 g_settings->set("smooth_lighting", itos(menudata.smooth_lighting));
1266                                 g_settings->set("enable_3d_clouds", itos(menudata.clouds_3d));
1267                                 g_settings->set("opaque_water", itos(menudata.opaque_water));
1268                                 g_settings->set("creative_mode", itos(menudata.creative_mode));
1269                                 g_settings->set("enable_damage", itos(menudata.enable_damage));
1270
1271                                 // NOTE: These are now checked server side; no need to do it
1272                                 //       here, so let's not do it here.
1273                                 /*// Check for valid parameters, restart menu if invalid.
1274                                 if(playername == "")
1275                                 {
1276                                         error_message = L"Name required.";
1277                                         continue;
1278                                 }
1279                                 // Check that name has only valid chars
1280                                 if(string_allowed(playername, PLAYERNAME_ALLOWED_CHARS)==false)
1281                                 {
1282                                         error_message = L"Characters allowed: "
1283                                                         +narrow_to_wide(PLAYERNAME_ALLOWED_CHARS);
1284                                         continue;
1285                                 }*/
1286
1287                                 // Save settings
1288                                 g_settings->set("name", playername);
1289                                 g_settings->set("address", address);
1290                                 g_settings->set("port", itos(port));
1291                                 // Update configuration file
1292                                 if(configpath != "")
1293                                         g_settings->updateConfigFile(configpath.c_str());
1294
1295                                 // Continue to game
1296                                 break;
1297                         }
1298
1299                         // Break out of menu-game loop to shut down cleanly
1300                         if(device->run() == false || kill == true)
1301                                 break;
1302
1303                         /*
1304                                 Run game
1305                         */
1306                         the_game(
1307                                 kill,
1308                                 random_input,
1309                                 input,
1310                                 device,
1311                                 font,
1312                                 map_dir,
1313                                 playername,
1314                                 password,
1315                                 address,
1316                                 port,
1317                                 error_message,
1318                                 configpath,
1319                                 chat_backend
1320                         );
1321
1322                 } //try
1323                 catch(con::PeerNotFoundException &e)
1324                 {
1325                         errorstream<<"Connection error (timed out?)"<<std::endl;
1326                         error_message = L"Connection error (timed out?)";
1327                 }
1328                 catch(SocketException &e)
1329                 {
1330                         errorstream<<"Socket error (port already in use?)"<<std::endl;
1331                         error_message = L"Socket error (port already in use?)";
1332                 }
1333                 catch(ModError &e)
1334                 {
1335                         errorstream<<e.what()<<std::endl;
1336                         error_message = narrow_to_wide(e.what()) + L"\nCheck debug.txt for details.";
1337                 }
1338 #ifdef NDEBUG
1339                 catch(std::exception &e)
1340                 {
1341                         std::string narrow_message = "Some exception, what()=\"";
1342                         narrow_message += e.what();
1343                         narrow_message += "\"";
1344                         errorstream<<narrow_message<<std::endl;
1345                         error_message = narrow_to_wide(narrow_message);
1346                 }
1347 #endif
1348
1349         } // Menu-game loop
1350
1351         delete input;
1352
1353         /*
1354                 In the end, delete the Irrlicht device.
1355         */
1356         device->drop();
1357
1358 #endif // !SERVER
1359
1360         // Update configuration file
1361         if(configpath != "")
1362                 g_settings->updateConfigFile(configpath.c_str());
1363
1364         END_DEBUG_EXCEPTION_HANDLER(errorstream)
1365
1366         debugstreams_deinit();
1367
1368         return 0;
1369 }
1370
1371 //END
1372