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 /*
  21 =============================== NOTES ==============================
  22 NOTE: Things starting with TODO are sometimes only suggestions.
  23
  24 NOTE: iostream.imbue(std::locale("C")) is very slow
  25 NOTE: Global locale is now set at initialization
  26
  27 NOTE: If VBO (EHM_STATIC) is used, remember to explicitly free the
  28       hardware buffer (it is not freed automatically)
  29
  30 NOTE: A random to-do list saved here as documentation:
  31 A list of "active blocks" in which stuff happens. (+=done)
  32         + Add a never-resetted game timer to the server
  33         + Add a timestamp value to blocks
  34         + The simple rule: All blocks near some player are "active"
  35         - Do stuff in real time in active blocks
  36                 + Handle objects
  37                 - Grow grass, delete leaves without a tree
  38                 - Spawn some mobs based on some rules
  39                 - Transform cobble to mossy cobble near water
  40                 - Run a custom script
  41                 - ...And all kinds of other dynamic stuff
  42         + Keep track of when a block becomes active and becomes inactive
  43         + When a block goes inactive:
  44                 + Store objects statically to block
  45                 + Store timer value as the timestamp
  46         + When a block goes active:
  47                 + Create active objects out of static objects
  48                 - Simulate the results of what would have happened if it would have
  49                   been active for all the time
  50                         - Grow a lot of grass and so on
  51         + Initially it is fine to send information about every active object
  52           to every player. Eventually it should be modified to only send info
  53           about the nearest ones.
  54                 + This was left to be done by the old system and it sends only the
  55                   nearest ones.
  56
  57 Vim conversion regexpes for moving to extended content type storage:
  58 %s/\(\.\|->\)d \([!=]=\)/\1getContent() \2/g
  59 %s/content_features(\([^.]*\)\.d)/content_features(\1)/g
  60 %s/\(\.\|->\)d = \([^;]*\);/\1setContent(\2);/g
  61 %s/\(getNodeNoExNoEmerge([^)]*)\)\.d/\1.getContent()/g
  62 %s/\(getNodeNoExNoEmerge(.*)\)\.d/\1.getContent()/g
  63 %s/\.d;/.getContent();/g
  64 %s/\(content_liquid\|content_flowing_liquid\|make_liquid_flowing\|content_pointable\)(\([^.]*\).d)/\1(\2.getContent())/g
  65 Other things to note:
  66 - node.d = node.param0 (only in raw serialization; use getContent() otherwise)
  67 - node.param = node.param1
  68 - node.dir = node.param2
  69 - content_walkable(node.d) etc should be changed to
  70   content_features(node).walkable etc
  71 - Also check for lines that store the result of getContent to a 8-bit
  72   variable and fix them (result of getContent() must be stored in
  73   content_t, which is 16-bit)
  74
  75 NOTE: Seeds in 1260:6c77e7dbfd29:
  76 5721858502589302589:
  77         Spawns you on a small sand island with a surface dungeon
  78 2983455799928051958:
  79         Enormous jungle + a surface dungeon at ~(250,0,0)
  80
  81 Old, wild and random suggestions that probably won't be done:
  82 -------------------------------------------------------------
  83
  84 SUGG: If player is on ground, mainly fetch ground-level blocks
  85
  86 SUGG: Expose Connection's seqnums and ACKs to server and client.
  87       - This enables saving many packets and making a faster connection
  88           - This also enables server to check if client has received the
  89             most recent block sent, for example.
  90 SUGG: Add a sane bandwidth throttling system to Connection
  91
  92 SUGG: More fine-grained control of client's dumping of blocks from
  93       memory
  94           - ...What does this mean in the first place?
  95
  96 SUGG: A map editing mode (similar to dedicated server mode)
  97
  98 SUGG: Transfer more blocks in a single packet
  99 SUGG: A blockdata combiner class, to which blocks are added and at
 100       destruction it sends all the stuff in as few packets as possible.
 101 SUGG: Make a PACKET_COMBINED which contains many subpackets. Utilize
 102       it by sending more stuff in a single packet.
 103           - Add a packet queue to RemoteClient, from which packets will be
 104             combined with object data packets
 105                 - This is not exactly trivial: the object data packets are
 106                   sometimes very big by themselves
 107           - This might not give much network performance gain though.
 108
 109 SUGG: Precalculate lighting translation table at runtime (at startup)
 110       - This is not doable because it is currently hand-made and not
 111             based on some mathematical function.
 112                 - Note: This has been changing lately
 113
 114 SUGG: A version number to blocks, which increments when the block is
 115       modified (node add/remove, water update, lighting update)
 116           - This can then be used to make sure the most recent version of
 117             a block has been sent to client, for example
 118
 119 SUGG: Make the amount of blocks sending to client and the total
 120           amount of blocks dynamically limited. Transferring blocks is the
 121           main network eater of this system, so it is the one that has
 122           to be throttled so that RTTs stay low.
 123
 124 SUGG: Meshes of blocks could be split into 6 meshes facing into
 125       different directions and then only those drawn that need to be
 126
 127 SUGG: Background music based on cellular automata?
 128       http://www.earslap.com/projectslab/otomata
 129
 130 SUGG: Simple light color information to air
 131
 132 SUGG: Server-side objects could be moved based on nodes to enable very
 133       lightweight operation and simple AI
 134         - Not practical; client would still need to show smooth movement.
 135
 136 SUGG: Make a system for pregenerating quick information for mapblocks, so
 137           that the client can show them as cubes before they are actually sent
 138           or even generated.
 139
 140 SUGG: Erosion simulation at map generation time
 141     - This might be plausible if larger areas of map were pregenerated
 142           without lighting (which is slow)
 143         - Simulate water flows, which would carve out dirt fast and
 144           then turn stone into gravel and sand and relocate it.
 145         - How about relocating minerals, too? Coal and gold in
 146           downstream sand and gravel would be kind of cool
 147           - This would need a better way of handling minerals, mainly
 148                 to have mineral content as a separate field. the first
 149                 parameter field is free for this.
 150         - Simulate rock falling from cliffs when water has removed
 151           enough solid rock from the bottom
 152
 153 SUGG: For non-mapgen FarMesh: Add a per-sector database to store surface
 154       stuff as simple flags/values
 155       - Light?
 156           - A building?
 157           And at some point make the server send this data to the client too,
 158           instead of referring to the noise functions
 159           - Ground height
 160           - Surface ground type
 161           - Trees?
 162
 163 Gaming ideas:
 164 -------------
 165
 166 - Aim for something like controlling a single dwarf in Dwarf Fortress
 167 - The player could go faster by a crafting a boat, or riding an animal
 168 - Random NPC traders. what else?
 169
 170 Game content:
 171 -------------
 172
 173 - When furnace is destroyed, move items to player's inventory
 174 - Add lots of stuff
 175 - Glass blocks
 176 - Growing grass, decaying leaves
 177         - This can be done in the active blocks I guess.
 178         - Lots of stuff can be done in the active blocks.
 179         - Uh, is there an active block list somewhere? I think not. Add it.
 180 - Breaking weak structures
 181         - This can probably be accomplished in the same way as grass
 182 - Player health points
 183         - When player dies, throw items on map (needs better item-on-map
 184           implementation)
 185 - Cobble to get mossy if near water
 186 - More slots in furnace source list, so that multiple ingredients
 187   are possible.
 188 - Keys to chests?
 189
 190 - The Treasure Guard; a big monster with a hammer
 191         - The hammer does great damage, shakes the ground and removes a block
 192         - You can drop on top of it, and have some time to attack there
 193           before he shakes you off
 194
 195 - Maybe the difficulty could come from monsters getting tougher in
 196   far-away places, and the player starting to need something from
 197   there when time goes by.
 198   - The player would have some of that stuff at the beginning, and
 199     would need new supplies of it when it runs out
 200
 201 - A bomb
 202 - A spread-items-on-map routine for the bomb, and for dying players
 203
 204 - Fighting:
 205   - Proper sword swing simulation
 206   - Player should get damage from colliding to a wall at high speed
 207
 208 Documentation:
 209 --------------
 210
 211 Build system / running:
 212 -----------------------
 213
 214 Networking and serialization:
 215 -----------------------------
 216
 217 SUGG: Fix address to be ipv6 compatible
 218
 219 User Interface:
 220 ---------------
 221
 222 Graphics:
 223 ---------
 224
 225 SUGG: Combine MapBlock's face caches to so big pieces that VBO
 226       can be used
 227       - That is >500 vertices
 228           - This is not easy; all the MapBlocks close to the player would
 229             still need to be drawn separately and combining the blocks
 230                 would have to happen in a background thread
 231
 232 SUGG: Make fetching sector's blocks more efficient when rendering
 233       sectors that have very large amounts of blocks (on client)
 234           - Is this necessary at all?
 235
 236 SUGG: Draw cubes in inventory directly with 3D drawing commands, so that
 237       animating them is easier.
 238
 239 SUGG: Option for enabling proper alpha channel for textures
 240
 241 TODO: Flowing water animation
 242
 243 TODO: A setting for enabling bilinear filtering for textures
 244
 245 TODO: Better control of draw_control.wanted_max_blocks
 246
 247 TODO: Further investigate the use of GPU lighting in addition to the
 248       current one
 249
 250 TODO: Artificial (night) light could be more yellow colored than sunlight.
 251       - This is technically doable.
 252           - Also the actual colors of the textures could be made less colorful
 253             in the dark but it's a bit more difficult.
 254
 255 SUGG: Somehow make the night less colorful
 256
 257 TODO: Occlusion culling
 258       - At the same time, move some of the renderMap() block choosing code
 259         to the same place as where the new culling happens.
 260       - Shoot some rays per frame and when ready, make a new list of
 261             blocks for usage of renderMap and give it a new pointer to it.
 262
 263 Configuration:
 264 --------------
 265
 266 Client:
 267 -------
 268
 269 TODO: Untie client network operations from framerate
 270       - Needs some input queues or something
 271           - This won't give much performance boost because calculating block
 272             meshes takes so long
 273
 274 SUGG: Make morning and evening transition more smooth and maybe shorter
 275
 276 TODO: Don't update all meshes always on single node changes, but
 277       check which ones should be updated
 278           - implement Map::updateNodeMeshes() and the usage of it
 279           - It will give almost always a 4x boost in mesh update performance.
 280
 281 - A weapon engine
 282
 283 - Tool/weapon visualization
 284
 285 FIXME: When disconnected to the menu, memory is not freed properly
 286
 287 TODO: Investigate how much the mesh generator thread gets used when
 288       transferring map data
 289
 290 Server:
 291 -------
 292
 293 SUGG: Make an option to the server to disable building and digging near
 294       the starting position
 295
 296 FIXME: Server sometimes goes into some infinite PeerNotFoundException loop
 297
 298 * Fix the problem with the server constantly saving one or a few
 299   blocks? List the first saved block, maybe it explains.
 300   - It is probably caused by oscillating water
 301   - TODO: Investigate if this still happens (this is a very old one)
 302 * Make a small history check to transformLiquids to detect and log
 303   continuous oscillations, in such detail that they can be fixed.
 304
 305 FIXME: The new optimized map sending doesn't sometimes send enough blocks
 306        from big caves and such
 307 FIXME: Block send distance configuration does not take effect for some reason
 308
 309 Environment:
 310 ------------
 311
 312 TODO: Add proper hooks to when adding and removing active blocks
 313
 314 TODO: Finish the ActiveBlockModifier stuff and use it for something
 315
 316 Objects:
 317 --------
 318
 319 TODO: Get rid of MapBlockObjects and use only ActiveObjects
 320         - Skipping the MapBlockObject data is nasty - there is no "total
 321           length" stored; have to make a SkipMBOs function which contains
 322           enough of the current code to skip them properly.
 323
 324 SUGG: MovingObject::move and Player::move are basically the same.
 325       combine them.
 326         - NOTE: This is a bit tricky because player has the sneaking ability
 327         - NOTE: Player::move is more up-to-date.
 328         - NOTE: There is a simple move implementation now in collision.{h,cpp}
 329         - NOTE: MovingObject will be deleted (MapBlockObject)
 330
 331 TODO: Add a long step function to objects that is called with the time
 332       difference when block activates
 333
 334 Map:
 335 ----
 336
 337 TODO: Mineral and ground material properties
 338       - This way mineral ground toughness can be calculated with just
 339             some formula, as well as tool strengths. Sounds too.
 340           - There are TODOs in appropriate files: material.h, content_mapnode.h
 341
 342 TODO: Flowing water to actually contain flow direction information
 343       - There is a space for this - it just has to be implemented.
 344
 345 TODO: Consider smoothening cave floors after generating them
 346
 347 TODO: Fix make_tree, make_* to use seed-position-consistent pseudorandom
 348           - delta also
 349
 350 Misc. stuff:
 351 ------------
 352 TODO: Make sure server handles removing grass when a block is placed (etc)
 353       - The client should not do it by itself
 354           - NOTE: I think nobody does it currently...
 355 TODO: Block cube placement around player's head
 356 TODO: Protocol version field
 357 TODO: Think about using same bits for material for fences and doors, for
 358           example
 359 TODO: Move mineral to param2, increment map serialization version, add
 360       conversion
 361
 362 SUGG: Restart irrlicht completely when coming back to main menu from game.
 363         - This gets rid of everything that is stored in irrlicht's caches.
 364         - This might be needed for texture pack selection in menu
 365
 366 TODO: Merge bahamada's audio stuff (clean patch available)
 367
 368 TODO: Move content_features to mapnode_content_features.{h,cpp} or so
 369
 370 TODO: Fix item use() stuff; dropping a stack of cooked rats and eating
 371       it gives 3 hearts and consumes all the rats.
 372
 373 Making it more portable:
 374 ------------------------
 375
 376 Stuff to do before release:
 377 ---------------------------
 378
 379 Fixes to the current release:
 380 -----------------------------
 381
 382 Stuff to do after release:
 383 ---------------------------
 384
 385 Doing currently:
 386 ----------------
 387
 388 ======================================================================
 389
 390 */
 391
 392 #ifdef NDEBUG
 393         #ifdef _WIN32
 394                 #pragma message ("Disabling unit tests")
 395         #else
 396                 #warning "Disabling unit tests"
 397         #endif
 398         // Disable unit tests
 399         #define ENABLE_TESTS 0
 400 #else
 401         // Enable unit tests
 402         #define ENABLE_TESTS 1
 403 #endif
 404
 405 #ifdef _MSC_VER
 406         #pragma comment(lib, "Irrlicht.lib")
 407         //#pragma comment(lib, "jthread.lib")
 408         #pragma comment(lib, "zlibwapi.lib")
 409         #pragma comment(lib, "Shell32.lib")
 410         // This would get rid of the console window
 411         //#pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup")
 412 #endif
 413
 414 #include "irrlicht.h" // createDevice
 415
 416 #include "main.h"
 417 #include "mainmenumanager.h"
 418 #include <iostream>
 419 #include <fstream>
 420 #include <locale.h>
 421 #include "common_irrlicht.h"
 422 #include "debug.h"
 423 #include "test.h"
 424 #include "server.h"
 425 #include "constants.h"
 426 #include "porting.h"
 427 #include "gettime.h"
 428 #include "guiMessageMenu.h"
 429 #include "filesys.h"
 430 #include "config.h"
 431 #include "guiMainMenu.h"
 432 #include "mineral.h"
 433 #include "materials.h"
 434 #include "game.h"
 435 #include "keycode.h"
 436 #include "tile.h"
 437 #include "defaultsettings.h"
 438 #include "gettext.h"
 439 #include "settings.h"
 440 #include "profiler.h"
 441 #include "log.h"
 442
 443 // This makes textures
 444 ITextureSource *g_texturesource = NULL;
 445
 446 /*
 447         Settings.
 448         These are loaded from the config file.
 449 */
 450 Settings main_settings;
 451 Settings *g_settings = &main_settings;
 452
 453 // Global profiler
 454 Profiler main_profiler;
 455 Profiler *g_profiler = &main_profiler;
 456
 457 /*
 458         Random stuff
 459 */
 460
 461 /*
 462         mainmenumanager.h
 463 */
 464
 465 gui::IGUIEnvironment* guienv = NULL;
 466 gui::IGUIStaticText *guiroot = NULL;
 467 MainMenuManager g_menumgr;
 468
 469 bool noMenuActive()
 470 {
 471         return (g_menumgr.menuCount() == 0);
 472 }
 473
 474 // Passed to menus to allow disconnecting and exiting
 475 MainGameCallback *g_gamecallback = NULL;
 476
 477 /*
 478         Debug streams
 479 */
 480
 481 // Connection
 482 std::ostream *dout_con_ptr = &dummyout;
 483 std::ostream *derr_con_ptr = &verbosestream;
 484 //std::ostream *dout_con_ptr = &infostream;
 485 //std::ostream *derr_con_ptr = &errorstream;
 486
 487 // Server
 488 std::ostream *dout_server_ptr = &infostream;
 489 std::ostream *derr_server_ptr = &errorstream;
 490
 491 // Client
 492 std::ostream *dout_client_ptr = &infostream;
 493 std::ostream *derr_client_ptr = &errorstream;
 494
 495 /*
 496         gettime.h implementation
 497 */
 498
 499 // A small helper class
 500 class TimeGetter
 501 {
 502 public:
 503         virtual u32 getTime() = 0;
 504 };
 505
 506 // A precise irrlicht one
 507 class IrrlichtTimeGetter: public TimeGetter
 508 {
 509 public:
 510         IrrlichtTimeGetter(IrrlichtDevice *device):
 511                 m_device(device)
 512         {}
 513         u32 getTime()
 514         {
 515                 if(m_device == NULL)
 516                         return 0;
 517                 return m_device->getTimer()->getRealTime();
 518         }
 519 private:
 520         IrrlichtDevice *m_device;
 521 };
 522 // Not so precise one which works without irrlicht
 523 class SimpleTimeGetter: public TimeGetter
 524 {
 525 public:
 526         u32 getTime()
 527         {
 528                 return porting::getTimeMs();
 529         }
 530 };
 531
 532 // A pointer to a global instance of the time getter
 533 // TODO: why?
 534 TimeGetter *g_timegetter = NULL;
 535
 536 u32 getTimeMs()
 537 {
 538         if(g_timegetter == NULL)
 539                 return 0;
 540         return g_timegetter->getTime();
 541 }
 542
 543 /*
 544         Event handler for Irrlicht
 545
 546         NOTE: Everything possible should be moved out from here,
 547               probably to InputHandler and the_game
 548 */
 549
 550 class MyEventReceiver : public IEventReceiver
 551 {
 552 public:
 553         // This is the one method that we have to implement
 554         virtual bool OnEvent(const SEvent& event)
 555         {
 556                 /*
 557                         React to nothing here if a menu is active
 558                 */
 559                 if(noMenuActive() == false)
 560                 {
 561                         return false;
 562                 }
 563
 564                 // Remember whether each key is down or up
 565                 if(event.EventType == irr::EET_KEY_INPUT_EVENT)
 566                 {
 567                         if(event.KeyInput.PressedDown) {
 568                                 keyIsDown.set(event.KeyInput);
 569                                 keyWasDown.set(event.KeyInput);
 570                         } else {
 571                                 keyIsDown.unset(event.KeyInput);
 572                         }
 573                 }
 574
 575                 if(event.EventType == irr::EET_MOUSE_INPUT_EVENT)
 576                 {
 577                         if(noMenuActive() == false)
 578                         {
 579                                 left_active = false;
 580                                 middle_active = false;
 581                                 right_active = false;
 582                         }
 583                         else
 584                         {
 585                                 left_active = event.MouseInput.isLeftPressed();
 586                                 middle_active = event.MouseInput.isMiddlePressed();
 587                                 right_active = event.MouseInput.isRightPressed();
 588
 589                                 if(event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)
 590                                 {
 591                                         leftclicked = true;
 592                                 }
 593                                 if(event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN)
 594                                 {
 595                                         rightclicked = true;
 596                                 }
 597                                 if(event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP)
 598                                 {
 599                                         leftreleased = true;
 600                                 }
 601                                 if(event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP)
 602                                 {
 603                                         rightreleased = true;
 604                                 }
 605                                 if(event.MouseInput.Event == EMIE_MOUSE_WHEEL)
 606                                 {
 607                                         mouse_wheel += event.MouseInput.Wheel;
 608                                 }
 609                         }
 610                 }
 611
 612                 return false;
 613         }
 614
 615         bool IsKeyDown(const KeyPress &keyCode) const
 616         {
 617                 return keyIsDown[keyCode];
 618         }
 619
 620         // Checks whether a key was down and resets the state
 621         bool WasKeyDown(const KeyPress &keyCode)
 622         {
 623                 bool b = keyWasDown[keyCode];
 624                 if (b)
 625                         keyWasDown.unset(keyCode);
 626                 return b;
 627         }
 628
 629         s32 getMouseWheel()
 630         {
 631                 s32 a = mouse_wheel;
 632                 mouse_wheel = 0;
 633                 return a;
 634         }
 635
 636         void clearInput()
 637         {
 638                 keyIsDown.clear();
 639                 keyWasDown.clear();
 640
 641                 leftclicked = false;
 642                 rightclicked = false;
 643                 leftreleased = false;
 644                 rightreleased = false;
 645
 646                 left_active = false;
 647                 middle_active = false;
 648                 right_active = false;
 649
 650                 mouse_wheel = 0;
 651         }
 652
 653         MyEventReceiver()
 654         {
 655                 clearInput();
 656         }
 657
 658         bool leftclicked;
 659         bool rightclicked;
 660         bool leftreleased;
 661         bool rightreleased;
 662
 663         bool left_active;
 664         bool middle_active;
 665         bool right_active;
 666
 667         s32 mouse_wheel;
 668
 669 private:
 670         IrrlichtDevice *m_device;
 671
 672         // The current state of keys
 673         KeyList keyIsDown;
 674         // Whether a key has been pressed or not
 675         KeyList keyWasDown;
 676 };
 677
 678 /*
 679         Separated input handler
 680 */
 681
 682 class RealInputHandler : public InputHandler
 683 {
 684 public:
 685         RealInputHandler(IrrlichtDevice *device, MyEventReceiver *receiver):
 686                 m_device(device),
 687                 m_receiver(receiver)
 688         {
 689         }
 690         virtual bool isKeyDown(const KeyPress &keyCode)
 691         {
 692                 return m_receiver->IsKeyDown(keyCode);
 693         }
 694         virtual bool wasKeyDown(const KeyPress &keyCode)
 695         {
 696                 return m_receiver->WasKeyDown(keyCode);
 697         }
 698         virtual v2s32 getMousePos()
 699         {
 700                 return m_device->getCursorControl()->getPosition();
 701         }
 702         virtual void setMousePos(s32 x, s32 y)
 703         {
 704                 m_device->getCursorControl()->setPosition(x, y);
 705         }
 706
 707         virtual bool getLeftState()
 708         {
 709                 return m_receiver->left_active;
 710         }
 711         virtual bool getRightState()
 712         {
 713                 return m_receiver->right_active;
 714         }
 715
 716         virtual bool getLeftClicked()
 717         {
 718                 return m_receiver->leftclicked;
 719         }
 720         virtual bool getRightClicked()
 721         {
 722                 return m_receiver->rightclicked;
 723         }
 724         virtual void resetLeftClicked()
 725         {
 726                 m_receiver->leftclicked = false;
 727         }
 728         virtual void resetRightClicked()
 729         {
 730                 m_receiver->rightclicked = false;
 731         }
 732
 733         virtual bool getLeftReleased()
 734         {
 735                 return m_receiver->leftreleased;
 736         }
 737         virtual bool getRightReleased()
 738         {
 739                 return m_receiver->rightreleased;
 740         }
 741         virtual void resetLeftReleased()
 742         {
 743                 m_receiver->leftreleased = false;
 744         }
 745         virtual void resetRightReleased()
 746         {
 747                 m_receiver->rightreleased = false;
 748         }
 749
 750         virtual s32 getMouseWheel()
 751         {
 752                 return m_receiver->getMouseWheel();
 753         }
 754
 755         void clear()
 756         {
 757                 m_receiver->clearInput();
 758         }
 759 private:
 760         IrrlichtDevice *m_device;
 761         MyEventReceiver *m_receiver;
 762 };
 763
 764 class RandomInputHandler : public InputHandler
 765 {
 766 public:
 767         RandomInputHandler()
 768         {
 769                 leftdown = false;
 770                 rightdown = false;
 771                 leftclicked = false;
 772                 rightclicked = false;
 773                 leftreleased = false;
 774                 rightreleased = false;
 775                 keydown.clear();
 776         }
 777         virtual bool isKeyDown(const KeyPress &keyCode)
 778         {
 779                 return keydown[keyCode];
 780         }
 781         virtual bool wasKeyDown(const KeyPress &keyCode)
 782         {
 783                 return false;
 784         }
 785         virtual v2s32 getMousePos()
 786         {
 787                 return mousepos;
 788         }
 789         virtual void setMousePos(s32 x, s32 y)
 790         {
 791                 mousepos = v2s32(x,y);
 792         }
 793
 794         virtual bool getLeftState()
 795         {
 796                 return leftdown;
 797         }
 798         virtual bool getRightState()
 799         {
 800                 return rightdown;
 801         }
 802
 803         virtual bool getLeftClicked()
 804         {
 805                 return leftclicked;
 806         }
 807         virtual bool getRightClicked()
 808         {
 809                 return rightclicked;
 810         }
 811         virtual void resetLeftClicked()
 812         {
 813                 leftclicked = false;
 814         }
 815         virtual void resetRightClicked()
 816         {
 817                 rightclicked = false;
 818         }
 819
 820         virtual bool getLeftReleased()
 821         {
 822                 return leftreleased;
 823         }
 824         virtual bool getRightReleased()
 825         {
 826                 return rightreleased;
 827         }
 828         virtual void resetLeftReleased()
 829         {
 830                 leftreleased = false;
 831         }
 832         virtual void resetRightReleased()
 833         {
 834                 rightreleased = false;
 835         }
 836
 837         virtual s32 getMouseWheel()
 838         {
 839                 return 0;
 840         }
 841
 842         virtual void step(float dtime)
 843         {
 844                 {
 845                         static float counter1 = 0;
 846                         counter1 -= dtime;
 847                         if(counter1 < 0.0)
 848                         {
 849                                 counter1 = 0.1*Rand(1, 40);
 850                                 keydown.toggle(getKeySetting("keymap_jump"));
 851                         }
 852                 }
 853                 {
 854                         static float counter1 = 0;
 855                         counter1 -= dtime;
 856                         if(counter1 < 0.0)
 857                         {
 858                                 counter1 = 0.1*Rand(1, 40);
 859                                 keydown.toggle(getKeySetting("keymap_special1"));
 860                         }
 861                 }
 862                 {
 863                         static float counter1 = 0;
 864                         counter1 -= dtime;
 865                         if(counter1 < 0.0)
 866                         {
 867                                 counter1 = 0.1*Rand(1, 40);
 868                                 keydown.toggle(getKeySetting("keymap_forward"));
 869                         }
 870                 }
 871                 {
 872                         static float counter1 = 0;
 873                         counter1 -= dtime;
 874                         if(counter1 < 0.0)
 875                         {
 876                                 counter1 = 0.1*Rand(1, 40);
 877                                 keydown.toggle(getKeySetting("keymap_left"));
 878                         }
 879                 }
 880                 {
 881                         static float counter1 = 0;
 882                         counter1 -= dtime;
 883                         if(counter1 < 0.0)
 884                         {
 885                                 counter1 = 0.1*Rand(1, 20);
 886                                 mousespeed = v2s32(Rand(-20,20), Rand(-15,20));
 887                         }
 888                 }
 889                 {
 890                         static float counter1 = 0;
 891                         counter1 -= dtime;
 892                         if(counter1 < 0.0)
 893                         {
 894                                 counter1 = 0.1*Rand(1, 30);
 895                                 leftdown = !leftdown;
 896                                 if(leftdown)
 897                                         leftclicked = true;
 898                                 if(!leftdown)
 899                                         leftreleased = true;
 900                         }
 901                 }
 902                 {
 903                         static float counter1 = 0;
 904                         counter1 -= dtime;
 905                         if(counter1 < 0.0)
 906                         {
 907                                 counter1 = 0.1*Rand(1, 15);
 908                                 rightdown = !rightdown;
 909                                 if(rightdown)
 910                                         rightclicked = true;
 911                                 if(!rightdown)
 912                                         rightreleased = true;
 913                         }
 914                 }
 915                 mousepos += mousespeed;
 916         }
 917
 918         s32 Rand(s32 min, s32 max)
 919         {
 920                 return (myrand()%(max-min+1))+min;
 921         }
 922 private:
 923         KeyList keydown;
 924         v2s32 mousepos;
 925         v2s32 mousespeed;
 926         bool leftdown;
 927         bool rightdown;
 928         bool leftclicked;
 929         bool rightclicked;
 930         bool leftreleased;
 931         bool rightreleased;
 932 };
 933
 934 // These are defined global so that they're not optimized too much.
 935 // Can't change them to volatile.
 936 s16 temp16;
 937 f32 tempf;
 938 v3f tempv3f1;
 939 v3f tempv3f2;
 940 std::string tempstring;
 941 std::string tempstring2;
 942
 943 void SpeedTests()
 944 {
 945         {
 946                 dstream<<"The following test should take around 20ms."<<std::endl;
 947                 TimeTaker timer("Testing std::string speed");
 948                 const u32 jj = 10000;
 949                 for(u32 j=0; j<jj; j++)
 950                 {
 951                         tempstring = "";
 952                         tempstring2 = "";
 953                         const u32 ii = 10;
 954                         for(u32 i=0; i<ii; i++){
 955                                 tempstring2 += "asd";
 956                         }
 957                         for(u32 i=0; i<ii+1; i++){
 958                                 tempstring += "asd";
 959                                 if(tempstring == tempstring2)
 960                                         break;
 961                         }
 962                 }
 963         }
 964
 965         dstream<<"All of the following tests should take around 100ms each."
 966                         <<std::endl;
 967
 968         {
 969                 TimeTaker timer("Testing floating-point conversion speed");
 970                 tempf = 0.001;
 971                 for(u32 i=0; i<4000000; i++){
 972                         temp16 += tempf;
 973                         tempf += 0.001;
 974                 }
 975         }
 976
 977         {
 978                 TimeTaker timer("Testing floating-point vector speed");
 979
 980                 tempv3f1 = v3f(1,2,3);
 981                 tempv3f2 = v3f(4,5,6);
 982                 for(u32 i=0; i<10000000; i++){
 983                         tempf += tempv3f1.dotProduct(tempv3f2);
 984                         tempv3f2 += v3f(7,8,9);
 985                 }
 986         }
 987
 988         {
 989                 TimeTaker timer("Testing core::map speed");
 990
 991                 core::map<v2s16, f32> map1;
 992                 tempf = -324;
 993                 const s16 ii=300;
 994                 for(s16 y=0; y<ii; y++){
 995                         for(s16 x=0; x<ii; x++){
 996                                 map1.insert(v2s16(x,y), tempf);
 997                                 tempf += 1;
 998                         }
 999                 }
1000                 for(s16 y=ii-1; y>=0; y--){
1001                         for(s16 x=0; x<ii; x++){
1002                                 tempf = map1[v2s16(x,y)];
1003                         }
1004                 }
1005         }
1006
1007         {
1008                 dstream<<"Around 5000/ms should do well here."<<std::endl;
1009                 TimeTaker timer("Testing mutex speed");
1010
1011                 JMutex m;
1012                 m.Init();
1013                 u32 n = 0;
1014                 u32 i = 0;
1015                 do{
1016                         n += 10000;
1017                         for(; i<n; i++){
1018                                 m.Lock();
1019                                 m.Unlock();
1020                         }
1021                 }
1022                 // Do at least 10ms
1023                 while(timer.getTime() < 10);
1024
1025                 u32 dtime = timer.stop();
1026                 u32 per_ms = n / dtime;
1027                 dstream<<"Done. "<<dtime<<"ms, "
1028                                 <<per_ms<<"/ms"<<std::endl;
1029         }
1030 }
1031
1032 void drawMenuBackground(video::IVideoDriver* driver)
1033 {
1034         core::dimension2d<u32> screensize = driver->getScreenSize();
1035
1036         video::ITexture *bgtexture =
1037                         driver->getTexture(getTexturePath("mud.png").c_str());
1038         if(bgtexture)
1039         {
1040                 s32 texturesize = 128;
1041                 s32 tiled_y = screensize.Height / texturesize + 1;
1042                 s32 tiled_x = screensize.Width / texturesize + 1;
1043
1044                 for(s32 y=0; y<tiled_y; y++)
1045                 for(s32 x=0; x<tiled_x; x++)
1046                 {
1047                         core::rect<s32> rect(0,0,texturesize,texturesize);
1048                         rect += v2s32(x*texturesize, y*texturesize);
1049                         driver->draw2DImage(bgtexture, rect,
1050                                 core::rect<s32>(core::position2d<s32>(0,0),
1051                                 core::dimension2di(bgtexture->getSize())),
1052                                 NULL, NULL, true);
1053                 }
1054         }
1055
1056         video::ITexture *logotexture =
1057                         driver->getTexture(getTexturePath("menulogo.png").c_str());
1058         if(logotexture)
1059         {
1060                 v2s32 logosize(logotexture->getOriginalSize().Width,
1061                                 logotexture->getOriginalSize().Height);
1062                 logosize *= 4;
1063
1064                 video::SColor bgcolor(255,50,50,50);
1065                 core::rect<s32> bgrect(0, screensize.Height-logosize.Y-20,
1066                                 screensize.Width, screensize.Height);
1067                 driver->draw2DRectangle(bgcolor, bgrect, NULL);
1068
1069                 core::rect<s32> rect(0,0,logosize.X,logosize.Y);
1070                 rect += v2s32(screensize.Width/2,screensize.Height-10-logosize.Y);
1071                 rect -= v2s32(logosize.X/2, 0);
1072                 driver->draw2DImage(logotexture, rect,
1073                         core::rect<s32>(core::position2d<s32>(0,0),
1074                         core::dimension2di(logotexture->getSize())),
1075                         NULL, NULL, true);
1076         }
1077 }
1078
1079 class StderrLogOutput: public ILogOutput
1080 {
1081 public:
1082         /* line: Full line with timestamp, level and thread */
1083         void printLog(const std::string &line)
1084         {
1085                 std::cerr<<line<<std::endl;
1086         }
1087 } main_stderr_log_out;
1088
1089 class DstreamNoStderrLogOutput: public ILogOutput
1090 {
1091 public:
1092         /* line: Full line with timestamp, level and thread */
1093         void printLog(const std::string &line)
1094         {
1095                 dstream_no_stderr<<line<<std::endl;
1096         }
1097 } main_dstream_no_stderr_log_out;
1098
1099 int main(int argc, char *argv[])
1100 {
1101         /*
1102                 Initialization
1103         */
1104
1105         log_add_output_maxlev(&main_stderr_log_out, LMT_ACTION);
1106         log_add_output_all_levs(&main_dstream_no_stderr_log_out);
1107
1108         log_register_thread("main");
1109
1110         // Set locale. This is for forcing '.' as the decimal point.
1111         std::locale::global(std::locale("C"));
1112         // This enables printing all characters in bitmap font
1113         setlocale(LC_CTYPE, "en_US");
1114
1115         /*
1116                 Parse command line
1117         */
1118
1119         // List all allowed options
1120         core::map<std::string, ValueSpec> allowed_options;
1121         allowed_options.insert("help", ValueSpec(VALUETYPE_FLAG));
1122         allowed_options.insert("server", ValueSpec(VALUETYPE_FLAG,
1123                         "Run server directly"));
1124         allowed_options.insert("config", ValueSpec(VALUETYPE_STRING,
1125                         "Load configuration from specified file"));
1126         allowed_options.insert("port", ValueSpec(VALUETYPE_STRING));
1127         allowed_options.insert("address", ValueSpec(VALUETYPE_STRING));
1128         allowed_options.insert("random-input", ValueSpec(VALUETYPE_FLAG));
1129         allowed_options.insert("disable-unittests", ValueSpec(VALUETYPE_FLAG));
1130         allowed_options.insert("enable-unittests", ValueSpec(VALUETYPE_FLAG));
1131         allowed_options.insert("map-dir", ValueSpec(VALUETYPE_STRING));
1132 #ifdef _WIN32
1133         allowed_options.insert("dstream-on-stderr", ValueSpec(VALUETYPE_FLAG));
1134 #endif
1135         allowed_options.insert("speedtests", ValueSpec(VALUETYPE_FLAG));
1136         allowed_options.insert("info-on-stderr", ValueSpec(VALUETYPE_FLAG));
1137
1138         Settings cmd_args;
1139
1140         bool ret = cmd_args.parseCommandLine(argc, argv, allowed_options);
1141
1142         if(ret == false || cmd_args.getFlag("help"))
1143         {
1144                 dstream<<"Allowed options:"<<std::endl;
1145                 for(core::map<std::string, ValueSpec>::Iterator
1146                                 i = allowed_options.getIterator();
1147                                 i.atEnd() == false; i++)
1148                 {
1149                         dstream<<"  --"<<i.getNode()->getKey();
1150                         if(i.getNode()->getValue().type == VALUETYPE_FLAG)
1151                         {
1152                         }
1153                         else
1154                         {
1155                                 dstream<<" <value>";
1156                         }
1157                         dstream<<std::endl;
1158
1159                         if(i.getNode()->getValue().help != NULL)
1160                         {
1161                                 dstream<<"      "<<i.getNode()->getValue().help
1162                                                 <<std::endl;
1163                         }
1164                 }
1165
1166                 return cmd_args.getFlag("help") ? 0 : 1;
1167         }
1168
1169         /*
1170                 Low-level initialization
1171         */
1172
1173         bool disable_stderr = false;
1174 #ifdef _WIN32
1175         if(cmd_args.getFlag("dstream-on-stderr") == false)
1176                 disable_stderr = true;
1177 #endif
1178
1179         if(cmd_args.getFlag("info-on-stderr"))
1180                 log_add_output(&main_stderr_log_out, LMT_INFO);
1181
1182         porting::signal_handler_init();
1183         bool &kill = *porting::signal_handler_killstatus();
1184
1185         // Initialize porting::path_data and porting::path_userdata
1186         porting::initializePaths();
1187
1188         // Create user data directory
1189         fs::CreateDir(porting::path_userdata);
1190
1191         init_gettext((porting::path_data+DIR_DELIM+".."+DIR_DELIM+"locale").c_str());
1192
1193         // Initialize debug streams
1194 #ifdef RUN_IN_PLACE
1195         std::string debugfile = DEBUGFILE;
1196 #else
1197         std::string debugfile = porting::path_userdata+DIR_DELIM+DEBUGFILE;
1198 #endif
1199         debugstreams_init(disable_stderr, debugfile.c_str());
1200         // Initialize debug stacks
1201         debug_stacks_init();
1202
1203         DSTACK(__FUNCTION_NAME);
1204
1205         // Init material properties table
1206         //initializeMaterialProperties();
1207
1208         // Debug handler
1209         BEGIN_DEBUG_EXCEPTION_HANDLER
1210
1211         // Print startup message
1212         actionstream<<PROJECT_NAME<<
1213                         " with SER_FMT_VER_HIGHEST="<<(int)SER_FMT_VER_HIGHEST
1214                         <<", "<<BUILD_INFO
1215                         <<std::endl;
1216
1217         /*
1218                 Basic initialization
1219         */
1220
1221         // Initialize default settings
1222         set_default_settings(g_settings);
1223
1224         // Initialize sockets
1225         sockets_init();
1226         atexit(sockets_cleanup);
1227
1228         /*
1229                 Read config file
1230         */
1231
1232         // Path of configuration file in use
1233         std::string configpath = "";
1234
1235         if(cmd_args.exists("config"))
1236         {
1237                 bool r = g_settings->readConfigFile(cmd_args.get("config").c_str());
1238                 if(r == false)
1239                 {
1240                         errorstream<<"Could not read configuration from \""
1241                                         <<cmd_args.get("config")<<"\""<<std::endl;
1242                         return 1;
1243                 }
1244                 configpath = cmd_args.get("config");
1245         }
1246         else
1247         {
1248                 core::array<std::string> filenames;
1249                 filenames.push_back(porting::path_userdata +
1250                                 DIR_DELIM + "minetest.conf");
1251 #ifdef RUN_IN_PLACE
1252                 filenames.push_back(porting::path_userdata +
1253                                 DIR_DELIM + ".." + DIR_DELIM + "minetest.conf");
1254 #endif
1255
1256                 for(u32 i=0; i<filenames.size(); i++)
1257                 {
1258                         bool r = g_settings->readConfigFile(filenames[i].c_str());
1259                         if(r)
1260                         {
1261                                 configpath = filenames[i];
1262                                 break;
1263                         }
1264                 }
1265
1266                 // If no path found, use the first one (menu creates the file)
1267                 if(configpath == "")
1268                         configpath = filenames[0];
1269         }
1270
1271         // Initialize random seed
1272         srand(time(0));
1273         mysrand(time(0));
1274
1275         /*
1276                 Pre-initialize some stuff with a dummy irrlicht wrapper.
1277
1278                 These are needed for unit tests at least.
1279         */
1280
1281         // Initial call with g_texturesource not set.
1282         init_mapnode();
1283         // Must be called before g_texturesource is created
1284         // (for texture atlas making)
1285         init_mineral();
1286
1287         /*
1288                 Run unit tests
1289         */
1290
1291         if((ENABLE_TESTS && cmd_args.getFlag("disable-unittests") == false)
1292                         || cmd_args.getFlag("enable-unittests") == true)
1293         {
1294                 run_tests();
1295         }
1296
1297         /*for(s16 y=-100; y<100; y++)
1298         for(s16 x=-100; x<100; x++)
1299         {
1300                 std::cout<<noise2d_gradient((double)x/10,(double)y/10, 32415)<<std::endl;
1301         }
1302         return 0;*/
1303
1304         /*
1305                 Game parameters
1306         */
1307
1308         // Port
1309         u16 port = 30000;
1310         if(cmd_args.exists("port"))
1311                 port = cmd_args.getU16("port");
1312         else if(g_settings->exists("port"))
1313                 port = g_settings->getU16("port");
1314         if(port == 0)
1315                 port = 30000;
1316
1317         // Map directory
1318         std::string map_dir = porting::path_userdata+DIR_DELIM+"world";
1319         if(cmd_args.exists("map-dir"))
1320                 map_dir = cmd_args.get("map-dir");
1321         else if(g_settings->exists("map-dir"))
1322                 map_dir = g_settings->get("map-dir");
1323
1324         // Run dedicated server if asked to
1325         if(cmd_args.getFlag("server"))
1326         {
1327                 DSTACK("Dedicated server branch");
1328
1329                 // Create time getter
1330                 g_timegetter = new SimpleTimeGetter();
1331
1332                 // Create server
1333                 Server server(map_dir.c_str(), configpath);
1334                 server.start(port);
1335
1336                 // Run server
1337                 dedicated_server_loop(server, kill);
1338
1339                 return 0;
1340         }
1341
1342
1343         /*
1344                 More parameters
1345         */
1346
1347         // Address to connect to
1348         std::string address = "";
1349
1350         if(cmd_args.exists("address"))
1351         {
1352                 address = cmd_args.get("address");
1353         }
1354         else
1355         {
1356                 address = g_settings->get("address");
1357         }
1358
1359         std::string playername = g_settings->get("name");
1360
1361         /*
1362                 Device initialization
1363         */
1364
1365         // Resolution selection
1366
1367         bool fullscreen = false;
1368         u16 screenW = g_settings->getU16("screenW");
1369         u16 screenH = g_settings->getU16("screenH");
1370
1371         // Determine driver
1372
1373         video::E_DRIVER_TYPE driverType;
1374
1375         std::string driverstring = g_settings->get("video_driver");
1376
1377         if(driverstring == "null")
1378                 driverType = video::EDT_NULL;
1379         else if(driverstring == "software")
1380                 driverType = video::EDT_SOFTWARE;
1381         else if(driverstring == "burningsvideo")
1382                 driverType = video::EDT_BURNINGSVIDEO;
1383         else if(driverstring == "direct3d8")
1384                 driverType = video::EDT_DIRECT3D8;
1385         else if(driverstring == "direct3d9")
1386                 driverType = video::EDT_DIRECT3D9;
1387         else if(driverstring == "opengl")
1388                 driverType = video::EDT_OPENGL;
1389         else
1390         {
1391                 errorstream<<"WARNING: Invalid video_driver specified; defaulting "
1392                                 "to opengl"<<std::endl;
1393                 driverType = video::EDT_OPENGL;
1394         }
1395
1396         /*
1397                 Create device and exit if creation failed
1398         */
1399
1400         MyEventReceiver receiver;
1401
1402         IrrlichtDevice *device;
1403         device = createDevice(driverType,
1404                         core::dimension2d<u32>(screenW, screenH),
1405                         16, fullscreen, false, false, &receiver);
1406
1407         if (device == 0)
1408                 return 1; // could not create selected driver.
1409
1410         /*
1411                 Continue initialization
1412         */
1413
1414         video::IVideoDriver* driver = device->getVideoDriver();
1415
1416         // Disable mipmaps (because some of them look ugly)
1417         driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);
1418
1419         /*
1420                 This changes the minimum allowed number of vertices in a VBO.
1421                 Default is 500.
1422         */
1423         //driver->setMinHardwareBufferVertexCount(50);
1424
1425         // Set the window caption
1426         device->setWindowCaption(L"Minetest [Main Menu]");
1427
1428         // Create time getter
1429         g_timegetter = new IrrlichtTimeGetter(device);
1430
1431         // Create game callback for menus
1432         g_gamecallback = new MainGameCallback(device);
1433
1434         // Create texture source
1435         g_texturesource = new TextureSource(device);
1436
1437         /*
1438                 Speed tests (done after irrlicht is loaded to get timer)
1439         */
1440         if(cmd_args.getFlag("speedtests"))
1441         {
1442                 dstream<<"Running speed tests"<<std::endl;
1443                 SpeedTests();
1444                 return 0;
1445         }
1446
1447         device->setResizable(true);
1448
1449         bool random_input = g_settings->getBool("random_input")
1450                         || cmd_args.getFlag("random-input");
1451         InputHandler *input = NULL;
1452         if(random_input)
1453                 input = new RandomInputHandler();
1454         else
1455                 input = new RealInputHandler(device, &receiver);
1456
1457         scene::ISceneManager* smgr = device->getSceneManager();
1458
1459         guienv = device->getGUIEnvironment();
1460         gui::IGUISkin* skin = guienv->getSkin();
1461         gui::IGUIFont* font = guienv->getFont(getTexturePath("fontlucida.png").c_str());
1462         if(font)
1463                 skin->setFont(font);
1464         else
1465                 errorstream<<"WARNING: Font file was not found."
1466                                 " Using default font."<<std::endl;
1467         // If font was not found, this will get us one
1468         font = skin->getFont();
1469         assert(font);
1470
1471         u32 text_height = font->getDimension(L"Hello, world!").Height;
1472         infostream<<"text_height="<<text_height<<std::endl;
1473
1474         //skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255,0,0,0));
1475         skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255,255,255,255));
1476         //skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(0,0,0,0));
1477         //skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(0,0,0,0));
1478         skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(255,0,0,0));
1479         skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(255,0,0,0));
1480
1481         /*
1482                 Preload some textures and stuff
1483         */
1484
1485         init_mapnode(); // Second call with g_texturesource set
1486
1487         /*
1488                 GUI stuff
1489         */
1490
1491         /*
1492                 If an error occurs, this is set to something and the
1493                 menu-game loop is restarted. It is then displayed before
1494                 the menu.
1495         */
1496         std::wstring error_message = L"";
1497
1498         // The password entered during the menu screen,
1499         std::string password;
1500
1501         /*
1502                 Menu-game loop
1503         */
1504         while(device->run() && kill == false)
1505         {
1506
1507                 // This is used for catching disconnects
1508                 try
1509                 {
1510
1511                         /*
1512                                 Clear everything from the GUIEnvironment
1513                         */
1514                         guienv->clear();
1515
1516                         /*
1517                                 We need some kind of a root node to be able to add
1518                                 custom gui elements directly on the screen.
1519                                 Otherwise they won't be automatically drawn.
1520                         */
1521                         guiroot = guienv->addStaticText(L"",
1522                                         core::rect<s32>(0, 0, 10000, 10000));
1523
1524                         /*
1525                                 Out-of-game menu loop.
1526
1527                                 Loop quits when menu returns proper parameters.
1528                         */
1529                         while(kill == false)
1530                         {
1531                                 // Cursor can be non-visible when coming from the game
1532                                 device->getCursorControl()->setVisible(true);
1533                                 // Some stuff are left to scene manager when coming from the game
1534                                 // (map at least?)
1535                                 smgr->clear();
1536                                 // Reset or hide the debug gui texts
1537                                 /*guitext->setText(L"Minetest-c55");
1538                                 guitext2->setVisible(false);
1539                                 guitext_info->setVisible(false);
1540                                 guitext_chat->setVisible(false);*/
1541
1542                                 // Initialize menu data
1543                                 MainMenuData menudata;
1544                                 menudata.address = narrow_to_wide(address);
1545                                 menudata.name = narrow_to_wide(playername);
1546                                 menudata.port = narrow_to_wide(itos(port));
1547                                 menudata.fancy_trees = g_settings->getBool("new_style_leaves");
1548                                 menudata.smooth_lighting = g_settings->getBool("smooth_lighting");
1549                                 menudata.clouds_3d = g_settings->getBool("enable_3d_clouds");
1550                                 menudata.opaque_water = g_settings->getBool("opaque_water");
1551                                 menudata.creative_mode = g_settings->getBool("creative_mode");
1552                                 menudata.enable_damage = g_settings->getBool("enable_damage");
1553
1554                                 GUIMainMenu *menu =
1555                                                 new GUIMainMenu(guienv, guiroot, -1,
1556                                                         &g_menumgr, &menudata, g_gamecallback);
1557                                 menu->allowFocusRemoval(true);
1558
1559                                 if(error_message != L"")
1560                                 {
1561                                         errorstream<<"error_message = "
1562                                                         <<wide_to_narrow(error_message)<<std::endl;
1563
1564                                         GUIMessageMenu *menu2 =
1565                                                         new GUIMessageMenu(guienv, guiroot, -1,
1566                                                                 &g_menumgr, error_message.c_str());
1567                                         menu2->drop();
1568                                         error_message = L"";
1569                                 }
1570
1571                                 video::IVideoDriver* driver = device->getVideoDriver();
1572
1573                                 infostream<<"Created main menu"<<std::endl;
1574
1575                                 while(device->run() && kill == false)
1576                                 {
1577                                         if(menu->getStatus() == true)
1578                                                 break;
1579
1580                                         //driver->beginScene(true, true, video::SColor(255,0,0,0));
1581                                         driver->beginScene(true, true, video::SColor(255,128,128,128));
1582
1583                                         drawMenuBackground(driver);
1584
1585                                         guienv->drawAll();
1586
1587                                         driver->endScene();
1588
1589                                         // On some computers framerate doesn't seem to be
1590                                         // automatically limited
1591                                         sleep_ms(25);
1592                                 }
1593
1594                                 // Break out of menu-game loop to shut down cleanly
1595                                 if(device->run() == false || kill == true)
1596                                         break;
1597
1598                                 infostream<<"Dropping main menu"<<std::endl;
1599
1600                                 menu->drop();
1601
1602                                 // Delete map if requested
1603                                 if(menudata.delete_map)
1604                                 {
1605                                         bool r = fs::RecursiveDeleteContent(map_dir);
1606                                         if(r == false)
1607                                                 error_message = L"Delete failed";
1608                                         continue;
1609                                 }
1610
1611                                 playername = wide_to_narrow(menudata.name);
1612
1613                                 password = translatePassword(playername, menudata.password);
1614
1615                                 //infostream<<"Main: password hash: '"<<password<<"'"<<std::endl;
1616
1617                                 address = wide_to_narrow(menudata.address);
1618                                 int newport = stoi(wide_to_narrow(menudata.port));
1619                                 if(newport != 0)
1620                                         port = newport;
1621                                 g_settings->set("new_style_leaves", itos(menudata.fancy_trees));
1622                                 g_settings->set("smooth_lighting", itos(menudata.smooth_lighting));
1623                                 g_settings->set("enable_3d_clouds", itos(menudata.clouds_3d));
1624                                 g_settings->set("opaque_water", itos(menudata.opaque_water));
1625                                 g_settings->set("creative_mode", itos(menudata.creative_mode));
1626                                 g_settings->set("enable_damage", itos(menudata.enable_damage));
1627
1628                                 // NOTE: These are now checked server side; no need to do it
1629                                 //       here, so let's not do it here.
1630                                 /*// Check for valid parameters, restart menu if invalid.
1631                                 if(playername == "")
1632                                 {
1633                                         error_message = L"Name required.";
1634                                         continue;
1635                                 }
1636                                 // Check that name has only valid chars
1637                                 if(string_allowed(playername, PLAYERNAME_ALLOWED_CHARS)==false)
1638                                 {
1639                                         error_message = L"Characters allowed: "
1640                                                         +narrow_to_wide(PLAYERNAME_ALLOWED_CHARS);
1641                                         continue;
1642                                 }*/
1643
1644                                 // Save settings
1645                                 g_settings->set("name", playername);
1646                                 g_settings->set("address", address);
1647                                 g_settings->set("port", itos(port));
1648                                 // Update configuration file
1649                                 if(configpath != "")
1650                                         g_settings->updateConfigFile(configpath.c_str());
1651
1652                                 // Continue to game
1653                                 break;
1654                         }
1655
1656                         // Break out of menu-game loop to shut down cleanly
1657                         if(device->run() == false)
1658                                 break;
1659
1660                         // Initialize mapnode again to enable changed graphics settings
1661                         init_mapnode();
1662
1663                         /*
1664                                 Run game
1665                         */
1666                         the_game(
1667                                 kill,
1668                                 random_input,
1669                                 input,
1670                                 device,
1671                                 font,
1672                                 map_dir,
1673                                 playername,
1674                                 password,
1675                                 address,
1676                                 port,
1677                                 error_message,
1678                                 configpath
1679                         );
1680
1681                 } //try
1682                 catch(con::PeerNotFoundException &e)
1683                 {
1684                         errorstream<<"Connection error (timed out?)"<<std::endl;
1685                         error_message = L"Connection error (timed out?)";
1686                 }
1687                 catch(SocketException &e)
1688                 {
1689                         errorstream<<"Socket error (port already in use?)"<<std::endl;
1690                         error_message = L"Socket error (port already in use?)";
1691                 }
1692 #ifdef NDEBUG
1693                 catch(std::exception &e)
1694                 {
1695                         std::string narrow_message = "Some exception, what()=\"";
1696                         narrow_message += e.what();
1697                         narrow_message += "\"";
1698                         errorstream<<narrow_message<<std::endl;
1699                         error_message = narrow_to_wide(narrow_message);
1700                 }
1701 #endif
1702
1703         } // Menu-game loop
1704
1705         delete input;
1706
1707         /*
1708                 In the end, delete the Irrlicht device.
1709         */
1710         device->drop();
1711
1712         END_DEBUG_EXCEPTION_HANDLER(errorstream)
1713
1714         debugstreams_deinit();
1715
1716         return 0;
1717 }
1718
1719 //END
1720