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