]> git.lizzy.rs Git - dragonfireclient.git/blob - src/main.cpp
Fix typo in lua_api.txt
[dragonfireclient.git] / src / main.cpp
1 /*
2 Minetest
3 Copyright (C) 2010-2013 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 Lesser General Public License as published by
7 the Free Software Foundation; either version 2.1 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 GNU Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20 #ifdef NDEBUG
21         /*#ifdef _WIN32
22                 #pragma message ("Disabling unit tests")
23         #else
24                 #warning "Disabling unit tests"
25         #endif*/
26         // Disable unit tests
27         #define ENABLE_TESTS 0
28 #else
29         // Enable unit tests
30         #define ENABLE_TESTS 1
31 #endif
32
33 #ifdef _MSC_VER
34 #ifndef SERVER // Dedicated server isn't linked with Irrlicht
35         #pragma comment(lib, "Irrlicht.lib")
36         // This would get rid of the console window
37         //#pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup")
38 #endif
39         #pragma comment(lib, "zlibwapi.lib")
40         #pragma comment(lib, "Shell32.lib")
41 #endif
42
43 #include "irrlicht.h" // createDevice
44
45 #include "main.h"
46 #include "mainmenumanager.h"
47 #include <iostream>
48 #include <fstream>
49 #include <locale.h>
50 #include "irrlichttypes_extrabloated.h"
51 #include "debug.h"
52 #include "test.h"
53 #include "clouds.h"
54 #include "server.h"
55 #include "constants.h"
56 #include "porting.h"
57 #include "gettime.h"
58 #include "guiMessageMenu.h"
59 #include "filesys.h"
60 #include "config.h"
61 #include "version.h"
62 #include "guiMainMenu.h"
63 #include "game.h"
64 #include "keycode.h"
65 #include "tile.h"
66 #include "chat.h"
67 #include "defaultsettings.h"
68 #include "gettext.h"
69 #include "settings.h"
70 #include "profiler.h"
71 #include "log.h"
72 #include "mods.h"
73 #if USE_FREETYPE
74 #include "xCGUITTFont.h"
75 #endif
76 #include "util/string.h"
77 #include "subgame.h"
78 #include "quicktune.h"
79 #include "serverlist.h"
80 #include "guiEngine.h"
81 #include "mapsector.h"
82
83 #include "database-sqlite3.h"
84 #ifdef USE_LEVELDB
85 #include "database-leveldb.h"
86 #endif
87
88 /*
89         Settings.
90         These are loaded from the config file.
91 */
92 Settings main_settings;
93 Settings *g_settings = &main_settings;
94 std::string g_settings_path;
95
96 // Global profiler
97 Profiler main_profiler;
98 Profiler *g_profiler = &main_profiler;
99
100 // Menu clouds are created later
101 Clouds *g_menuclouds = 0;
102 irr::scene::ISceneManager *g_menucloudsmgr = 0;
103
104 /*
105         Debug streams
106 */
107
108 // Connection
109 std::ostream *dout_con_ptr = &dummyout;
110 std::ostream *derr_con_ptr = &verbosestream;
111
112 // Server
113 std::ostream *dout_server_ptr = &infostream;
114 std::ostream *derr_server_ptr = &errorstream;
115
116 // Client
117 std::ostream *dout_client_ptr = &infostream;
118 std::ostream *derr_client_ptr = &errorstream;
119
120 #ifndef SERVER
121 /*
122         Random stuff
123 */
124
125 /* mainmenumanager.h */
126
127 gui::IGUIEnvironment* guienv = NULL;
128 gui::IGUIStaticText *guiroot = NULL;
129 MainMenuManager g_menumgr;
130
131 bool noMenuActive()
132 {
133         return (g_menumgr.menuCount() == 0);
134 }
135
136 // Passed to menus to allow disconnecting and exiting
137 MainGameCallback *g_gamecallback = NULL;
138 #endif
139
140 /*
141         gettime.h implementation
142 */
143
144 #ifdef SERVER
145
146 u32 getTimeMs()
147 {
148         /* Use imprecise system calls directly (from porting.h) */
149         return porting::getTime(PRECISION_MILLI);
150 }
151
152 u32 getTime(TimePrecision prec)
153 {
154         return porting::getTime(prec);
155 }
156
157 #else
158
159 // A small helper class
160 class TimeGetter
161 {
162 public:
163         virtual u32 getTime(TimePrecision prec) = 0;
164 };
165
166 // A precise irrlicht one
167 class IrrlichtTimeGetter: public TimeGetter
168 {
169 public:
170         IrrlichtTimeGetter(IrrlichtDevice *device):
171                 m_device(device)
172         {}
173         u32 getTime(TimePrecision prec)
174         {
175                 if (prec == PRECISION_MILLI) {
176                         if(m_device == NULL)
177                                 return 0;
178                         return m_device->getTimer()->getRealTime();
179                 } else {
180                         return porting::getTime(prec);
181                 }
182         }
183 private:
184         IrrlichtDevice *m_device;
185 };
186 // Not so precise one which works without irrlicht
187 class SimpleTimeGetter: public TimeGetter
188 {
189 public:
190         u32 getTime(TimePrecision prec)
191         {
192                 return porting::getTime(prec);
193         }
194 };
195
196 // A pointer to a global instance of the time getter
197 // TODO: why?
198 TimeGetter *g_timegetter = NULL;
199
200 u32 getTimeMs()
201 {
202         if(g_timegetter == NULL)
203                 return 0;
204         return g_timegetter->getTime(PRECISION_MILLI);
205 }
206
207 u32 getTime(TimePrecision prec) {
208         if (g_timegetter == NULL)
209                 return 0;
210         return g_timegetter->getTime(prec);
211 }
212 #endif
213
214 class StderrLogOutput: public ILogOutput
215 {
216 public:
217         /* line: Full line with timestamp, level and thread */
218         void printLog(const std::string &line)
219         {
220                 std::cerr<<line<<std::endl;
221         }
222 } main_stderr_log_out;
223
224 class DstreamNoStderrLogOutput: public ILogOutput
225 {
226 public:
227         /* line: Full line with timestamp, level and thread */
228         void printLog(const std::string &line)
229         {
230                 dstream_no_stderr<<line<<std::endl;
231         }
232 } main_dstream_no_stderr_log_out;
233
234 #ifndef SERVER
235
236 /*
237         Event handler for Irrlicht
238
239         NOTE: Everything possible should be moved out from here,
240               probably to InputHandler and the_game
241 */
242
243 class MyEventReceiver : public IEventReceiver
244 {
245 public:
246         // This is the one method that we have to implement
247         virtual bool OnEvent(const SEvent& event)
248         {
249                 /*
250                         React to nothing here if a menu is active
251                 */
252                 if(noMenuActive() == false)
253                 {
254                         return g_menumgr.preprocessEvent(event);
255                 }
256
257                 // Remember whether each key is down or up
258                 if(event.EventType == irr::EET_KEY_INPUT_EVENT)
259                 {
260                         if(event.KeyInput.PressedDown) {
261                                 keyIsDown.set(event.KeyInput);
262                                 keyWasDown.set(event.KeyInput);
263                         } else {
264                                 keyIsDown.unset(event.KeyInput);
265                         }
266                 }
267
268                 if(event.EventType == irr::EET_MOUSE_INPUT_EVENT)
269                 {
270                         if(noMenuActive() == false)
271                         {
272                                 left_active = false;
273                                 middle_active = false;
274                                 right_active = false;
275                         }
276                         else
277                         {
278                                 left_active = event.MouseInput.isLeftPressed();
279                                 middle_active = event.MouseInput.isMiddlePressed();
280                                 right_active = event.MouseInput.isRightPressed();
281
282                                 if(event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)
283                                 {
284                                         leftclicked = true;
285                                 }
286                                 if(event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN)
287                                 {
288                                         rightclicked = true;
289                                 }
290                                 if(event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP)
291                                 {
292                                         leftreleased = true;
293                                 }
294                                 if(event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP)
295                                 {
296                                         rightreleased = true;
297                                 }
298                                 if(event.MouseInput.Event == EMIE_MOUSE_WHEEL)
299                                 {
300                                         mouse_wheel += event.MouseInput.Wheel;
301                                 }
302                         }
303                 }
304
305                 return false;
306         }
307
308         bool IsKeyDown(const KeyPress &keyCode) const
309         {
310                 return keyIsDown[keyCode];
311         }
312         
313         // Checks whether a key was down and resets the state
314         bool WasKeyDown(const KeyPress &keyCode)
315         {
316                 bool b = keyWasDown[keyCode];
317                 if (b)
318                         keyWasDown.unset(keyCode);
319                 return b;
320         }
321
322         s32 getMouseWheel()
323         {
324                 s32 a = mouse_wheel;
325                 mouse_wheel = 0;
326                 return a;
327         }
328
329         void clearInput()
330         {
331                 keyIsDown.clear();
332                 keyWasDown.clear();
333
334                 leftclicked = false;
335                 rightclicked = false;
336                 leftreleased = false;
337                 rightreleased = false;
338
339                 left_active = false;
340                 middle_active = false;
341                 right_active = false;
342
343                 mouse_wheel = 0;
344         }
345
346         MyEventReceiver()
347         {
348                 clearInput();
349         }
350
351         bool leftclicked;
352         bool rightclicked;
353         bool leftreleased;
354         bool rightreleased;
355
356         bool left_active;
357         bool middle_active;
358         bool right_active;
359
360         s32 mouse_wheel;
361
362 private:
363         IrrlichtDevice *m_device;
364         
365         // The current state of keys
366         KeyList keyIsDown;
367         // Whether a key has been pressed or not
368         KeyList keyWasDown;
369 };
370
371 /*
372         Separated input handler
373 */
374
375 class RealInputHandler : public InputHandler
376 {
377 public:
378         RealInputHandler(IrrlichtDevice *device, MyEventReceiver *receiver):
379                 m_device(device),
380                 m_receiver(receiver)
381         {
382         }
383         virtual bool isKeyDown(const KeyPress &keyCode)
384         {
385                 return m_receiver->IsKeyDown(keyCode);
386         }
387         virtual bool wasKeyDown(const KeyPress &keyCode)
388         {
389                 return m_receiver->WasKeyDown(keyCode);
390         }
391         virtual v2s32 getMousePos()
392         {
393                 return m_device->getCursorControl()->getPosition();
394         }
395         virtual void setMousePos(s32 x, s32 y)
396         {
397                 m_device->getCursorControl()->setPosition(x, y);
398         }
399
400         virtual bool getLeftState()
401         {
402                 return m_receiver->left_active;
403         }
404         virtual bool getRightState()
405         {
406                 return m_receiver->right_active;
407         }
408         
409         virtual bool getLeftClicked()
410         {
411                 return m_receiver->leftclicked;
412         }
413         virtual bool getRightClicked()
414         {
415                 return m_receiver->rightclicked;
416         }
417         virtual void resetLeftClicked()
418         {
419                 m_receiver->leftclicked = false;
420         }
421         virtual void resetRightClicked()
422         {
423                 m_receiver->rightclicked = false;
424         }
425
426         virtual bool getLeftReleased()
427         {
428                 return m_receiver->leftreleased;
429         }
430         virtual bool getRightReleased()
431         {
432                 return m_receiver->rightreleased;
433         }
434         virtual void resetLeftReleased()
435         {
436                 m_receiver->leftreleased = false;
437         }
438         virtual void resetRightReleased()
439         {
440                 m_receiver->rightreleased = false;
441         }
442
443         virtual s32 getMouseWheel()
444         {
445                 return m_receiver->getMouseWheel();
446         }
447
448         void clear()
449         {
450                 m_receiver->clearInput();
451         }
452 private:
453         IrrlichtDevice *m_device;
454         MyEventReceiver *m_receiver;
455 };
456
457 class RandomInputHandler : public InputHandler
458 {
459 public:
460         RandomInputHandler()
461         {
462                 leftdown = false;
463                 rightdown = false;
464                 leftclicked = false;
465                 rightclicked = false;
466                 leftreleased = false;
467                 rightreleased = false;
468                 keydown.clear();
469         }
470         virtual bool isKeyDown(const KeyPress &keyCode)
471         {
472                 return keydown[keyCode];
473         }
474         virtual bool wasKeyDown(const KeyPress &keyCode)
475         {
476                 return false;
477         }
478         virtual v2s32 getMousePos()
479         {
480                 return mousepos;
481         }
482         virtual void setMousePos(s32 x, s32 y)
483         {
484                 mousepos = v2s32(x,y);
485         }
486
487         virtual bool getLeftState()
488         {
489                 return leftdown;
490         }
491         virtual bool getRightState()
492         {
493                 return rightdown;
494         }
495
496         virtual bool getLeftClicked()
497         {
498                 return leftclicked;
499         }
500         virtual bool getRightClicked()
501         {
502                 return rightclicked;
503         }
504         virtual void resetLeftClicked()
505         {
506                 leftclicked = false;
507         }
508         virtual void resetRightClicked()
509         {
510                 rightclicked = false;
511         }
512
513         virtual bool getLeftReleased()
514         {
515                 return leftreleased;
516         }
517         virtual bool getRightReleased()
518         {
519                 return rightreleased;
520         }
521         virtual void resetLeftReleased()
522         {
523                 leftreleased = false;
524         }
525         virtual void resetRightReleased()
526         {
527                 rightreleased = false;
528         }
529
530         virtual s32 getMouseWheel()
531         {
532                 return 0;
533         }
534
535         virtual void step(float dtime)
536         {
537                 {
538                         static float counter1 = 0;
539                         counter1 -= dtime;
540                         if(counter1 < 0.0)
541                         {
542                                 counter1 = 0.1*Rand(1, 40);
543                                 keydown.toggle(getKeySetting("keymap_jump"));
544                         }
545                 }
546                 {
547                         static float counter1 = 0;
548                         counter1 -= dtime;
549                         if(counter1 < 0.0)
550                         {
551                                 counter1 = 0.1*Rand(1, 40);
552                                 keydown.toggle(getKeySetting("keymap_special1"));
553                         }
554                 }
555                 {
556                         static float counter1 = 0;
557                         counter1 -= dtime;
558                         if(counter1 < 0.0)
559                         {
560                                 counter1 = 0.1*Rand(1, 40);
561                                 keydown.toggle(getKeySetting("keymap_forward"));
562                         }
563                 }
564                 {
565                         static float counter1 = 0;
566                         counter1 -= dtime;
567                         if(counter1 < 0.0)
568                         {
569                                 counter1 = 0.1*Rand(1, 40);
570                                 keydown.toggle(getKeySetting("keymap_left"));
571                         }
572                 }
573                 {
574                         static float counter1 = 0;
575                         counter1 -= dtime;
576                         if(counter1 < 0.0)
577                         {
578                                 counter1 = 0.1*Rand(1, 20);
579                                 mousespeed = v2s32(Rand(-20,20), Rand(-15,20));
580                         }
581                 }
582                 {
583                         static float counter1 = 0;
584                         counter1 -= dtime;
585                         if(counter1 < 0.0)
586                         {
587                                 counter1 = 0.1*Rand(1, 30);
588                                 leftdown = !leftdown;
589                                 if(leftdown)
590                                         leftclicked = true;
591                                 if(!leftdown)
592                                         leftreleased = true;
593                         }
594                 }
595                 {
596                         static float counter1 = 0;
597                         counter1 -= dtime;
598                         if(counter1 < 0.0)
599                         {
600                                 counter1 = 0.1*Rand(1, 15);
601                                 rightdown = !rightdown;
602                                 if(rightdown)
603                                         rightclicked = true;
604                                 if(!rightdown)
605                                         rightreleased = true;
606                         }
607                 }
608                 mousepos += mousespeed;
609         }
610
611         s32 Rand(s32 min, s32 max)
612         {
613                 return (myrand()%(max-min+1))+min;
614         }
615 private:
616         KeyList keydown;
617         v2s32 mousepos;
618         v2s32 mousespeed;
619         bool leftdown;
620         bool rightdown;
621         bool leftclicked;
622         bool rightclicked;
623         bool leftreleased;
624         bool rightreleased;
625 };
626
627 #endif // !SERVER
628
629 // These are defined global so that they're not optimized too much.
630 // Can't change them to volatile.
631 s16 temp16;
632 f32 tempf;
633 v3f tempv3f1;
634 v3f tempv3f2;
635 std::string tempstring;
636 std::string tempstring2;
637
638 void SpeedTests()
639 {
640         {
641                 infostream<<"The following test should take around 20ms."<<std::endl;
642                 TimeTaker timer("Testing std::string speed");
643                 const u32 jj = 10000;
644                 for(u32 j=0; j<jj; j++)
645                 {
646                         tempstring = "";
647                         tempstring2 = "";
648                         const u32 ii = 10;
649                         for(u32 i=0; i<ii; i++){
650                                 tempstring2 += "asd";
651                         }
652                         for(u32 i=0; i<ii+1; i++){
653                                 tempstring += "asd";
654                                 if(tempstring == tempstring2)
655                                         break;
656                         }
657                 }
658         }
659         
660         infostream<<"All of the following tests should take around 100ms each."
661                         <<std::endl;
662
663         {
664                 TimeTaker timer("Testing floating-point conversion speed");
665                 tempf = 0.001;
666                 for(u32 i=0; i<4000000; i++){
667                         temp16 += tempf;
668                         tempf += 0.001;
669                 }
670         }
671         
672         {
673                 TimeTaker timer("Testing floating-point vector speed");
674
675                 tempv3f1 = v3f(1,2,3);
676                 tempv3f2 = v3f(4,5,6);
677                 for(u32 i=0; i<10000000; i++){
678                         tempf += tempv3f1.dotProduct(tempv3f2);
679                         tempv3f2 += v3f(7,8,9);
680                 }
681         }
682
683         {
684                 TimeTaker timer("Testing std::map speed");
685                 
686                 std::map<v2s16, f32> map1;
687                 tempf = -324;
688                 const s16 ii=300;
689                 for(s16 y=0; y<ii; y++){
690                         for(s16 x=0; x<ii; x++){
691                                 map1[v2s16(x,y)] =  tempf;
692                                 tempf += 1;
693                         }
694                 }
695                 for(s16 y=ii-1; y>=0; y--){
696                         for(s16 x=0; x<ii; x++){
697                                 tempf = map1[v2s16(x,y)];
698                         }
699                 }
700         }
701
702         {
703                 infostream<<"Around 5000/ms should do well here."<<std::endl;
704                 TimeTaker timer("Testing mutex speed");
705                 
706                 JMutex m;
707                 m.Init();
708                 u32 n = 0;
709                 u32 i = 0;
710                 do{
711                         n += 10000;
712                         for(; i<n; i++){
713                                 m.Lock();
714                                 m.Unlock();
715                         }
716                 }
717                 // Do at least 10ms
718                 while(timer.getTimerTime() < 10);
719
720                 u32 dtime = timer.stop();
721                 u32 per_ms = n / dtime;
722                 infostream<<"Done. "<<dtime<<"ms, "
723                                 <<per_ms<<"/ms"<<std::endl;
724         }
725 }
726
727 static void print_worldspecs(const std::vector<WorldSpec> &worldspecs,
728                 std::ostream &os)
729 {
730         for(u32 i=0; i<worldspecs.size(); i++){
731                 std::string name = worldspecs[i].name;
732                 std::string path = worldspecs[i].path;
733                 if(name.find(" ") != std::string::npos)
734                         name = std::string("'") + name + "'";
735                 path = std::string("'") + path + "'";
736                 name = padStringRight(name, 14);
737                 os<<"  "<<name<<" "<<path<<std::endl;
738         }
739 }
740
741 int main(int argc, char *argv[])
742 {
743         int retval = 0;
744
745         /*
746                 Initialization
747         */
748
749         log_add_output_maxlev(&main_stderr_log_out, LMT_ACTION);
750         log_add_output_all_levs(&main_dstream_no_stderr_log_out);
751
752         log_register_thread("main");
753
754         // This enables internatonal characters input
755         if( setlocale(LC_ALL, "") == NULL )
756         {
757                 fprintf( stderr, "%s: warning: could not set default locale\n", argv[0] );
758         }
759
760         // Set locale. This is for forcing '.' as the decimal point.
761         try {
762                 std::locale::global(std::locale(std::locale(""), "C", std::locale::numeric));
763                 setlocale(LC_NUMERIC, "C");
764         } catch (const std::exception& ex) {
765                 errorstream<<"Could not set numeric locale to C"<<std::endl;
766         }
767         /*
768                 Parse command line
769         */
770         
771         // List all allowed options
772         std::map<std::string, ValueSpec> allowed_options;
773         allowed_options.insert(std::make_pair("help", ValueSpec(VALUETYPE_FLAG,
774                         _("Show allowed options"))));
775         allowed_options.insert(std::make_pair("version", ValueSpec(VALUETYPE_FLAG,
776                         _("Show version information"))));
777         allowed_options.insert(std::make_pair("config", ValueSpec(VALUETYPE_STRING,
778                         _("Load configuration from specified file"))));
779         allowed_options.insert(std::make_pair("port", ValueSpec(VALUETYPE_STRING,
780                         _("Set network port (UDP)"))));
781         allowed_options.insert(std::make_pair("disable-unittests", ValueSpec(VALUETYPE_FLAG,
782                         _("Disable unit tests"))));
783         allowed_options.insert(std::make_pair("enable-unittests", ValueSpec(VALUETYPE_FLAG,
784                         _("Enable unit tests"))));
785         allowed_options.insert(std::make_pair("map-dir", ValueSpec(VALUETYPE_STRING,
786                         _("Same as --world (deprecated)"))));
787         allowed_options.insert(std::make_pair("world", ValueSpec(VALUETYPE_STRING,
788                         _("Set world path (implies local game) ('list' lists all)"))));
789         allowed_options.insert(std::make_pair("worldname", ValueSpec(VALUETYPE_STRING,
790                         _("Set world by name (implies local game)"))));
791         allowed_options.insert(std::make_pair("info", ValueSpec(VALUETYPE_FLAG,
792                         _("Print more information to console"))));
793         allowed_options.insert(std::make_pair("verbose",  ValueSpec(VALUETYPE_FLAG,
794                         _("Print even more information to console"))));
795         allowed_options.insert(std::make_pair("trace", ValueSpec(VALUETYPE_FLAG,
796                         _("Print enormous amounts of information to log and console"))));
797         allowed_options.insert(std::make_pair("logfile", ValueSpec(VALUETYPE_STRING,
798                         _("Set logfile path ('' = no logging)"))));
799         allowed_options.insert(std::make_pair("gameid", ValueSpec(VALUETYPE_STRING,
800                         _("Set gameid (\"--gameid list\" prints available ones)"))));
801         allowed_options.insert(std::make_pair("migrate", ValueSpec(VALUETYPE_STRING,
802                         _("Migrate from current map backend to another (Only works when using minetestserver or with --server)"))));
803 #ifndef SERVER
804         allowed_options.insert(std::make_pair("videomodes", ValueSpec(VALUETYPE_FLAG,
805                         _("Show available video modes"))));
806         allowed_options.insert(std::make_pair("speedtests", ValueSpec(VALUETYPE_FLAG,
807                         _("Run speed tests"))));
808         allowed_options.insert(std::make_pair("address", ValueSpec(VALUETYPE_STRING,
809                         _("Address to connect to. ('' = local game)"))));
810         allowed_options.insert(std::make_pair("random-input", ValueSpec(VALUETYPE_FLAG,
811                         _("Enable random user input, for testing"))));
812         allowed_options.insert(std::make_pair("server", ValueSpec(VALUETYPE_FLAG,
813                         _("Run dedicated server"))));
814         allowed_options.insert(std::make_pair("name", ValueSpec(VALUETYPE_STRING,
815                         _("Set player name"))));
816         allowed_options.insert(std::make_pair("password", ValueSpec(VALUETYPE_STRING,
817                         _("Set password"))));
818         allowed_options.insert(std::make_pair("go", ValueSpec(VALUETYPE_FLAG,
819                         _("Disable main menu"))));
820 #endif
821
822         Settings cmd_args;
823         
824         bool ret = cmd_args.parseCommandLine(argc, argv, allowed_options);
825
826         if(ret == false || cmd_args.getFlag("help") || cmd_args.exists("nonopt1"))
827         {
828                 dstream<<_("Allowed options:")<<std::endl;
829                 for(std::map<std::string, ValueSpec>::iterator
830                                 i = allowed_options.begin();
831                                 i != allowed_options.end(); ++i)
832                 {
833                         std::ostringstream os1(std::ios::binary);
834                         os1<<"  --"<<i->first;
835                         if(i->second.type == VALUETYPE_FLAG)
836                                 {}
837                         else
838                                 os1<<_(" <value>");
839                         dstream<<padStringRight(os1.str(), 24);
840
841                         if(i->second.help != NULL)
842                                 dstream<<i->second.help;
843                         dstream<<std::endl;
844                 }
845
846                 return cmd_args.getFlag("help") ? 0 : 1;
847         }
848
849         if(cmd_args.getFlag("version"))
850         {
851 #ifdef SERVER
852                 dstream<<"minetestserver "<<minetest_version_hash<<std::endl;
853 #else
854                 dstream<<"Minetest "<<minetest_version_hash<<std::endl;
855                 dstream<<"Using Irrlicht "<<IRRLICHT_SDK_VERSION<<std::endl;
856 #endif
857                 dstream<<"Build info: "<<minetest_build_info<<std::endl;
858                 return 0;
859         }
860         
861         /*
862                 Low-level initialization
863         */
864         
865         // If trace is enabled, enable logging of certain things
866         if(cmd_args.getFlag("trace")){
867                 dstream<<_("Enabling trace level debug output")<<std::endl;
868                 log_trace_level_enabled = true;
869                 dout_con_ptr = &verbosestream; // this is somewhat old crap
870                 socket_enable_debug_output = true; // socket doesn't use log.h
871         }
872         // In certain cases, output info level on stderr
873         if(cmd_args.getFlag("info") || cmd_args.getFlag("verbose") ||
874                         cmd_args.getFlag("trace") || cmd_args.getFlag("speedtests"))
875                 log_add_output(&main_stderr_log_out, LMT_INFO);
876         // In certain cases, output verbose level on stderr
877         if(cmd_args.getFlag("verbose") || cmd_args.getFlag("trace"))
878                 log_add_output(&main_stderr_log_out, LMT_VERBOSE);
879
880         porting::signal_handler_init();
881         bool &kill = *porting::signal_handler_killstatus();
882         
883         porting::initializePaths();
884
885         // Create user data directory
886         fs::CreateDir(porting::path_user);
887
888         init_gettext((porting::path_share + DIR_DELIM + "locale").c_str());
889
890         infostream<<"path_share = "<<porting::path_share<<std::endl;
891         infostream<<"path_user  = "<<porting::path_user<<std::endl;
892
893         // Initialize debug stacks
894         debug_stacks_init();
895         DSTACK(__FUNCTION_NAME);
896
897         // Debug handler
898         BEGIN_DEBUG_EXCEPTION_HANDLER
899         
900         // List gameids if requested
901         if(cmd_args.exists("gameid") && cmd_args.get("gameid") == "list")
902         {
903                 std::set<std::string> gameids = getAvailableGameIds();
904                 for(std::set<std::string>::const_iterator i = gameids.begin();
905                                 i != gameids.end(); i++)
906                         dstream<<(*i)<<std::endl;
907                 return 0;
908         }
909         
910         // List worlds if requested
911         if(cmd_args.exists("world") && cmd_args.get("world") == "list"){
912                 dstream<<_("Available worlds:")<<std::endl;
913                 std::vector<WorldSpec> worldspecs = getAvailableWorlds();
914                 print_worldspecs(worldspecs, dstream);
915                 return 0;
916         }
917
918         // Print startup message
919         infostream<<PROJECT_NAME<<
920                         " "<<_("with")<<" SER_FMT_VER_HIGHEST_READ="<<(int)SER_FMT_VER_HIGHEST_READ
921                         <<", "<<minetest_build_info
922                         <<std::endl;
923         
924         /*
925                 Basic initialization
926         */
927
928         // Initialize default settings
929         set_default_settings(g_settings);
930         
931         // Initialize sockets
932         sockets_init();
933         atexit(sockets_cleanup);
934         
935         /*
936                 Read config file
937         */
938         
939         // Path of configuration file in use
940         g_settings_path = "";
941         
942         if(cmd_args.exists("config"))
943         {
944                 bool r = g_settings->readConfigFile(cmd_args.get("config").c_str());
945                 if(r == false)
946                 {
947                         errorstream<<"Could not read configuration from \""
948                                         <<cmd_args.get("config")<<"\""<<std::endl;
949                         return 1;
950                 }
951                 g_settings_path = cmd_args.get("config");
952         }
953         else
954         {
955                 std::vector<std::string> filenames;
956                 filenames.push_back(porting::path_user +
957                                 DIR_DELIM + "minetest.conf");
958                 // Legacy configuration file location
959                 filenames.push_back(porting::path_user +
960                                 DIR_DELIM + ".." + DIR_DELIM + "minetest.conf");
961 #if RUN_IN_PLACE
962                 // Try also from a lower level (to aid having the same configuration
963                 // for many RUN_IN_PLACE installs)
964                 filenames.push_back(porting::path_user +
965                                 DIR_DELIM + ".." + DIR_DELIM + ".." + DIR_DELIM + "minetest.conf");
966 #endif
967
968                 for(u32 i=0; i<filenames.size(); i++)
969                 {
970                         bool r = g_settings->readConfigFile(filenames[i].c_str());
971                         if(r)
972                         {
973                                 g_settings_path = filenames[i];
974                                 break;
975                         }
976                 }
977                 
978                 // If no path found, use the first one (menu creates the file)
979                 if(g_settings_path == "")
980                         g_settings_path = filenames[0];
981         }
982         
983         // Initialize debug streams
984 #define DEBUGFILE "debug.txt"
985 #if RUN_IN_PLACE
986         std::string logfile = DEBUGFILE;
987 #else
988         std::string logfile = porting::path_user+DIR_DELIM+DEBUGFILE;
989 #endif
990         if(cmd_args.exists("logfile"))
991                 logfile = cmd_args.get("logfile");
992         
993         log_remove_output(&main_dstream_no_stderr_log_out);
994         int loglevel = g_settings->getS32("debug_log_level");
995
996         if (loglevel == 0) //no logging
997                 logfile = "";
998         else if (loglevel > 0 && loglevel <= LMT_NUM_VALUES)
999                 log_add_output_maxlev(&main_dstream_no_stderr_log_out, (LogMessageLevel)(loglevel - 1));
1000
1001         if(logfile != "")
1002                 debugstreams_init(false, logfile.c_str());
1003         else
1004                 debugstreams_init(false, NULL);
1005                 
1006         infostream<<"logfile    = "<<logfile<<std::endl;
1007
1008         // Initialize random seed
1009         srand(time(0));
1010         mysrand(time(0));
1011
1012         /*
1013                 Run unit tests
1014         */
1015
1016         if((ENABLE_TESTS && cmd_args.getFlag("disable-unittests") == false)
1017                         || cmd_args.getFlag("enable-unittests") == true)
1018         {
1019                 run_tests();
1020         }
1021
1022         std::string language = g_settings->get("language");
1023         if (language.length()) {
1024 #ifndef _WIN32
1025                 setenv("LANGUAGE", language.c_str(), 1);
1026 #else
1027                 char *lang_str = (char*)calloc(10 + language.length(), sizeof(char));
1028                 strcat(lang_str, "LANGUAGE=");
1029                 strcat(lang_str, language.c_str());
1030                 putenv(lang_str);
1031 #endif
1032         }
1033
1034         /*
1035                 Game parameters
1036         */
1037
1038         // Port
1039         u16 port = 30000;
1040         if(cmd_args.exists("port"))
1041                 port = cmd_args.getU16("port");
1042         else if(g_settings->exists("port"))
1043                 port = g_settings->getU16("port");
1044         if(port == 0)
1045                 port = 30000;
1046         
1047         // World directory
1048         std::string commanded_world = "";
1049         if(cmd_args.exists("world"))
1050                 commanded_world = cmd_args.get("world");
1051         else if(cmd_args.exists("map-dir"))
1052                 commanded_world = cmd_args.get("map-dir");
1053         else if(cmd_args.exists("nonopt0")) // First nameless argument
1054                 commanded_world = cmd_args.get("nonopt0");
1055         else if(g_settings->exists("map-dir"))
1056                 commanded_world = g_settings->get("map-dir");
1057         
1058         // World name
1059         std::string commanded_worldname = "";
1060         if(cmd_args.exists("worldname"))
1061                 commanded_worldname = cmd_args.get("worldname");
1062         
1063         // Strip world.mt from commanded_world
1064         {
1065                 std::string worldmt = "world.mt";
1066                 if(commanded_world.size() > worldmt.size() &&
1067                                 commanded_world.substr(commanded_world.size()-worldmt.size())
1068                                 == worldmt){
1069                         dstream<<_("Supplied world.mt file - stripping it off.")<<std::endl;
1070                         commanded_world = commanded_world.substr(
1071                                         0, commanded_world.size()-worldmt.size());
1072                 }
1073         }
1074         
1075         // If a world name was specified, convert it to a path
1076         if(commanded_worldname != ""){
1077                 // Get information about available worlds
1078                 std::vector<WorldSpec> worldspecs = getAvailableWorlds();
1079                 bool found = false;
1080                 for(u32 i=0; i<worldspecs.size(); i++){
1081                         std::string name = worldspecs[i].name;
1082                         if(name == commanded_worldname){
1083                                 if(commanded_world != ""){
1084                                         dstream<<_("--worldname takes precedence over previously "
1085                                                         "selected world.")<<std::endl;
1086                                 }
1087                                 commanded_world = worldspecs[i].path;
1088                                 found = true;
1089                                 break;
1090                         }
1091                 }
1092                 if(!found){
1093                         dstream<<_("World")<<" '"<<commanded_worldname<<_("' not "
1094                                         "available. Available worlds:")<<std::endl;
1095                         print_worldspecs(worldspecs, dstream);
1096                         return 1;
1097                 }
1098         }
1099
1100         // Gamespec
1101         SubgameSpec commanded_gamespec;
1102         if(cmd_args.exists("gameid")){
1103                 std::string gameid = cmd_args.get("gameid");
1104                 commanded_gamespec = findSubgame(gameid);
1105                 if(!commanded_gamespec.isValid()){
1106                         errorstream<<"Game \""<<gameid<<"\" not found"<<std::endl;
1107                         return 1;
1108                 }
1109         }
1110
1111
1112         /*
1113                 Run dedicated server if asked to or no other option
1114         */
1115 #ifdef SERVER
1116         bool run_dedicated_server = true;
1117 #else
1118         bool run_dedicated_server = cmd_args.getFlag("server");
1119 #endif
1120         g_settings->set("server_dedicated", run_dedicated_server ? "true" : "false");
1121         if(run_dedicated_server)
1122         {
1123                 DSTACK("Dedicated server branch");
1124                 // Create time getter if built with Irrlicht
1125 #ifndef SERVER
1126                 g_timegetter = new SimpleTimeGetter();
1127 #endif
1128
1129                 // World directory
1130                 std::string world_path;
1131                 verbosestream<<_("Determining world path")<<std::endl;
1132                 bool is_legacy_world = false;
1133                 // If a world was commanded, use it
1134                 if(commanded_world != ""){
1135                         world_path = commanded_world;
1136                         infostream<<"Using commanded world path ["<<world_path<<"]"
1137                                         <<std::endl;
1138                 }
1139                 // No world was specified; try to select it automatically
1140                 else
1141                 {
1142                         // Get information about available worlds
1143                         std::vector<WorldSpec> worldspecs = getAvailableWorlds();
1144                         // If a world name was specified, select it
1145                         if(commanded_worldname != ""){
1146                                 world_path = "";
1147                                 for(u32 i=0; i<worldspecs.size(); i++){
1148                                         std::string name = worldspecs[i].name;
1149                                         if(name == commanded_worldname){
1150                                                 world_path = worldspecs[i].path;
1151                                                 break;
1152                                         }
1153                                 }
1154                                 if(world_path == ""){
1155                                         dstream<<_("World")<<" '"<<commanded_worldname<<"' "<<_("not "
1156                                                         "available. Available worlds:")<<std::endl;
1157                                         print_worldspecs(worldspecs, dstream);
1158                                         return 1;
1159                                 }
1160                         }
1161                         // If there is only a single world, use it
1162                         if(worldspecs.size() == 1){
1163                                 world_path = worldspecs[0].path;
1164                                 dstream<<_("Automatically selecting world at")<<" ["
1165                                                 <<world_path<<"]"<<std::endl;
1166                         // If there are multiple worlds, list them
1167                         } else if(worldspecs.size() > 1){
1168                                 dstream<<_("Multiple worlds are available.")<<std::endl;
1169                                 dstream<<_("Please select one using --worldname <name>"
1170                                                 " or --world <path>")<<std::endl;
1171                                 print_worldspecs(worldspecs, dstream);
1172                                 return 1;
1173                         // If there are no worlds, automatically create a new one
1174                         } else {
1175                                 // This is the ultimate default world path
1176                                 world_path = porting::path_user + DIR_DELIM + "worlds" +
1177                                                 DIR_DELIM + "world";
1178                                 infostream<<"Creating default world at ["
1179                                                 <<world_path<<"]"<<std::endl;
1180                         }
1181                 }
1182
1183                 if(world_path == ""){
1184                         errorstream<<"No world path specified or found."<<std::endl;
1185                         return 1;
1186                 }
1187                 verbosestream<<_("Using world path")<<" ["<<world_path<<"]"<<std::endl;
1188
1189                 // We need a gamespec.
1190                 SubgameSpec gamespec;
1191                 verbosestream<<_("Determining gameid/gamespec")<<std::endl;
1192                 // If world doesn't exist
1193                 if(!getWorldExists(world_path))
1194                 {
1195                         // Try to take gamespec from command line
1196                         if(commanded_gamespec.isValid()){
1197                                 gamespec = commanded_gamespec;
1198                                 infostream<<"Using commanded gameid ["<<gamespec.id<<"]"<<std::endl;
1199                         }
1200                         // Otherwise we will be using "minetest"
1201                         else{
1202                                 gamespec = findSubgame(g_settings->get("default_game"));
1203                                 infostream<<"Using default gameid ["<<gamespec.id<<"]"<<std::endl;
1204                         }
1205                 }
1206                 // World exists
1207                 else
1208                 {
1209                         std::string world_gameid = getWorldGameId(world_path, is_legacy_world);
1210                         // If commanded to use a gameid, do so
1211                         if(commanded_gamespec.isValid()){
1212                                 gamespec = commanded_gamespec;
1213                                 if(commanded_gamespec.id != world_gameid){
1214                                         errorstream<<"WARNING: Using commanded gameid ["
1215                                                         <<gamespec.id<<"]"<<" instead of world gameid ["
1216                                                         <<world_gameid<<"]"<<std::endl;
1217                                 }
1218                         } else{
1219                                 // If world contains an embedded game, use it;
1220                                 // Otherwise find world from local system.
1221                                 gamespec = findWorldSubgame(world_path);
1222                                 infostream<<"Using world gameid ["<<gamespec.id<<"]"<<std::endl;
1223                         }
1224                 }
1225                 if(!gamespec.isValid()){
1226                         errorstream<<"Subgame ["<<gamespec.id<<"] could not be found."
1227                                         <<std::endl;
1228                         return 1;
1229                 }
1230                 verbosestream<<_("Using gameid")<<" ["<<gamespec.id<<"]"<<std::endl;
1231
1232                 // Create server
1233                 Server server(world_path, gamespec, false);
1234
1235                 // Database migration
1236                 if (cmd_args.exists("migrate")) {
1237                         std::string migrate_to = cmd_args.get("migrate");
1238                         Settings world_mt;
1239                         bool success = world_mt.readConfigFile((world_path + DIR_DELIM + "world.mt").c_str());
1240                         if (!success) {
1241                                 errorstream << "Cannot read world.mt" << std::endl;
1242                                 return 1;
1243                         }
1244                         if (!world_mt.exists("backend")) {
1245                                 errorstream << "Please specify your current backend in world.mt file:"
1246                                         << std::endl << "       backend = {sqlite3|leveldb|dummy}" << std::endl;
1247                                 return 1;
1248                         }
1249                         std::string backend = world_mt.get("backend");
1250                         Database *new_db;
1251                         if (backend == migrate_to) {
1252                                 errorstream << "Cannot migrate: new backend is same as the old one" << std::endl;
1253                                 return 1;
1254                         }
1255                         if (migrate_to == "sqlite3")
1256                                 new_db = new Database_SQLite3(&(ServerMap&)server.getMap(), world_path);
1257                         #if USE_LEVELDB
1258                         else if (migrate_to == "leveldb")
1259                                 new_db = new Database_LevelDB(&(ServerMap&)server.getMap(), world_path);
1260                         #endif
1261                         else {
1262                                 errorstream << "Migration to " << migrate_to << " is not supported" << std::endl;
1263                                 return 1;
1264                         }
1265
1266                         std::list<v3s16> blocks;
1267                         ServerMap &old_map = ((ServerMap&)server.getMap());
1268                         old_map.listAllLoadableBlocks(blocks);
1269                         int count = 0;
1270                         new_db->beginSave();
1271                         for (std::list<v3s16>::iterator i = blocks.begin(); i != blocks.end(); ++i) {
1272                                 MapBlock *block = old_map.loadBlock(*i);
1273                                 new_db->saveBlock(block);
1274                                 MapSector *sector = old_map.getSectorNoGenerate(v2s16(i->X, i->Z));
1275                                 sector->deleteBlock(block);
1276                                 ++count;
1277                                 if (count % 500 == 0)
1278                                         actionstream << "Migrated " << count << " blocks "
1279                                                 << (100.0 * count / blocks.size()) << "\% completed" << std::endl;
1280                         }
1281                         new_db->endSave();
1282
1283                         actionstream << "Successfully migrated " << count << " blocks" << std::endl;
1284                         world_mt.set("backend", migrate_to);
1285                         if(!world_mt.updateConfigFile((world_path + DIR_DELIM + "world.mt").c_str()))
1286                                 errorstream<<"Failed to update world.mt!"<<std::endl;
1287                         else
1288                                 actionstream<<"world.mt updated"<<std::endl;
1289
1290                         return 0;
1291                 }
1292
1293                 server.start(port);
1294                 
1295                 // Run server
1296                 dedicated_server_loop(server, kill);
1297
1298                 return 0;
1299         }
1300
1301 #ifndef SERVER // Exclude from dedicated server build
1302
1303         /*
1304                 More parameters
1305         */
1306         
1307         std::string address = g_settings->get("address");
1308         if(commanded_world != "")
1309                 address = "";
1310         else if(cmd_args.exists("address"))
1311                 address = cmd_args.get("address");
1312         
1313         std::string playername = g_settings->get("name");
1314         if(cmd_args.exists("name"))
1315                 playername = cmd_args.get("name");
1316         
1317         bool skip_main_menu = cmd_args.getFlag("go");
1318
1319         /*
1320                 Device initialization
1321         */
1322
1323         // Resolution selection
1324         
1325         bool fullscreen = g_settings->getBool("fullscreen");
1326         u16 screenW = g_settings->getU16("screenW");
1327         u16 screenH = g_settings->getU16("screenH");
1328
1329         // bpp, fsaa, vsync
1330
1331         bool vsync = g_settings->getBool("vsync");
1332         u16 bits = g_settings->getU16("fullscreen_bpp");
1333         u16 fsaa = g_settings->getU16("fsaa");
1334
1335         // Determine driver
1336
1337         video::E_DRIVER_TYPE driverType;
1338         
1339         std::string driverstring = g_settings->get("video_driver");
1340
1341         if(driverstring == "null")
1342                 driverType = video::EDT_NULL;
1343         else if(driverstring == "software")
1344                 driverType = video::EDT_SOFTWARE;
1345         else if(driverstring == "burningsvideo")
1346                 driverType = video::EDT_BURNINGSVIDEO;
1347         else if(driverstring == "direct3d8")
1348                 driverType = video::EDT_DIRECT3D8;
1349         else if(driverstring == "direct3d9")
1350                 driverType = video::EDT_DIRECT3D9;
1351         else if(driverstring == "opengl")
1352                 driverType = video::EDT_OPENGL;
1353 #ifdef _IRR_COMPILE_WITH_OGLES1_
1354         else if(driverstring == "ogles1")
1355                 driverType = video::EDT_OGLES1;
1356 #endif
1357 #ifdef _IRR_COMPILE_WITH_OGLES2_
1358         else if(driverstring == "ogles2")
1359                 driverType = video::EDT_OGLES2;
1360 #endif
1361         else
1362         {
1363                 errorstream<<"WARNING: Invalid video_driver specified; defaulting "
1364                                 "to opengl"<<std::endl;
1365                 driverType = video::EDT_OPENGL;
1366         }
1367
1368         /*
1369                 List video modes if requested
1370         */
1371
1372         MyEventReceiver receiver;
1373
1374         if(cmd_args.getFlag("videomodes")){
1375                 IrrlichtDevice *nulldevice;
1376
1377                 SIrrlichtCreationParameters params = SIrrlichtCreationParameters();
1378                 params.DriverType    = video::EDT_NULL;
1379                 params.WindowSize    = core::dimension2d<u32>(640, 480);
1380                 params.Bits          = 24;
1381                 params.AntiAlias     = fsaa;
1382                 params.Fullscreen    = false;
1383                 params.Stencilbuffer = false;
1384                 params.Vsync         = vsync;
1385                 params.EventReceiver = &receiver;
1386                 params.HighPrecisionFPU = g_settings->getBool("high_precision_fpu");
1387
1388                 nulldevice = createDeviceEx(params);
1389
1390                 if(nulldevice == 0)
1391                         return 1;
1392
1393                 dstream<<_("Available video modes (WxHxD):")<<std::endl;
1394
1395                 video::IVideoModeList *videomode_list =
1396                                 nulldevice->getVideoModeList();
1397
1398                 if(videomode_list == 0){
1399                         nulldevice->drop();
1400                         return 1;
1401                 }
1402
1403                 s32 videomode_count = videomode_list->getVideoModeCount();
1404                 core::dimension2d<u32> videomode_res;
1405                 s32 videomode_depth;
1406                 for (s32 i = 0; i < videomode_count; ++i){
1407                         videomode_res = videomode_list->getVideoModeResolution(i);
1408                         videomode_depth = videomode_list->getVideoModeDepth(i);
1409                         dstream<<videomode_res.Width<<"x"<<videomode_res.Height
1410                                         <<"x"<<videomode_depth<<std::endl;
1411                 }
1412
1413                 dstream<<_("Active video mode (WxHxD):")<<std::endl;
1414                 videomode_res = videomode_list->getDesktopResolution();
1415                 videomode_depth = videomode_list->getDesktopDepth();
1416                 dstream<<videomode_res.Width<<"x"<<videomode_res.Height
1417                                 <<"x"<<videomode_depth<<std::endl;
1418
1419                 nulldevice->drop();
1420
1421                 return 0;
1422         }
1423
1424         /*
1425                 Create device and exit if creation failed
1426         */
1427
1428         IrrlichtDevice *device;
1429
1430         SIrrlichtCreationParameters params = SIrrlichtCreationParameters();
1431         params.DriverType    = driverType;
1432         params.WindowSize    = core::dimension2d<u32>(screenW, screenH);
1433         params.Bits          = bits;
1434         params.AntiAlias     = fsaa;
1435         params.Fullscreen    = fullscreen;
1436         params.Stencilbuffer = false;
1437         params.Vsync         = vsync;
1438         params.EventReceiver = &receiver;
1439         params.HighPrecisionFPU = g_settings->getBool("high_precision_fpu");
1440
1441         device = createDeviceEx(params);
1442
1443         if (device == 0)
1444                 return 1; // could not create selected driver.
1445         
1446         /*
1447                 Continue initialization
1448         */
1449
1450         video::IVideoDriver* driver = device->getVideoDriver();
1451
1452         /*
1453                 This changes the minimum allowed number of vertices in a VBO.
1454                 Default is 500.
1455         */
1456         //driver->setMinHardwareBufferVertexCount(50);
1457
1458         // Create time getter
1459         g_timegetter = new IrrlichtTimeGetter(device);
1460         
1461         // Create game callback for menus
1462         g_gamecallback = new MainGameCallback(device);
1463         
1464         /*
1465                 Speed tests (done after irrlicht is loaded to get timer)
1466         */
1467         if(cmd_args.getFlag("speedtests"))
1468         {
1469                 dstream<<"Running speed tests"<<std::endl;
1470                 SpeedTests();
1471                 device->drop();
1472                 return 0;
1473         }
1474         
1475         device->setResizable(true);
1476
1477         bool random_input = g_settings->getBool("random_input")
1478                         || cmd_args.getFlag("random-input");
1479         InputHandler *input = NULL;
1480         if(random_input)
1481                 input = new RandomInputHandler();
1482         else
1483                 input = new RealInputHandler(device, &receiver);
1484         
1485         scene::ISceneManager* smgr = device->getSceneManager();
1486
1487         guienv = device->getGUIEnvironment();
1488         gui::IGUISkin* skin = guienv->getSkin();
1489         std::string font_path = g_settings->get("font_path");
1490         gui::IGUIFont *font;
1491         #if USE_FREETYPE
1492         bool use_freetype = g_settings->getBool("freetype");
1493         if (use_freetype) {
1494                 std::string fallback;
1495                 if (is_yes(gettext("needs_fallback_font")))
1496                         fallback = "fallback_";
1497                 u16 font_size = g_settings->getU16(fallback + "font_size");
1498                 font_path = g_settings->get(fallback + "font_path");
1499                 font = gui::CGUITTFont::createTTFont(guienv, font_path.c_str(), font_size);
1500         } else {
1501                 font = guienv->getFont(font_path.c_str());
1502         }
1503         #else
1504         font = guienv->getFont(font_path.c_str());
1505         #endif
1506         if(font)
1507                 skin->setFont(font);
1508         else
1509                 errorstream<<"WARNING: Font file was not found."
1510                                 " Using default font."<<std::endl;
1511         // If font was not found, this will get us one
1512         font = skin->getFont();
1513         assert(font);
1514         
1515         u32 text_height = font->getDimension(L"Hello, world!").Height;
1516         infostream<<"text_height="<<text_height<<std::endl;
1517
1518         //skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255,0,0,0));
1519         skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255,255,255,255));
1520         //skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(0,0,0,0));
1521         //skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(0,0,0,0));
1522         skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(255,0,0,0));
1523         skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(255,0,0,0));
1524         skin->setColor(gui::EGDC_HIGH_LIGHT, video::SColor(255,70,100,50));
1525         skin->setColor(gui::EGDC_HIGH_LIGHT_TEXT, video::SColor(255,255,255,255));
1526
1527 #if (IRRLICHT_VERSION_MAJOR >= 1 && IRRLICHT_VERSION_MINOR >= 8) || IRRLICHT_VERSION_MAJOR >= 2
1528         // Irrlicht 1.8 input colours
1529         skin->setColor(gui::EGDC_EDITABLE, video::SColor(255,128,128,128));
1530         skin->setColor(gui::EGDC_FOCUSED_EDITABLE, video::SColor(255,96,134,49));
1531 #endif
1532
1533
1534         // Create the menu clouds
1535         if (!g_menucloudsmgr)
1536                 g_menucloudsmgr = smgr->createNewSceneManager();
1537         if (!g_menuclouds)
1538                 g_menuclouds = new Clouds(g_menucloudsmgr->getRootSceneNode(),
1539                         g_menucloudsmgr, -1, rand(), 100);
1540         g_menuclouds->update(v2f(0, 0), video::SColor(255,200,200,255));
1541         scene::ICameraSceneNode* camera;
1542         camera = g_menucloudsmgr->addCameraSceneNode(0,
1543                                 v3f(0,0,0), v3f(0, 60, 100));
1544         camera->setFarValue(10000);
1545
1546         /*
1547                 GUI stuff
1548         */
1549
1550         ChatBackend chat_backend;
1551
1552         /*
1553                 If an error occurs, this is set to something and the
1554                 menu-game loop is restarted. It is then displayed before
1555                 the menu.
1556         */
1557         std::wstring error_message = L"";
1558
1559         // The password entered during the menu screen,
1560         std::string password;
1561
1562         bool first_loop = true;
1563
1564         /*
1565                 Menu-game loop
1566         */
1567         while(device->run() && kill == false)
1568         {
1569                 // Set the window caption
1570                 wchar_t* text = wgettext("Main Menu");
1571                 device->setWindowCaption((std::wstring(L"Minetest [")+text+L"]").c_str());
1572                 delete[] text;
1573
1574                 // This is used for catching disconnects
1575                 try
1576                 {
1577
1578                         /*
1579                                 Clear everything from the GUIEnvironment
1580                         */
1581                         guienv->clear();
1582                         
1583                         /*
1584                                 We need some kind of a root node to be able to add
1585                                 custom gui elements directly on the screen.
1586                                 Otherwise they won't be automatically drawn.
1587                         */
1588                         guiroot = guienv->addStaticText(L"",
1589                                         core::rect<s32>(0, 0, 10000, 10000));
1590                         
1591                         SubgameSpec gamespec;
1592                         WorldSpec worldspec;
1593                         bool simple_singleplayer_mode = false;
1594
1595                         // These are set up based on the menu and other things
1596                         std::string current_playername = "inv£lid";
1597                         std::string current_password = "";
1598                         std::string current_address = "does-not-exist";
1599                         int current_port = 0;
1600
1601                         /*
1602                                 Out-of-game menu loop.
1603
1604                                 Loop quits when menu returns proper parameters.
1605                         */
1606                         while(kill == false)
1607                         {
1608                                 // If skip_main_menu, only go through here once
1609                                 if(skip_main_menu && !first_loop){
1610                                         kill = true;
1611                                         break;
1612                                 }
1613                                 first_loop = false;
1614                                 
1615                                 // Cursor can be non-visible when coming from the game
1616                                 device->getCursorControl()->setVisible(true);
1617                                 // Some stuff are left to scene manager when coming from the game
1618                                 // (map at least?)
1619                                 smgr->clear();
1620                                 
1621                                 // Initialize menu data
1622                                 MainMenuData menudata;
1623                                 menudata.address = address;
1624                                 menudata.name = playername;
1625                                 menudata.port = itos(port);
1626                                 menudata.errormessage = wide_to_narrow(error_message);
1627                                 error_message = L"";
1628                                 if(cmd_args.exists("password"))
1629                                         menudata.password = cmd_args.get("password");
1630
1631                                 driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, g_settings->getBool("mip_map"));
1632
1633                                 menudata.enable_public = g_settings->getBool("server_announce");
1634
1635                                 std::vector<WorldSpec> worldspecs = getAvailableWorlds();
1636
1637                                 // If a world was commanded, append and select it
1638                                 if(commanded_world != ""){
1639
1640                                         std::string gameid = getWorldGameId(commanded_world, true);
1641                                         std::string name = _("[--world parameter]");
1642                                         if(gameid == ""){
1643                                                 gameid = g_settings->get("default_game");
1644                                                 name += " [new]";
1645                                         }
1646                                         //TODO find within worldspecs and set config
1647                                 }
1648
1649                                 if(skip_main_menu == false)
1650                                 {
1651                                         video::IVideoDriver* driver = device->getVideoDriver();
1652
1653                                         infostream<<"Waiting for other menus"<<std::endl;
1654                                         while(device->run() && kill == false)
1655                                         {
1656                                                 if(noMenuActive())
1657                                                         break;
1658                                                 driver->beginScene(true, true,
1659                                                                 video::SColor(255,128,128,128));
1660                                                 guienv->drawAll();
1661                                                 driver->endScene();
1662                                                 // On some computers framerate doesn't seem to be
1663                                                 // automatically limited
1664                                                 sleep_ms(25);
1665                                         }
1666                                         infostream<<"Waited for other menus"<<std::endl;
1667
1668                                         GUIEngine* temp = new GUIEngine(device, guiroot, &g_menumgr,smgr,&menudata,kill);
1669                                         
1670                                         delete temp;
1671                                         //once finished you'll never end up here
1672                                         smgr->clear();
1673                                 }
1674
1675                                 if(menudata.errormessage != ""){
1676                                         error_message = narrow_to_wide(menudata.errormessage);
1677                                         continue;
1678                                 }
1679
1680                                 //update worldspecs (necessary as new world may have been created)
1681                                 worldspecs = getAvailableWorlds();
1682
1683                                 if (menudata.name == "")
1684                                         menudata.name = std::string("Guest") + itos(myrand_range(1000,9999));
1685                                 else
1686                                         playername = menudata.name;
1687
1688                                 password = translatePassword(playername, narrow_to_wide(menudata.password));
1689                                 //infostream<<"Main: password hash: '"<<password<<"'"<<std::endl;
1690
1691                                 address = menudata.address;
1692                                 int newport = stoi(menudata.port);
1693                                 if(newport != 0)
1694                                         port = newport;
1695
1696                                 simple_singleplayer_mode = menudata.simple_singleplayer_mode;
1697
1698                                 // Save settings
1699                                 g_settings->set("name", playername);
1700                                 g_settings->set("address", address);
1701                                 g_settings->set("port", itos(port));
1702
1703                                 if((menudata.selected_world >= 0) &&
1704                                                 (menudata.selected_world < (int)worldspecs.size()))
1705                                         g_settings->set("selected_world_path",
1706                                                         worldspecs[menudata.selected_world].path);
1707
1708                                 // Break out of menu-game loop to shut down cleanly
1709                                 if(device->run() == false || kill == true)
1710                                         break;
1711                                 
1712                                 current_playername = playername;
1713                                 current_password = password;
1714                                 current_address = address;
1715                                 current_port = port;
1716
1717                                 // If using simple singleplayer mode, override
1718                                 if(simple_singleplayer_mode){
1719                                         current_playername = "singleplayer";
1720                                         current_password = "";
1721                                         current_address = "";
1722                                         current_port = myrand_range(49152, 65535);
1723                                 }
1724                                 else if (address != "")
1725                                 {
1726                                         ServerListSpec server;
1727                                         server["name"] = menudata.servername;
1728                                         server["address"] = menudata.address;
1729                                         server["port"] = menudata.port;
1730                                         server["description"] = menudata.serverdescription;
1731                                         ServerList::insert(server);
1732                                 }
1733                                 
1734                                 // Set world path to selected one
1735                                 if ((menudata.selected_world >= 0) &&
1736                                         (menudata.selected_world < (int)worldspecs.size())) {
1737                                         worldspec = worldspecs[menudata.selected_world];
1738                                         infostream<<"Selected world: "<<worldspec.name
1739                                                         <<" ["<<worldspec.path<<"]"<<std::endl;
1740                                 }
1741                                 
1742                                 // If local game
1743                                 if(current_address == "")
1744                                 {
1745                                         if(menudata.selected_world == -1){
1746                                                 error_message = wgettext("No world selected and no address "
1747                                                                 "provided. Nothing to do.");
1748                                                 errorstream<<wide_to_narrow(error_message)<<std::endl;
1749                                                 continue;
1750                                         }
1751                                         // Load gamespec for required game
1752                                         gamespec = findWorldSubgame(worldspec.path);
1753                                         if(!gamespec.isValid() && !commanded_gamespec.isValid()){
1754                                                 error_message = wgettext("Could not find or load game \"")
1755                                                                 + narrow_to_wide(worldspec.gameid) + L"\"";
1756                                                 errorstream<<wide_to_narrow(error_message)<<std::endl;
1757                                                 continue;
1758                                         }
1759                                         if(commanded_gamespec.isValid() &&
1760                                                         commanded_gamespec.id != worldspec.gameid){
1761                                                 errorstream<<"WARNING: Overriding gamespec from \""
1762                                                                 <<worldspec.gameid<<"\" to \""
1763                                                                 <<commanded_gamespec.id<<"\""<<std::endl;
1764                                                 gamespec = commanded_gamespec;
1765                                         }
1766
1767                                         if(!gamespec.isValid()){
1768                                                 error_message = wgettext("Invalid gamespec.");
1769                                                 error_message += L" (world_gameid="
1770                                                                 +narrow_to_wide(worldspec.gameid)+L")";
1771                                                 errorstream<<wide_to_narrow(error_message)<<std::endl;
1772                                                 continue;
1773                                         }
1774                                 }
1775
1776                                 // Continue to game
1777                                 break;
1778                         }
1779
1780                         // Break out of menu-game loop to shut down cleanly
1781                         if(device->run() == false || kill == true) {
1782                                 if(g_settings_path != "") {
1783                                         g_settings->updateConfigFile(
1784                                                 g_settings_path.c_str());
1785                                 }
1786                                 break;
1787                         }
1788
1789                         /*
1790                                 Run game
1791                         */
1792                         the_game(
1793                                 kill,
1794                                 random_input,
1795                                 input,
1796                                 device,
1797                                 font,
1798                                 worldspec.path,
1799                                 current_playername,
1800                                 current_password,
1801                                 current_address,
1802                                 current_port,
1803                                 error_message,
1804                                 chat_backend,
1805                                 gamespec,
1806                                 simple_singleplayer_mode
1807                         );
1808                         smgr->clear();
1809
1810                 } //try
1811                 catch(con::PeerNotFoundException &e)
1812                 {
1813                         error_message = wgettext("Connection error (timed out?)");
1814                         errorstream<<wide_to_narrow(error_message)<<std::endl;
1815                 }
1816 #ifdef NDEBUG
1817                 catch(std::exception &e)
1818                 {
1819                         std::string narrow_message = "Some exception: \"";
1820                         narrow_message += e.what();
1821                         narrow_message += "\"";
1822                         errorstream<<narrow_message<<std::endl;
1823                         error_message = narrow_to_wide(narrow_message);
1824                 }
1825 #endif
1826
1827                 // If no main menu, show error and exit
1828                 if(skip_main_menu)
1829                 {
1830                         if(error_message != L""){
1831                                 verbosestream<<"error_message = "
1832                                                 <<wide_to_narrow(error_message)<<std::endl;
1833                                 retval = 1;
1834                         }
1835                         break;
1836                 }
1837         } // Menu-game loop
1838
1839
1840         g_menuclouds->drop();
1841         g_menucloudsmgr->drop();
1842
1843         delete input;
1844
1845         /*
1846                 In the end, delete the Irrlicht device.
1847         */
1848         device->drop();
1849
1850 #if USE_FREETYPE
1851         if (use_freetype)
1852                 font->drop();
1853 #endif
1854
1855 #endif // !SERVER
1856         
1857         // Update configuration file
1858         if(g_settings_path != "")
1859                 g_settings->updateConfigFile(g_settings_path.c_str());
1860         
1861         // Print modified quicktune values
1862         {
1863                 bool header_printed = false;
1864                 std::vector<std::string> names = getQuicktuneNames();
1865                 for(u32 i=0; i<names.size(); i++){
1866                         QuicktuneValue val = getQuicktuneValue(names[i]);
1867                         if(!val.modified)
1868                                 continue;
1869                         if(!header_printed){
1870                                 dstream<<"Modified quicktune values:"<<std::endl;
1871                                 header_printed = true;
1872                         }
1873                         dstream<<names[i]<<" = "<<val.getString()<<std::endl;
1874                 }
1875         }
1876
1877         END_DEBUG_EXCEPTION_HANDLER(errorstream)
1878         
1879         debugstreams_deinit();
1880         
1881         return retval;
1882 }
1883
1884 //END
1885