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 <iostream>
 415 #include <fstream>
 416 #include <locale.h>
 417 #include "main.h"
 418 #include "common_irrlicht.h"
 419 #include "debug.h"
 420 #include "test.h"
 421 #include "server.h"
 422 #include "constants.h"
 423 #include "porting.h"
 424 #include "gettime.h"
 425 #include "guiMessageMenu.h"
 426 #include "filesys.h"
 427 #include "config.h"
 428 #include "guiMainMenu.h"
 429 #include "mineral.h"
 430 #include "materials.h"
 431 #include "game.h"
 432 #include "keycode.h"
 433 #include "tile.h"
 434
 435 #include "gettext.h"
 436
 437 // This makes textures
 438 ITextureSource *g_texturesource = NULL;
 439
 440 /*
 441         Settings.
 442         These are loaded from the config file.
 443 */
 444
 445 Settings g_settings;
 446 // This is located in defaultsettings.cpp
 447 extern void set_default_settings();
 448
 449 // Global profiler
 450 Profiler g_profiler;
 451
 452 /*
 453         Random stuff
 454 */
 455
 456 /*
 457         GUI Stuff
 458 */
 459
 460 gui::IGUIEnvironment* guienv = NULL;
 461 gui::IGUIStaticText *guiroot = NULL;
 462
 463 MainMenuManager g_menumgr;
 464
 465 bool noMenuActive()
 466 {
 467         return (g_menumgr.menuCount() == 0);
 468 }
 469
 470 // Passed to menus to allow disconnecting and exiting
 471
 472 MainGameCallback *g_gamecallback = NULL;
 473
 474 /*
 475         Debug streams
 476 */
 477
 478 // Connection
 479 std::ostream *dout_con_ptr = &dummyout;
 480 std::ostream *derr_con_ptr = &dstream_no_stderr;
 481 //std::ostream *dout_con_ptr = &dstream_no_stderr;
 482 //std::ostream *derr_con_ptr = &dstream_no_stderr;
 483 //std::ostream *dout_con_ptr = &dstream;
 484 //std::ostream *derr_con_ptr = &dstream;
 485
 486 // Server
 487 std::ostream *dout_server_ptr = &dstream;
 488 std::ostream *derr_server_ptr = &dstream;
 489
 490 // Client
 491 std::ostream *dout_client_ptr = &dstream;
 492 std::ostream *derr_client_ptr = &dstream;
 493
 494 /*
 495         gettime.h implementation
 496 */
 497
 498 // A small helper class
 499 class TimeGetter
 500 {
 501 public:
 502         virtual u32 getTime() = 0;
 503 };
 504
 505 // A precise irrlicht one
 506 class IrrlichtTimeGetter: public TimeGetter
 507 {
 508 public:
 509         IrrlichtTimeGetter(IrrlichtDevice *device):
 510                 m_device(device)
 511         {}
 512         u32 getTime()
 513         {
 514                 if(m_device == NULL)
 515                         return 0;
 516                 return m_device->getTimer()->getRealTime();
 517         }
 518 private:
 519         IrrlichtDevice *m_device;
 520 };
 521 // Not so precise one which works without irrlicht
 522 class SimpleTimeGetter: public TimeGetter
 523 {
 524 public:
 525         u32 getTime()
 526         {
 527                 return porting::getTimeMs();
 528         }
 529 };
 530
 531 // A pointer to a global instance of the time getter
 532 // TODO: why?
 533 TimeGetter *g_timegetter = NULL;
 534
 535 u32 getTimeMs()
 536 {
 537         if(g_timegetter == NULL)
 538                 return 0;
 539         return g_timegetter->getTime();
 540 }
 541
 542 /*
 543         Event handler for Irrlicht
 544
 545         NOTE: Everything possible should be moved out from here,
 546               probably to InputHandler and the_game
 547 */
 548
 549 class MyEventReceiver : public IEventReceiver
 550 {
 551 public:
 552         // This is the one method that we have to implement
 553         virtual bool OnEvent(const SEvent& event)
 554         {
 555                 /*
 556                         React to nothing here if a menu is active
 557                 */
 558                 if(noMenuActive() == false)
 559                 {
 560                         return false;
 561                 }
 562
 563                 // Remember whether each key is down or up
 564                 if(event.EventType == irr::EET_KEY_INPUT_EVENT)
 565                 {
 566                         keyIsDown[event.KeyInput.Key] = event.KeyInput.PressedDown;
 567
 568                         if(event.KeyInput.PressedDown)
 569                                 keyWasDown[event.KeyInput.Key] = true;
 570                 }
 571
 572                 if(event.EventType == irr::EET_MOUSE_INPUT_EVENT)
 573                 {
 574                         if(noMenuActive() == false)
 575                         {
 576                                 left_active = false;
 577                                 middle_active = false;
 578                                 right_active = false;
 579                         }
 580                         else
 581                         {
 582                                 //dstream<<"MyEventReceiver: mouse input"<<std::endl;
 583                                 left_active = event.MouseInput.isLeftPressed();
 584                                 middle_active = event.MouseInput.isMiddlePressed();
 585                                 right_active = event.MouseInput.isRightPressed();
 586
 587                                 if(event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)
 588                                 {
 589                                         leftclicked = true;
 590                                 }
 591                                 if(event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN)
 592                                 {
 593                                         rightclicked = true;
 594                                 }
 595                                 if(event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP)
 596                                 {
 597                                         leftreleased = true;
 598                                 }
 599                                 if(event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP)
 600                                 {
 601                                         rightreleased = true;
 602                                 }
 603                                 if(event.MouseInput.Event == EMIE_MOUSE_WHEEL)
 604                                 {
 605                                         mouse_wheel += event.MouseInput.Wheel;
 606                                 }
 607                         }
 608                 }
 609
 610                 return false;
 611         }
 612
 613         bool IsKeyDown(EKEY_CODE keyCode) const
 614         {
 615                 return keyIsDown[keyCode];
 616         }
 617
 618         // Checks whether a key was down and resets the state
 619         bool WasKeyDown(EKEY_CODE keyCode)
 620         {
 621                 bool b = keyWasDown[keyCode];
 622                 keyWasDown[keyCode] = false;
 623                 return b;
 624         }
 625
 626         s32 getMouseWheel()
 627         {
 628                 s32 a = mouse_wheel;
 629                 mouse_wheel = 0;
 630                 return a;
 631         }
 632
 633         void clearInput()
 634         {
 635                 for(u32 i=0; i<KEY_KEY_CODES_COUNT; i++)
 636                 {
 637                         keyIsDown[i] = false;
 638                         keyWasDown[i] = false;
 639                 }
 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         bool keyIsDown[KEY_KEY_CODES_COUNT];
 674         // Whether a key has been pressed or not
 675         bool keyWasDown[KEY_KEY_CODES_COUNT];
 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(EKEY_CODE keyCode)
 691         {
 692                 return m_receiver->IsKeyDown(keyCode);
 693         }
 694         virtual bool wasKeyDown(EKEY_CODE 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                 for(u32 i=0; i<KEY_KEY_CODES_COUNT; ++i)
 776                         keydown[i] = false;
 777         }
 778         virtual bool isKeyDown(EKEY_CODE keyCode)
 779         {
 780                 return keydown[keyCode];
 781         }
 782         virtual bool wasKeyDown(EKEY_CODE keyCode)
 783         {
 784                 return false;
 785         }
 786         virtual v2s32 getMousePos()
 787         {
 788                 return mousepos;
 789         }
 790         virtual void setMousePos(s32 x, s32 y)
 791         {
 792                 mousepos = v2s32(x,y);
 793         }
 794
 795         virtual bool getLeftState()
 796         {
 797                 return leftdown;
 798         }
 799         virtual bool getRightState()
 800         {
 801                 return rightdown;
 802         }
 803
 804         virtual bool getLeftClicked()
 805         {
 806                 return leftclicked;
 807         }
 808         virtual bool getRightClicked()
 809         {
 810                 return rightclicked;
 811         }
 812         virtual void resetLeftClicked()
 813         {
 814                 leftclicked = false;
 815         }
 816         virtual void resetRightClicked()
 817         {
 818                 rightclicked = false;
 819         }
 820
 821         virtual bool getLeftReleased()
 822         {
 823                 return leftreleased;
 824         }
 825         virtual bool getRightReleased()
 826         {
 827                 return rightreleased;
 828         }
 829         virtual void resetLeftReleased()
 830         {
 831                 leftreleased = false;
 832         }
 833         virtual void resetRightReleased()
 834         {
 835                 rightreleased = false;
 836         }
 837
 838         virtual s32 getMouseWheel()
 839         {
 840                 return 0;
 841         }
 842
 843         virtual void step(float dtime)
 844         {
 845                 {
 846                         static float counter1 = 0;
 847                         counter1 -= dtime;
 848                         if(counter1 < 0.0)
 849                         {
 850                                 counter1 = 0.1*Rand(1, 40);
 851                                 keydown[getKeySetting("keymap_jump")] =
 852                                                 !keydown[getKeySetting("keymap_jump")];
 853                         }
 854                 }
 855                 {
 856                         static float counter1 = 0;
 857                         counter1 -= dtime;
 858                         if(counter1 < 0.0)
 859                         {
 860                                 counter1 = 0.1*Rand(1, 40);
 861                                 keydown[getKeySetting("keymap_special1")] =
 862                                                 !keydown[getKeySetting("keymap_special1")];
 863                         }
 864                 }
 865                 {
 866                         static float counter1 = 0;
 867                         counter1 -= dtime;
 868                         if(counter1 < 0.0)
 869                         {
 870                                 counter1 = 0.1*Rand(1, 40);
 871                                 keydown[getKeySetting("keymap_forward")] =
 872                                                 !keydown[getKeySetting("keymap_forward")];
 873                         }
 874                 }
 875                 {
 876                         static float counter1 = 0;
 877                         counter1 -= dtime;
 878                         if(counter1 < 0.0)
 879                         {
 880                                 counter1 = 0.1*Rand(1, 40);
 881                                 keydown[getKeySetting("keymap_left")] =
 882                                                 !keydown[getKeySetting("keymap_left")];
 883                         }
 884                 }
 885                 {
 886                         static float counter1 = 0;
 887                         counter1 -= dtime;
 888                         if(counter1 < 0.0)
 889                         {
 890                                 counter1 = 0.1*Rand(1, 20);
 891                                 mousespeed = v2s32(Rand(-20,20), Rand(-15,20));
 892                         }
 893                 }
 894                 {
 895                         static float counter1 = 0;
 896                         counter1 -= dtime;
 897                         if(counter1 < 0.0)
 898                         {
 899                                 counter1 = 0.1*Rand(1, 30);
 900                                 leftdown = !leftdown;
 901                                 if(leftdown)
 902                                         leftclicked = true;
 903                                 if(!leftdown)
 904                                         leftreleased = true;
 905                         }
 906                 }
 907                 {
 908                         static float counter1 = 0;
 909                         counter1 -= dtime;
 910                         if(counter1 < 0.0)
 911                         {
 912                                 counter1 = 0.1*Rand(1, 15);
 913                                 rightdown = !rightdown;
 914                                 if(rightdown)
 915                                         rightclicked = true;
 916                                 if(!rightdown)
 917                                         rightreleased = true;
 918                         }
 919                 }
 920                 mousepos += mousespeed;
 921         }
 922
 923         s32 Rand(s32 min, s32 max)
 924         {
 925                 return (myrand()%(max-min+1))+min;
 926         }
 927 private:
 928         bool keydown[KEY_KEY_CODES_COUNT];
 929         v2s32 mousepos;
 930         v2s32 mousespeed;
 931         bool leftdown;
 932         bool rightdown;
 933         bool leftclicked;
 934         bool rightclicked;
 935         bool leftreleased;
 936         bool rightreleased;
 937 };
 938
 939 // These are defined global so that they're not optimized too much.
 940 // Can't change them to volatile.
 941 s16 temp16;
 942 f32 tempf;
 943 v3f tempv3f1;
 944 v3f tempv3f2;
 945 std::string tempstring;
 946 std::string tempstring2;
 947
 948 void SpeedTests()
 949 {
 950         {
 951                 dstream<<"The following test should take around 20ms."<<std::endl;
 952                 TimeTaker timer("Testing std::string speed");
 953                 const u32 jj = 10000;
 954                 for(u32 j=0; j<jj; j++)
 955                 {
 956                         tempstring = "";
 957                         tempstring2 = "";
 958                         const u32 ii = 10;
 959                         for(u32 i=0; i<ii; i++){
 960                                 tempstring2 += "asd";
 961                         }
 962                         for(u32 i=0; i<ii+1; i++){
 963                                 tempstring += "asd";
 964                                 if(tempstring == tempstring2)
 965                                         break;
 966                         }
 967                 }
 968         }
 969
 970         dstream<<"All of the following tests should take around 100ms each."
 971                         <<std::endl;
 972
 973         {
 974                 TimeTaker timer("Testing floating-point conversion speed");
 975                 tempf = 0.001;
 976                 for(u32 i=0; i<4000000; i++){
 977                         temp16 += tempf;
 978                         tempf += 0.001;
 979                 }
 980         }
 981
 982         {
 983                 TimeTaker timer("Testing floating-point vector speed");
 984
 985                 tempv3f1 = v3f(1,2,3);
 986                 tempv3f2 = v3f(4,5,6);
 987                 for(u32 i=0; i<10000000; i++){
 988                         tempf += tempv3f1.dotProduct(tempv3f2);
 989                         tempv3f2 += v3f(7,8,9);
 990                 }
 991         }
 992
 993         {
 994                 TimeTaker timer("Testing core::map speed");
 995
 996                 core::map<v2s16, f32> map1;
 997                 tempf = -324;
 998                 const s16 ii=300;
 999                 for(s16 y=0; y<ii; y++){
1000                         for(s16 x=0; x<ii; x++){
1001                                 map1.insert(v2s16(x,y), tempf);
1002                                 tempf += 1;
1003                         }
1004                 }
1005                 for(s16 y=ii-1; y>=0; y--){
1006                         for(s16 x=0; x<ii; x++){
1007                                 tempf = map1[v2s16(x,y)];
1008                         }
1009                 }
1010         }
1011
1012         {
1013                 dstream<<"Around 5000/ms should do well here."<<std::endl;
1014                 TimeTaker timer("Testing mutex speed");
1015
1016                 JMutex m;
1017                 m.Init();
1018                 u32 n = 0;
1019                 u32 i = 0;
1020                 do{
1021                         n += 10000;
1022                         for(; i<n; i++){
1023                                 m.Lock();
1024                                 m.Unlock();
1025                         }
1026                 }
1027                 // Do at least 10ms
1028                 while(timer.getTime() < 10);
1029
1030                 u32 dtime = timer.stop();
1031                 u32 per_ms = n / dtime;
1032                 std::cout<<"Done. "<<dtime<<"ms, "
1033                                 <<per_ms<<"/ms"<<std::endl;
1034         }
1035 }
1036
1037 void drawMenuBackground(video::IVideoDriver* driver)
1038 {
1039         core::dimension2d<u32> screensize = driver->getScreenSize();
1040
1041         video::ITexture *bgtexture =
1042                         driver->getTexture(getTexturePath("mud.png").c_str());
1043         if(bgtexture)
1044         {
1045                 s32 texturesize = 128;
1046                 s32 tiled_y = screensize.Height / texturesize + 1;
1047                 s32 tiled_x = screensize.Width / texturesize + 1;
1048
1049                 for(s32 y=0; y<tiled_y; y++)
1050                 for(s32 x=0; x<tiled_x; x++)
1051                 {
1052                         core::rect<s32> rect(0,0,texturesize,texturesize);
1053                         rect += v2s32(x*texturesize, y*texturesize);
1054                         driver->draw2DImage(bgtexture, rect,
1055                                 core::rect<s32>(core::position2d<s32>(0,0),
1056                                 core::dimension2di(bgtexture->getSize())),
1057                                 NULL, NULL, true);
1058                 }
1059         }
1060
1061         video::ITexture *logotexture =
1062                         driver->getTexture(getTexturePath("menulogo.png").c_str());
1063         if(logotexture)
1064         {
1065                 v2s32 logosize(logotexture->getOriginalSize().Width,
1066                                 logotexture->getOriginalSize().Height);
1067                 logosize *= 4;
1068
1069                 video::SColor bgcolor(255,50,50,50);
1070                 core::rect<s32> bgrect(0, screensize.Height-logosize.Y-20,
1071                                 screensize.Width, screensize.Height);
1072                 driver->draw2DRectangle(bgcolor, bgrect, NULL);
1073
1074                 core::rect<s32> rect(0,0,logosize.X,logosize.Y);
1075                 rect += v2s32(screensize.Width/2,screensize.Height-10-logosize.Y);
1076                 rect -= v2s32(logosize.X/2, 0);
1077                 driver->draw2DImage(logotexture, rect,
1078                         core::rect<s32>(core::position2d<s32>(0,0),
1079                         core::dimension2di(logotexture->getSize())),
1080                         NULL, NULL, true);
1081         }
1082 }
1083
1084 int main(int argc, char *argv[])
1085 {
1086         /*
1087                 Initialization
1088         */
1089
1090         // Set locale. This is for forcing '.' as the decimal point.
1091         std::locale::global(std::locale("C"));
1092         // This enables printing all characters in bitmap font
1093         setlocale(LC_CTYPE, "en_US");
1094
1095         /*
1096                 Parse command line
1097         */
1098
1099         // List all allowed options
1100         core::map<std::string, ValueSpec> allowed_options;
1101         allowed_options.insert("help", ValueSpec(VALUETYPE_FLAG));
1102         allowed_options.insert("server", ValueSpec(VALUETYPE_FLAG,
1103                         "Run server directly"));
1104         allowed_options.insert("config", ValueSpec(VALUETYPE_STRING,
1105                         "Load configuration from specified file"));
1106         allowed_options.insert("port", ValueSpec(VALUETYPE_STRING));
1107         allowed_options.insert("address", ValueSpec(VALUETYPE_STRING));
1108         allowed_options.insert("random-input", ValueSpec(VALUETYPE_FLAG));
1109         allowed_options.insert("disable-unittests", ValueSpec(VALUETYPE_FLAG));
1110         allowed_options.insert("enable-unittests", ValueSpec(VALUETYPE_FLAG));
1111         allowed_options.insert("map-dir", ValueSpec(VALUETYPE_STRING));
1112 #ifdef _WIN32
1113         allowed_options.insert("dstream-on-stderr", ValueSpec(VALUETYPE_FLAG));
1114 #endif
1115         allowed_options.insert("speedtests", ValueSpec(VALUETYPE_FLAG));
1116
1117         Settings cmd_args;
1118
1119         bool ret = cmd_args.parseCommandLine(argc, argv, allowed_options);
1120
1121         if(ret == false || cmd_args.getFlag("help"))
1122         {
1123                 dstream<<"Allowed options:"<<std::endl;
1124                 for(core::map<std::string, ValueSpec>::Iterator
1125                                 i = allowed_options.getIterator();
1126                                 i.atEnd() == false; i++)
1127                 {
1128                         dstream<<"  --"<<i.getNode()->getKey();
1129                         if(i.getNode()->getValue().type == VALUETYPE_FLAG)
1130                         {
1131                         }
1132                         else
1133                         {
1134                                 dstream<<" <value>";
1135                         }
1136                         dstream<<std::endl;
1137
1138                         if(i.getNode()->getValue().help != NULL)
1139                         {
1140                                 dstream<<"      "<<i.getNode()->getValue().help
1141                                                 <<std::endl;
1142                         }
1143                 }
1144
1145                 return cmd_args.getFlag("help") ? 0 : 1;
1146         }
1147
1148         /*
1149                 Low-level initialization
1150         */
1151
1152         bool disable_stderr = false;
1153 #ifdef _WIN32
1154         if(cmd_args.getFlag("dstream-on-stderr") == false)
1155                 disable_stderr = true;
1156 #endif
1157
1158         porting::signal_handler_init();
1159         bool &kill = *porting::signal_handler_killstatus();
1160
1161         // Initialize porting::path_data and porting::path_userdata
1162         porting::initializePaths();
1163
1164         // Create user data directory
1165         fs::CreateDir(porting::path_userdata);
1166
1167         init_gettext((porting::path_data+"/../locale").c_str());
1168
1169         // Initialize debug streams
1170 #ifdef RUN_IN_PLACE
1171         std::string debugfile = DEBUGFILE;
1172 #else
1173         std::string debugfile = porting::path_userdata+"/"+DEBUGFILE;
1174 #endif
1175         debugstreams_init(disable_stderr, debugfile.c_str());
1176         // Initialize debug stacks
1177         debug_stacks_init();
1178
1179         DSTACK(__FUNCTION_NAME);
1180
1181         // Init material properties table
1182         //initializeMaterialProperties();
1183
1184         // Debug handler
1185         BEGIN_DEBUG_EXCEPTION_HANDLER
1186
1187         // Print startup message
1188         dstream<<DTIME<<PROJECT_NAME
1189                         " with SER_FMT_VER_HIGHEST="<<(int)SER_FMT_VER_HIGHEST
1190                         <<", "<<BUILD_INFO
1191                         <<std::endl;
1192
1193         /*
1194                 Basic initialization
1195         */
1196
1197         // Initialize default settings
1198         set_default_settings();
1199
1200         // Initialize sockets
1201         sockets_init();
1202         atexit(sockets_cleanup);
1203
1204         /*
1205                 Read config file
1206         */
1207
1208         // Path of configuration file in use
1209         std::string configpath = "";
1210
1211         if(cmd_args.exists("config"))
1212         {
1213                 bool r = g_settings.readConfigFile(cmd_args.get("config").c_str());
1214                 if(r == false)
1215                 {
1216                         dstream<<"Could not read configuration from \""
1217                                         <<cmd_args.get("config")<<"\""<<std::endl;
1218                         return 1;
1219                 }
1220                 configpath = cmd_args.get("config");
1221         }
1222         else
1223         {
1224                 core::array<std::string> filenames;
1225                 filenames.push_back(porting::path_userdata + "/minetest.conf");
1226 #ifdef RUN_IN_PLACE
1227                 filenames.push_back(porting::path_userdata + "/../minetest.conf");
1228 #endif
1229
1230                 for(u32 i=0; i<filenames.size(); i++)
1231                 {
1232                         bool r = g_settings.readConfigFile(filenames[i].c_str());
1233                         if(r)
1234                         {
1235                                 configpath = filenames[i];
1236                                 break;
1237                         }
1238                 }
1239
1240                 // If no path found, use the first one (menu creates the file)
1241                 if(configpath == "")
1242                         configpath = filenames[0];
1243         }
1244
1245         // Initialize random seed
1246         srand(time(0));
1247         mysrand(time(0));
1248
1249         /*
1250                 Pre-initialize some stuff with a dummy irrlicht wrapper.
1251
1252                 These are needed for unit tests at least.
1253         */
1254
1255         // Initial call with g_texturesource not set.
1256         init_mapnode();
1257
1258         /*
1259                 Run unit tests
1260         */
1261
1262         if((ENABLE_TESTS && cmd_args.getFlag("disable-unittests") == false)
1263                         || cmd_args.getFlag("enable-unittests") == true)
1264         {
1265                 run_tests();
1266         }
1267
1268         /*for(s16 y=-100; y<100; y++)
1269         for(s16 x=-100; x<100; x++)
1270         {
1271                 std::cout<<noise2d_gradient((double)x/10,(double)y/10, 32415)<<std::endl;
1272         }
1273         return 0;*/
1274
1275         /*
1276                 Game parameters
1277         */
1278
1279         // Port
1280         u16 port = 30000;
1281         if(cmd_args.exists("port"))
1282                 port = cmd_args.getU16("port");
1283         else if(g_settings.exists("port"))
1284                 port = g_settings.getU16("port");
1285         if(port == 0)
1286                 port = 30000;
1287
1288         // Map directory
1289         std::string map_dir = porting::path_userdata+"/world";
1290         if(cmd_args.exists("map-dir"))
1291                 map_dir = cmd_args.get("map-dir");
1292         else if(g_settings.exists("map-dir"))
1293                 map_dir = g_settings.get("map-dir");
1294
1295         // Run dedicated server if asked to
1296         if(cmd_args.getFlag("server"))
1297         {
1298                 DSTACK("Dedicated server branch");
1299
1300                 // Create time getter
1301                 g_timegetter = new SimpleTimeGetter();
1302
1303                 // Create server
1304                 Server server(map_dir.c_str(), configpath);
1305                 server.start(port);
1306
1307                 // Run server
1308                 dedicated_server_loop(server, kill);
1309
1310                 return 0;
1311         }
1312
1313
1314         /*
1315                 More parameters
1316         */
1317
1318         // Address to connect to
1319         std::string address = "";
1320
1321         if(cmd_args.exists("address"))
1322         {
1323                 address = cmd_args.get("address");
1324         }
1325         else
1326         {
1327                 address = g_settings.get("address");
1328         }
1329
1330         std::string playername = g_settings.get("name");
1331
1332         /*
1333                 Device initialization
1334         */
1335
1336         // Resolution selection
1337
1338         bool fullscreen = false;
1339         u16 screenW = g_settings.getU16("screenW");
1340         u16 screenH = g_settings.getU16("screenH");
1341
1342         // Determine driver
1343
1344         video::E_DRIVER_TYPE driverType;
1345
1346         std::string driverstring = g_settings.get("video_driver");
1347
1348         if(driverstring == "null")
1349                 driverType = video::EDT_NULL;
1350         else if(driverstring == "software")
1351                 driverType = video::EDT_SOFTWARE;
1352         else if(driverstring == "burningsvideo")
1353                 driverType = video::EDT_BURNINGSVIDEO;
1354         else if(driverstring == "direct3d8")
1355                 driverType = video::EDT_DIRECT3D8;
1356         else if(driverstring == "direct3d9")
1357                 driverType = video::EDT_DIRECT3D9;
1358         else if(driverstring == "opengl")
1359                 driverType = video::EDT_OPENGL;
1360         else
1361         {
1362                 dstream<<"WARNING: Invalid video_driver specified; defaulting "
1363                                 "to opengl"<<std::endl;
1364                 driverType = video::EDT_OPENGL;
1365         }
1366
1367         /*
1368                 Create device and exit if creation failed
1369         */
1370
1371         MyEventReceiver receiver;
1372
1373         IrrlichtDevice *device;
1374         device = createDevice(driverType,
1375                         core::dimension2d<u32>(screenW, screenH),
1376                         16, fullscreen, false, false, &receiver);
1377
1378         if (device == 0)
1379                 return 1; // could not create selected driver.
1380
1381         // Set the window caption
1382         device->setWindowCaption(L"Minetest [Main Menu]");
1383
1384         // Create time getter
1385         g_timegetter = new IrrlichtTimeGetter(device);
1386
1387         // Create game callback for menus
1388         g_gamecallback = new MainGameCallback(device);
1389
1390         // Create texture source
1391         g_texturesource = new TextureSource(device);
1392
1393         /*
1394                 Speed tests (done after irrlicht is loaded to get timer)
1395         */
1396         if(cmd_args.getFlag("speedtests"))
1397         {
1398                 dstream<<"Running speed tests"<<std::endl;
1399                 SpeedTests();
1400                 return 0;
1401         }
1402
1403         device->setResizable(true);
1404
1405         bool random_input = g_settings.getBool("random_input")
1406                         || cmd_args.getFlag("random-input");
1407         InputHandler *input = NULL;
1408         if(random_input)
1409                 input = new RandomInputHandler();
1410         else
1411                 input = new RealInputHandler(device, &receiver);
1412
1413         /*
1414                 Continue initialization
1415         */
1416
1417         //video::IVideoDriver* driver = device->getVideoDriver();
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         scene::ISceneManager* smgr = device->getSceneManager();
1426
1427         guienv = device->getGUIEnvironment();
1428         gui::IGUISkin* skin = guienv->getSkin();
1429         gui::IGUIFont* font = guienv->getFont(getTexturePath("fontlucida.png").c_str());
1430         if(font)
1431                 skin->setFont(font);
1432         else
1433                 dstream<<"WARNING: Font file was not found."
1434                                 " Using default font."<<std::endl;
1435         // If font was not found, this will get us one
1436         font = skin->getFont();
1437         assert(font);
1438
1439         u32 text_height = font->getDimension(L"Hello, world!").Height;
1440         dstream<<"text_height="<<text_height<<std::endl;
1441
1442         //skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255,0,0,0));
1443         skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255,255,255,255));
1444         //skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(0,0,0,0));
1445         //skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(0,0,0,0));
1446         skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(255,0,0,0));
1447         skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(255,0,0,0));
1448
1449         /*
1450                 Preload some textures and stuff
1451         */
1452
1453         init_mapnode(); // Second call with g_texturesource set
1454         init_mineral();
1455
1456         /*
1457                 GUI stuff
1458         */
1459
1460         /*
1461                 If an error occurs, this is set to something and the
1462                 menu-game loop is restarted. It is then displayed before
1463                 the menu.
1464         */
1465         std::wstring error_message = L"";
1466
1467         // The password entered during the menu screen,
1468         std::string password;
1469
1470         /*
1471                 Menu-game loop
1472         */
1473         while(device->run() && kill == false)
1474         {
1475
1476                 // This is used for catching disconnects
1477                 try
1478                 {
1479
1480                         /*
1481                                 Clear everything from the GUIEnvironment
1482                         */
1483                         guienv->clear();
1484
1485                         /*
1486                                 We need some kind of a root node to be able to add
1487                                 custom gui elements directly on the screen.
1488                                 Otherwise they won't be automatically drawn.
1489                         */
1490                         guiroot = guienv->addStaticText(L"",
1491                                         core::rect<s32>(0, 0, 10000, 10000));
1492
1493                         /*
1494                                 Out-of-game menu loop.
1495
1496                                 Loop quits when menu returns proper parameters.
1497                         */
1498                         while(kill == false)
1499                         {
1500                                 // Cursor can be non-visible when coming from the game
1501                                 device->getCursorControl()->setVisible(true);
1502                                 // Some stuff are left to scene manager when coming from the game
1503                                 // (map at least?)
1504                                 smgr->clear();
1505                                 // Reset or hide the debug gui texts
1506                                 /*guitext->setText(L"Minetest-c55");
1507                                 guitext2->setVisible(false);
1508                                 guitext_info->setVisible(false);
1509                                 guitext_chat->setVisible(false);*/
1510
1511                                 // Initialize menu data
1512                                 MainMenuData menudata;
1513                                 menudata.address = narrow_to_wide(address);
1514                                 menudata.name = narrow_to_wide(playername);
1515                                 menudata.port = narrow_to_wide(itos(port));
1516                                 menudata.fancy_trees = g_settings.getBool("new_style_leaves");
1517                                 menudata.smooth_lighting = g_settings.getBool("smooth_lighting");
1518                                 menudata.creative_mode = g_settings.getBool("creative_mode");
1519                                 menudata.enable_damage = g_settings.getBool("enable_damage");
1520
1521                                 GUIMainMenu *menu =
1522                                                 new GUIMainMenu(guienv, guiroot, -1,
1523                                                         &g_menumgr, &menudata, g_gamecallback);
1524                                 menu->allowFocusRemoval(true);
1525
1526                                 if(error_message != L"")
1527                                 {
1528                                         dstream<<"WARNING: error_message = "
1529                                                         <<wide_to_narrow(error_message)<<std::endl;
1530
1531                                         GUIMessageMenu *menu2 =
1532                                                         new GUIMessageMenu(guienv, guiroot, -1,
1533                                                                 &g_menumgr, error_message.c_str());
1534                                         menu2->drop();
1535                                         error_message = L"";
1536                                 }
1537
1538                                 video::IVideoDriver* driver = device->getVideoDriver();
1539
1540                                 dstream<<"Created main menu"<<std::endl;
1541
1542                                 while(device->run() && kill == false)
1543                                 {
1544                                         if(menu->getStatus() == true)
1545                                                 break;
1546
1547                                         //driver->beginScene(true, true, video::SColor(255,0,0,0));
1548                                         driver->beginScene(true, true, video::SColor(255,128,128,128));
1549
1550                                         drawMenuBackground(driver);
1551
1552                                         guienv->drawAll();
1553
1554                                         driver->endScene();
1555
1556                                         // On some computers framerate doesn't seem to be
1557                                         // automatically limited
1558                                         sleep_ms(25);
1559                                 }
1560
1561                                 // Break out of menu-game loop to shut down cleanly
1562                                 if(device->run() == false || kill == true)
1563                                         break;
1564
1565                                 dstream<<"Dropping main menu"<<std::endl;
1566
1567                                 menu->drop();
1568
1569                                 // Delete map if requested
1570                                 if(menudata.delete_map)
1571                                 {
1572                                         bool r = fs::RecursiveDeleteContent(map_dir);
1573                                         if(r == false)
1574                                                 error_message = L"Delete failed";
1575                                         continue;
1576                                 }
1577
1578                                 playername = wide_to_narrow(menudata.name);
1579
1580                                 password = translatePassword(playername, menudata.password);
1581
1582                                 //dstream<<"Main: password hash: '"<<password<<"'"<<std::endl;
1583
1584                                 address = wide_to_narrow(menudata.address);
1585                                 int newport = stoi(wide_to_narrow(menudata.port));
1586                                 if(newport != 0)
1587                                         port = newport;
1588                                 g_settings.set("new_style_leaves", itos(menudata.fancy_trees));
1589                                 g_settings.set("smooth_lighting", itos(menudata.smooth_lighting));
1590                                 g_settings.set("creative_mode", itos(menudata.creative_mode));
1591                                 g_settings.set("enable_damage", itos(menudata.enable_damage));
1592
1593                                 // NOTE: These are now checked server side; no need to do it
1594                                 //       here, so let's not do it here.
1595                                 /*// Check for valid parameters, restart menu if invalid.
1596                                 if(playername == "")
1597                                 {
1598                                         error_message = L"Name required.";
1599                                         continue;
1600                                 }
1601                                 // Check that name has only valid chars
1602                                 if(string_allowed(playername, PLAYERNAME_ALLOWED_CHARS)==false)
1603                                 {
1604                                         error_message = L"Characters allowed: "
1605                                                         +narrow_to_wide(PLAYERNAME_ALLOWED_CHARS);
1606                                         continue;
1607                                 }*/
1608
1609                                 // Save settings
1610                                 g_settings.set("name", playername);
1611                                 g_settings.set("address", address);
1612                                 g_settings.set("port", itos(port));
1613                                 // Update configuration file
1614                                 if(configpath != "")
1615                                         g_settings.updateConfigFile(configpath.c_str());
1616
1617                                 // Continue to game
1618                                 break;
1619                         }
1620
1621                         // Break out of menu-game loop to shut down cleanly
1622                         if(device->run() == false)
1623                                 break;
1624
1625                         // Initialize mapnode again to enable changed graphics settings
1626                         init_mapnode();
1627
1628                         /*
1629                                 Run game
1630                         */
1631                         the_game(
1632                                 kill,
1633                                 random_input,
1634                                 input,
1635                                 device,
1636                                 font,
1637                                 map_dir,
1638                                 playername,
1639                                 password,
1640                                 address,
1641                                 port,
1642                                 error_message,
1643                                 configpath
1644                         );
1645
1646                 } //try
1647                 catch(con::PeerNotFoundException &e)
1648                 {
1649                         dstream<<DTIME<<"Connection error (timed out?)"<<std::endl;
1650                         error_message = L"Connection error (timed out?)";
1651                 }
1652                 catch(SocketException &e)
1653                 {
1654                         dstream<<DTIME<<"Socket error (port already in use?)"<<std::endl;
1655                         error_message = L"Socket error (port already in use?)";
1656                 }
1657 #ifdef NDEBUG
1658                 catch(std::exception &e)
1659                 {
1660                         std::string narrow_message = "Some exception, what()=\"";
1661                         narrow_message += e.what();
1662                         narrow_message += "\"";
1663                         dstream<<DTIME<<narrow_message<<std::endl;
1664                         error_message = narrow_to_wide(narrow_message);
1665                 }
1666 #endif
1667
1668         } // Menu-game loop
1669
1670         delete input;
1671
1672         /*
1673                 In the end, delete the Irrlicht device.
1674         */
1675         device->drop();
1676
1677         END_DEBUG_EXCEPTION_HANDLER
1678
1679         debugstreams_deinit();
1680
1681         return 0;
1682 }
1683
1684 //END
1685