X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmain.cpp;h=1caa918b85448d948f9116c133cc6348465ad7df;hb=9afeb97fc693a769f2d9dad4aad6ddbdef285a71;hp=7f9ec1ace13385a808787888e3946e559207d493;hpb=e0564d5de01dd26f7b4f4d188415f5cf5a47b5d0;p=dragonfireclient.git

diff --git a/src/main.cpp b/src/main.cpp
index 7f9ec1ace..1caa918b8 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -55,9 +55,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "constants.h"
 #include "porting.h"
 #include "gettime.h"
-#include "guiMessageMenu.h"
 #include "filesys.h"
 #include "config.h"
+#include "version.h"
 #include "guiMainMenu.h"
 #include "game.h"
 #include "keycode.h"
@@ -76,15 +76,29 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "subgame.h"
 #include "quicktune.h"
 #include "serverlist.h"
-#include "sound.h"
-#include "sound_openal.h"
+#include "httpfetch.h"
+#include "guiEngine.h"
+#include "mapsector.h"
 
+#include "database-sqlite3.h"
+#ifdef USE_LEVELDB
+#include "database-leveldb.h"
+#endif
+
+#if USE_REDIS
+#include "database-redis.h"
+#endif
+
+#ifdef HAVE_TOUCHSCREENGUI
+#include "touchscreengui.h"
+#endif
 /*
 	Settings.
 	These are loaded from the config file.
 */
 Settings main_settings;
 Settings *g_settings = &main_settings;
+std::string g_settings_path;
 
 // Global profiler
 Profiler main_profiler;
@@ -166,7 +180,7 @@ class IrrlichtTimeGetter: public TimeGetter
 	u32 getTime(TimePrecision prec)
 	{
 		if (prec == PRECISION_MILLI) {
-			if(m_device == NULL)
+			if (m_device == NULL)
 				return 0;
 			return m_device->getTimer()->getRealTime();
 		} else {
@@ -192,7 +206,7 @@ TimeGetter *g_timegetter = NULL;
 
 u32 getTimeMs()
 {
-	if(g_timegetter == NULL)
+	if (g_timegetter == NULL)
 		return 0;
 	return g_timegetter->getTime(PRECISION_MILLI);
 }
@@ -204,56 +218,13 @@ u32 getTime(TimePrecision prec) {
 }
 #endif
 
-//Client side main menu music fetcher
-#ifndef SERVER
-class MenuMusicFetcher: public OnDemandSoundFetcher
-{
-	std::set<std::string> m_fetched;
-public:
-
-	void fetchSounds(const std::string &name,
-			std::set<std::string> &dst_paths,
-			std::set<std::string> &dst_datas)
-	{
-		if(m_fetched.count(name))
-			return;
-		m_fetched.insert(name);
-		std::string base;
-		base = porting::path_share + DIR_DELIM + "sounds";
-		dst_paths.insert(base + DIR_DELIM + name + ".ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".0.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".1.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".2.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".3.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".4.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".5.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".6.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".7.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".8.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".9.ogg");
-		base = porting::path_user + DIR_DELIM + "sounds";
-		dst_paths.insert(base + DIR_DELIM + name + ".ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".0.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".1.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".2.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".3.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".4.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".5.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".6.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".7.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".8.ogg");
-		dst_paths.insert(base + DIR_DELIM + name + ".9.ogg");
-		}
-};
-#endif
-
 class StderrLogOutput: public ILogOutput
 {
 public:
 	/* line: Full line with timestamp, level and thread */
 	void printLog(const std::string &line)
 	{
-		std::cerr<<line<<std::endl;
+		std::cerr << line << std::endl;
 	}
 } main_stderr_log_out;
 
@@ -263,7 +234,7 @@ class DstreamNoStderrLogOutput: public ILogOutput
 	/* line: Full line with timestamp, level and thread */
 	void printLog(const std::string &line)
 	{
-		dstream_no_stderr<<line<<std::endl;
+		dstream_no_stderr << line << std::endl;
 	}
 } main_dstream_no_stderr_log_out;
 
@@ -285,15 +256,18 @@ class MyEventReceiver : public IEventReceiver
 		/*
 			React to nothing here if a menu is active
 		*/
-		if(noMenuActive() == false)
-		{
-			return false;
+		if (noMenuActive() == false) {
+#ifdef HAVE_TOUCHSCREENGUI
+			if (m_touchscreengui != 0) {
+				m_touchscreengui->Toggle(false);
+			}
+#endif
+			return g_menumgr.preprocessEvent(event);
 		}
 
 		// Remember whether each key is down or up
-		if(event.EventType == irr::EET_KEY_INPUT_EVENT)
-		{
-			if(event.KeyInput.PressedDown) {
+		if (event.EventType == irr::EET_KEY_INPUT_EVENT) {
+			if (event.KeyInput.PressedDown) {
 				keyIsDown.set(event.KeyInput);
 				keyWasDown.set(event.KeyInput);
 			} else {
@@ -301,43 +275,47 @@ class MyEventReceiver : public IEventReceiver
 			}
 		}
 
-		if(event.EventType == irr::EET_MOUSE_INPUT_EVENT)
-		{
-			if(noMenuActive() == false)
-			{
+#ifdef HAVE_TOUCHSCREENGUI
+		// case of touchscreengui we have to handle different events
+		if ((m_touchscreengui != 0) &&
+				(event.EventType == irr::EET_TOUCH_INPUT_EVENT)) {
+			m_touchscreengui->translateEvent(event);
+			return true;
+		}
+#endif
+		// handle mouse events
+		if(event.EventType == irr::EET_MOUSE_INPUT_EVENT) {
+			if (noMenuActive() == false) {
 				left_active = false;
 				middle_active = false;
 				right_active = false;
-			}
-			else
-			{
+			} else {
 				left_active = event.MouseInput.isLeftPressed();
 				middle_active = event.MouseInput.isMiddlePressed();
 				right_active = event.MouseInput.isRightPressed();
 
-				if(event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)
-				{
+				if (event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN) {
 					leftclicked = true;
 				}
-				if(event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN)
-				{
+				if (event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN) {
 					rightclicked = true;
 				}
-				if(event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP)
-				{
+				if (event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP) {
 					leftreleased = true;
 				}
-				if(event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP)
-				{
+				if (event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP) {
 					rightreleased = true;
 				}
-				if(event.MouseInput.Event == EMIE_MOUSE_WHEEL)
-				{
+				if (event.MouseInput.Event == EMIE_MOUSE_WHEEL) {
 					mouse_wheel += event.MouseInput.Wheel;
 				}
 			}
 		}
-
+		if(event.EventType == irr::EET_LOG_TEXT_EVENT) {
+			dstream<< std::string("Irrlicht log: ") + std::string(event.LogEvent.Text)<<std::endl;
+			return true;
+		}
+		/* always return false in order to continue processing events */
 		return false;
 	}
 
@@ -345,7 +323,7 @@ class MyEventReceiver : public IEventReceiver
 	{
 		return keyIsDown[keyCode];
 	}
-	
+
 	// Checks whether a key was down and resets the state
 	bool WasKeyDown(const KeyPress &keyCode)
 	{
@@ -382,6 +360,9 @@ class MyEventReceiver : public IEventReceiver
 	MyEventReceiver()
 	{
 		clearInput();
+#ifdef HAVE_TOUCHSCREENGUI
+		m_touchscreengui = NULL;
+#endif
 	}
 
 	bool leftclicked;
@@ -395,9 +376,13 @@ class MyEventReceiver : public IEventReceiver
 
 	s32 mouse_wheel;
 
+#ifdef HAVE_TOUCHSCREENGUI
+	TouchScreenGUI* m_touchscreengui;
+#endif
+
 private:
 	IrrlichtDevice *m_device;
-	
+
 	// The current state of keys
 	KeyList keyIsDown;
 	// Whether a key has been pressed or not
@@ -413,7 +398,8 @@ class RealInputHandler : public InputHandler
 public:
 	RealInputHandler(IrrlichtDevice *device, MyEventReceiver *receiver):
 		m_device(device),
-		m_receiver(receiver)
+		m_receiver(receiver),
+		m_mousepos(0,0)
 	{
 	}
 	virtual bool isKeyDown(const KeyPress &keyCode)
@@ -426,11 +412,21 @@ class RealInputHandler : public InputHandler
 	}
 	virtual v2s32 getMousePos()
 	{
-		return m_device->getCursorControl()->getPosition();
+		if (m_device->getCursorControl()) {
+			return m_device->getCursorControl()->getPosition();
+		}
+		else {
+			return m_mousepos;
+		}
 	}
 	virtual void setMousePos(s32 x, s32 y)
 	{
-		m_device->getCursorControl()->setPosition(x, y);
+		if (m_device->getCursorControl()) {
+			m_device->getCursorControl()->setPosition(x, y);
+		}
+		else {
+			m_mousepos = v2s32(x,y);
+		}
 	}
 
 	virtual bool getLeftState()
@@ -441,7 +437,7 @@ class RealInputHandler : public InputHandler
 	{
 		return m_receiver->right_active;
 	}
-	
+
 	virtual bool getLeftClicked()
 	{
 		return m_receiver->leftclicked;
@@ -486,8 +482,9 @@ class RealInputHandler : public InputHandler
 		m_receiver->clearInput();
 	}
 private:
-	IrrlichtDevice *m_device;
+	IrrlichtDevice  *m_device;
 	MyEventReceiver *m_receiver;
+	v2s32           m_mousepos;
 };
 
 class RandomInputHandler : public InputHandler
@@ -517,7 +514,7 @@ class RandomInputHandler : public InputHandler
 	}
 	virtual void setMousePos(s32 x, s32 y)
 	{
-		mousepos = v2s32(x,y);
+		mousepos = v2s32(x, y);
 	}
 
 	virtual bool getLeftState()
@@ -573,71 +570,64 @@ class RandomInputHandler : public InputHandler
 		{
 			static float counter1 = 0;
 			counter1 -= dtime;
-			if(counter1 < 0.0)
-			{
-				counter1 = 0.1*Rand(1, 40);
+			if (counter1 < 0.0) {
+				counter1 = 0.1 * Rand(1, 40);
 				keydown.toggle(getKeySetting("keymap_jump"));
 			}
 		}
 		{
 			static float counter1 = 0;
 			counter1 -= dtime;
-			if(counter1 < 0.0)
-			{
-				counter1 = 0.1*Rand(1, 40);
+			if (counter1 < 0.0) {
+				counter1 = 0.1 * Rand(1, 40);
 				keydown.toggle(getKeySetting("keymap_special1"));
 			}
 		}
 		{
 			static float counter1 = 0;
 			counter1 -= dtime;
-			if(counter1 < 0.0)
-			{
-				counter1 = 0.1*Rand(1, 40);
+			if (counter1 < 0.0) {
+				counter1 = 0.1 * Rand(1, 40);
 				keydown.toggle(getKeySetting("keymap_forward"));
 			}
 		}
 		{
 			static float counter1 = 0;
 			counter1 -= dtime;
-			if(counter1 < 0.0)
-			{
-				counter1 = 0.1*Rand(1, 40);
+			if (counter1 < 0.0) {
+				counter1 = 0.1 * Rand(1, 40);
 				keydown.toggle(getKeySetting("keymap_left"));
 			}
 		}
 		{
 			static float counter1 = 0;
 			counter1 -= dtime;
-			if(counter1 < 0.0)
-			{
-				counter1 = 0.1*Rand(1, 20);
-				mousespeed = v2s32(Rand(-20,20), Rand(-15,20));
+			if (counter1 < 0.0) {
+				counter1 = 0.1 * Rand(1, 20);
+				mousespeed = v2s32(Rand(-20, 20), Rand(-15, 20));
 			}
 		}
 		{
 			static float counter1 = 0;
 			counter1 -= dtime;
-			if(counter1 < 0.0)
-			{
-				counter1 = 0.1*Rand(1, 30);
+			if (counter1 < 0.0) {
+				counter1 = 0.1 * Rand(1, 30);
 				leftdown = !leftdown;
-				if(leftdown)
+				if (leftdown)
 					leftclicked = true;
-				if(!leftdown)
+				if (!leftdown)
 					leftreleased = true;
 			}
 		}
 		{
 			static float counter1 = 0;
 			counter1 -= dtime;
-			if(counter1 < 0.0)
-			{
-				counter1 = 0.1*Rand(1, 15);
+			if (counter1 < 0.0) {
+				counter1 = 0.1 * Rand(1, 15);
 				rightdown = !rightdown;
-				if(rightdown)
+				if (rightdown)
 					rightclicked = true;
-				if(!rightdown)
+				if (!rightdown)
 					rightreleased = true;
 			}
 		}
@@ -660,180 +650,6 @@ class RandomInputHandler : public InputHandler
 	bool rightreleased;
 };
 
-struct MenuTextures
-{
-	std::string current_gameid;
-	bool global_textures;
-	video::ITexture *background;
-	video::ITexture *overlay;
-	video::ITexture *header;
-	video::ITexture *footer;
-
-	MenuTextures():
-		global_textures(false),
-		background(NULL),
-		overlay(NULL),
-		header(NULL),
-		footer(NULL)
-	{}
-
-	static video::ITexture* getMenuTexture(const std::string &tname,
-			video::IVideoDriver* driver, const SubgameSpec *spec)
-	{
-		if(spec){
-			std::string path;
-			// eg. minetest_menu_background.png (for texture packs)
-			std::string pack_tname = spec->id + "_menu_" + tname + ".png";
-			path = getTexturePath(pack_tname);
-			if(path != "")
-				return driver->getTexture(path.c_str());
-			// eg. games/minetest_game/menu/background.png
-			path = getImagePath(spec->path + DIR_DELIM + "menu" + DIR_DELIM + tname + ".png");
-			if(path != "")
-				return driver->getTexture(path.c_str());
-		} else {
-			std::string path;
-			// eg. menu_background.png
-			std::string pack_tname = "menu_" + tname + ".png";
-			path = getTexturePath(pack_tname);
-			if(path != "")
-				return driver->getTexture(path.c_str());
-		}
-		return NULL;
-	}
-
-	void update(video::IVideoDriver* driver, const SubgameSpec *spec, int tab)
-	{
-		if(tab == TAB_SINGLEPLAYER){
-			if(spec->id == current_gameid)
-				return;
-			current_gameid = spec->id;
-			global_textures = false;
-			background = getMenuTexture("background", driver, spec);
-			overlay = getMenuTexture("overlay", driver, spec);
-			header = getMenuTexture("header", driver, spec);
-			footer = getMenuTexture("footer", driver, spec);
-		} else {
-			if(global_textures)
-				return;
-			current_gameid = "";
-			global_textures = true;
-			background = getMenuTexture("background", driver, NULL);
-			overlay = getMenuTexture("overlay", driver, NULL);
-			header = getMenuTexture("header", driver, NULL);
-			footer = getMenuTexture("footer", driver, NULL);
-		}
-	}
-};
-
-void drawMenuBackground(video::IVideoDriver* driver, const MenuTextures &menutextures)
-{
-	v2u32 screensize = driver->getScreenSize();
-	video::ITexture *texture = menutextures.background;
-
-	/* If no texture, draw background of solid color */
-	if(!texture){
-		video::SColor color(255,80,58,37);
-		core::rect<s32> rect(0, 0, screensize.X, screensize.Y);
-		driver->draw2DRectangle(color, rect, NULL);
-		return;
-	}
-
-	/* Draw background texture */
-	v2u32 sourcesize = texture->getSize();
-	driver->draw2DImage(texture,
-		core::rect<s32>(0, 0, screensize.X, screensize.Y),
-		core::rect<s32>(0, 0, sourcesize.X, sourcesize.Y),
-		NULL, NULL, true);
-}
-
-void drawMenuOverlay(video::IVideoDriver* driver, const MenuTextures &menutextures)
-{
-	v2u32 screensize = driver->getScreenSize();
-	video::ITexture *texture = menutextures.overlay;
-
-	/* If no texture, draw nothing */
-	if(!texture)
-		return;
-
-	/* Draw overlay texture */
-	v2u32 sourcesize = texture->getSize();
-	driver->draw2DImage(texture,
-		core::rect<s32>(0, 0, screensize.X, screensize.Y),
-		core::rect<s32>(0, 0, sourcesize.X, sourcesize.Y),
-		NULL, NULL, true);
-}
-
-void drawMenuHeader(video::IVideoDriver* driver, const MenuTextures &menutextures)
-{
-	core::dimension2d<u32> screensize = driver->getScreenSize();
-	video::ITexture *texture = menutextures.header;
-
-	/* If no texture, draw nothing */
-	if(!texture)
-		return;
-
-	f32 mult = (((f32)screensize.Width / 2)) /
-		((f32)texture->getOriginalSize().Width);
-
-	v2s32 splashsize(((f32)texture->getOriginalSize().Width) * mult,
-			((f32)texture->getOriginalSize().Height) * mult);
-
-	// Don't draw the header is there isn't enough room
-	s32 free_space = (((s32)screensize.Height)-320)/2;
-	if (free_space > splashsize.Y) {
-		core::rect<s32> splashrect(0, 0, splashsize.X, splashsize.Y);
-		splashrect += v2s32((screensize.Width/2)-(splashsize.X/2),
-			((free_space/2)-splashsize.Y/2)+10);
-
-		video::SColor bgcolor(255,50,50,50);
-
-		driver->draw2DImage(texture, splashrect,
-			core::rect<s32>(core::position2d<s32>(0,0),
-			core::dimension2di(texture->getSize())),
-			NULL, NULL, true);
-	}
-}
-
-void drawMenuFooter(video::IVideoDriver* driver, const MenuTextures &menutextures)
-{
-	core::dimension2d<u32> screensize = driver->getScreenSize();
-	video::ITexture *texture = menutextures.footer;
-
-	/* If no texture, draw nothing */
-	if(!texture)
-		return;
-
-	f32 mult = (((f32)screensize.Width)) /
-		((f32)texture->getOriginalSize().Width);
-
-	v2s32 footersize(((f32)texture->getOriginalSize().Width) * mult,
-			((f32)texture->getOriginalSize().Height) * mult);
-
-	// Don't draw the footer if there isn't enough room
-	s32 free_space = (((s32)screensize.Height)-320)/2;
-	if (free_space > footersize.Y) {
-		core::rect<s32> rect(0,0,footersize.X,footersize.Y);
-		rect += v2s32(screensize.Width/2,screensize.Height-footersize.Y);
-		rect -= v2s32(footersize.X/2, 0);
-
-		driver->draw2DImage(texture, rect,
-			core::rect<s32>(core::position2d<s32>(0,0),
-			core::dimension2di(texture->getSize())),
-			NULL, NULL, true);
-	}
-}
-
-static const SubgameSpec* getMenuGame(const MainMenuData &menudata)
-{
-	for(size_t i=0; i<menudata.games.size(); i++){
-		if(menudata.games[i].id == menudata.selected_game){
-			return &menudata.games[i];
-		}
-	}
-	return NULL;
-}
-
 #endif // !SERVER
 
 // These are defined global so that they're not optimized too much.
@@ -848,78 +664,76 @@ std::string tempstring2;
 void SpeedTests()
 {
 	{
-		infostream<<"The following test should take around 20ms."<<std::endl;
+		infostream << "The following test should take around 20ms." << std::endl;
 		TimeTaker timer("Testing std::string speed");
 		const u32 jj = 10000;
-		for(u32 j=0; j<jj; j++)
-		{
+		for(u32 j = 0; j < jj; j++) {
 			tempstring = "";
 			tempstring2 = "";
 			const u32 ii = 10;
-			for(u32 i=0; i<ii; i++){
+			for(u32 i = 0; i < ii; i++) {
 				tempstring2 += "asd";
 			}
-			for(u32 i=0; i<ii+1; i++){
+			for(u32 i = 0; i < ii+1; i++) {
 				tempstring += "asd";
-				if(tempstring == tempstring2)
+				if (tempstring == tempstring2)
 					break;
 			}
 		}
 	}
-	
-	infostream<<"All of the following tests should take around 100ms each."
-			<<std::endl;
+
+	infostream << "All of the following tests should take around 100ms each."
+		<< std::endl;
 
 	{
 		TimeTaker timer("Testing floating-point conversion speed");
 		tempf = 0.001;
-		for(u32 i=0; i<4000000; i++){
+		for(u32 i = 0; i < 4000000; i++) {
 			temp16 += tempf;
 			tempf += 0.001;
 		}
 	}
-	
+
 	{
 		TimeTaker timer("Testing floating-point vector speed");
 
-		tempv3f1 = v3f(1,2,3);
-		tempv3f2 = v3f(4,5,6);
-		for(u32 i=0; i<10000000; i++){
+		tempv3f1 = v3f(1, 2, 3);
+		tempv3f2 = v3f(4, 5, 6);
+		for(u32 i = 0; i < 10000000; i++) {
 			tempf += tempv3f1.dotProduct(tempv3f2);
-			tempv3f2 += v3f(7,8,9);
+			tempv3f2 += v3f(7, 8, 9);
 		}
 	}
 
 	{
 		TimeTaker timer("Testing std::map speed");
-		
+
 		std::map<v2s16, f32> map1;
 		tempf = -324;
-		const s16 ii=300;
-		for(s16 y=0; y<ii; y++){
-			for(s16 x=0; x<ii; x++){
-				map1[v2s16(x,y)] =  tempf;
+		const s16 ii = 300;
+		for(s16 y = 0; y < ii; y++) {
+			for(s16 x = 0; x < ii; x++) {
+				map1[v2s16(x, y)] =  tempf;
 				tempf += 1;
 			}
 		}
-		for(s16 y=ii-1; y>=0; y--){
-			for(s16 x=0; x<ii; x++){
-				tempf = map1[v2s16(x,y)];
+		for(s16 y = ii - 1; y >= 0; y--) {
+			for(s16 x = 0; x < ii; x++) {
+				tempf = map1[v2s16(x, y)];
 			}
 		}
 	}
 
 	{
-		infostream<<"Around 5000/ms should do well here."<<std::endl;
+		infostream << "Around 5000/ms should do well here." << std::endl;
 		TimeTaker timer("Testing mutex speed");
-		
+
 		JMutex m;
-		m.Init();
 		u32 n = 0;
 		u32 i = 0;
-		do{
+		do {
 			n += 10000;
-			for(; i<n; i++){
+			for(; i < n; i++) {
 				m.Lock();
 				m.Unlock();
 			}
@@ -929,22 +743,20 @@ void SpeedTests()
 
 		u32 dtime = timer.stop();
 		u32 per_ms = n / dtime;
-		infostream<<"Done. "<<dtime<<"ms, "
-				<<per_ms<<"/ms"<<std::endl;
+		infostream << "Done. " << dtime << "ms, " << per_ms << "/ms" << std::endl;
 	}
 }
 
-static void print_worldspecs(const std::vector<WorldSpec> &worldspecs,
-		std::ostream &os)
+static void print_worldspecs(const std::vector<WorldSpec> &worldspecs, std::ostream &os)
 {
-	for(u32 i=0; i<worldspecs.size(); i++){
+	for(u32 i = 0; i < worldspecs.size(); i++) {
 		std::string name = worldspecs[i].name;
 		std::string path = worldspecs[i].path;
-		if(name.find(" ") != std::string::npos)
+		if (name.find(" ") != std::string::npos)
 			name = std::string("'") + name + "'";
 		path = std::string("'") + path + "'";
 		name = padStringRight(name, 14);
-		os<<"  "<<name<<" "<<path<<std::endl;
+		os << "  " << name << " " << path << std::endl;
 	}
 }
 
@@ -960,28 +772,16 @@ int main(int argc, char *argv[])
 	log_add_output_all_levs(&main_dstream_no_stderr_log_out);
 
 	log_register_thread("main");
-
-	// This enables internatonal characters input
-	if( setlocale(LC_ALL, "") == NULL )
-	{
-		fprintf( stderr, "%s: warning: could not set default locale\n", argv[0] );
-	}
-
-	// Set locale. This is for forcing '.' as the decimal point.
-	try {
-		std::locale::global(std::locale(std::locale(""), "C", std::locale::numeric));
-		setlocale(LC_NUMERIC, "C");
-	} catch (const std::exception& ex) {
-		errorstream<<"Could not set numeric locale to C"<<std::endl;
-	}
 	/*
 		Parse command line
 	*/
-	
+
 	// List all allowed options
 	std::map<std::string, ValueSpec> allowed_options;
 	allowed_options.insert(std::make_pair("help", ValueSpec(VALUETYPE_FLAG,
 			_("Show allowed options"))));
+	allowed_options.insert(std::make_pair("version", ValueSpec(VALUETYPE_FLAG,
+			_("Show version information"))));
 	allowed_options.insert(std::make_pair("config", ValueSpec(VALUETYPE_STRING,
 			_("Load configuration from specified file"))));
 	allowed_options.insert(std::make_pair("port", ValueSpec(VALUETYPE_STRING,
@@ -996,6 +796,8 @@ int main(int argc, char *argv[])
 			_("Set world path (implies local game) ('list' lists all)"))));
 	allowed_options.insert(std::make_pair("worldname", ValueSpec(VALUETYPE_STRING,
 			_("Set world by name (implies local game)"))));
+	allowed_options.insert(std::make_pair("quiet", ValueSpec(VALUETYPE_FLAG,
+			_("Print to console errors only"))));
 	allowed_options.insert(std::make_pair("info", ValueSpec(VALUETYPE_FLAG,
 			_("Print more information to console"))));
 	allowed_options.insert(std::make_pair("verbose",  ValueSpec(VALUETYPE_FLAG,
@@ -1006,6 +808,8 @@ int main(int argc, char *argv[])
 			_("Set logfile path ('' = no logging)"))));
 	allowed_options.insert(std::make_pair("gameid", ValueSpec(VALUETYPE_STRING,
 			_("Set gameid (\"--gameid list\" prints available ones)"))));
+	allowed_options.insert(std::make_pair("migrate", ValueSpec(VALUETYPE_STRING,
+			_("Migrate from current map backend to another (Only works when using minetestserver or with --server)"))));
 #ifndef SERVER
 	allowed_options.insert(std::make_pair("videomodes", ValueSpec(VALUETYPE_FLAG,
 			_("Show available video modes"))));
@@ -1026,63 +830,84 @@ int main(int argc, char *argv[])
 #endif
 
 	Settings cmd_args;
-	
+
 	bool ret = cmd_args.parseCommandLine(argc, argv, allowed_options);
 
-	if(ret == false || cmd_args.getFlag("help") || cmd_args.exists("nonopt1"))
-	{
-		dstream<<_("Allowed options:")<<std::endl;
+	if (ret == false || cmd_args.getFlag("help") || cmd_args.exists("nonopt1")) {
+		dstream << _("Allowed options:") << std::endl;
 		for(std::map<std::string, ValueSpec>::iterator
 				i = allowed_options.begin();
-				i != allowed_options.end(); ++i)
-		{
+				i != allowed_options.end(); ++i) {
 			std::ostringstream os1(std::ios::binary);
-			os1<<"  --"<<i->first;
-			if(i->second.type == VALUETYPE_FLAG)
-				{}
-			else
-				os1<<_(" <value>");
-			dstream<<padStringRight(os1.str(), 24);
-
-			if(i->second.help != NULL)
-				dstream<<i->second.help;
-			dstream<<std::endl;
+			os1 << "  --"<<i->first;
+			if (i->second.type == VALUETYPE_FLAG) {
+			} else
+				os1 << _(" <value>");
+			dstream << padStringRight(os1.str(), 24);
+
+			if (i->second.help != NULL)
+				dstream << i->second.help;
+			dstream << std::endl;
 		}
 
 		return cmd_args.getFlag("help") ? 0 : 1;
 	}
-	
+
+	if (cmd_args.getFlag("version")) {
+#ifdef SERVER
+		dstream << "minetestserver " << minetest_version_hash << std::endl;
+#else
+		dstream << "Minetest " << minetest_version_hash << std::endl;
+		dstream << "Using Irrlicht " << IRRLICHT_SDK_VERSION << std::endl;
+#endif
+		dstream << "Build info: " << minetest_build_info << std::endl;
+		return 0;
+	}
+
 	/*
 		Low-level initialization
 	*/
-	
+
+	// Quiet mode, print errors only
+	if (cmd_args.getFlag("quiet")) {
+		log_remove_output(&main_stderr_log_out);
+		log_add_output_maxlev(&main_stderr_log_out, LMT_ERROR);
+	}
 	// If trace is enabled, enable logging of certain things
-	if(cmd_args.getFlag("trace")){
-		dstream<<_("Enabling trace level debug output")<<std::endl;
+	if (cmd_args.getFlag("trace")) {
+		dstream << _("Enabling trace level debug output") << std::endl;
 		log_trace_level_enabled = true;
 		dout_con_ptr = &verbosestream; // this is somewhat old crap
 		socket_enable_debug_output = true; // socket doesn't use log.h
 	}
 	// In certain cases, output info level on stderr
-	if(cmd_args.getFlag("info") || cmd_args.getFlag("verbose") ||
+	if (cmd_args.getFlag("info") || cmd_args.getFlag("verbose") ||
 			cmd_args.getFlag("trace") || cmd_args.getFlag("speedtests"))
 		log_add_output(&main_stderr_log_out, LMT_INFO);
 	// In certain cases, output verbose level on stderr
-	if(cmd_args.getFlag("verbose") || cmd_args.getFlag("trace"))
+	if (cmd_args.getFlag("verbose") || cmd_args.getFlag("trace"))
 		log_add_output(&main_stderr_log_out, LMT_VERBOSE);
 
 	porting::signal_handler_init();
 	bool &kill = *porting::signal_handler_killstatus();
-	
+
 	porting::initializePaths();
 
+#ifdef __ANDROID__
+	porting::initAndroid();
+
+	porting::setExternalStorageDir(porting::jnienv);
+	if (!fs::PathExists(porting::path_user)) {
+		fs::CreateDir(porting::path_user);
+	}
+	porting::copyAssets();
+#else
 	// Create user data directory
 	fs::CreateDir(porting::path_user);
+#endif
 
-	init_gettext((porting::path_share + DIR_DELIM + "locale").c_str());
-
-	infostream<<"path_share = "<<porting::path_share<<std::endl;
-	infostream<<"path_user  = "<<porting::path_user<<std::endl;
+	infostream << "path_share = " << porting::path_share << std::endl;
+	infostream << "path_user  = " << porting::path_user << std::endl;
 
 	// Initialize debug stacks
 	debug_stacks_init();
@@ -1090,62 +915,55 @@ int main(int argc, char *argv[])
 
 	// Debug handler
 	BEGIN_DEBUG_EXCEPTION_HANDLER
-	
+
 	// List gameids if requested
-	if(cmd_args.exists("gameid") && cmd_args.get("gameid") == "list")
-	{
+	if (cmd_args.exists("gameid") && cmd_args.get("gameid") == "list") {
 		std::set<std::string> gameids = getAvailableGameIds();
 		for(std::set<std::string>::const_iterator i = gameids.begin();
 				i != gameids.end(); i++)
 			dstream<<(*i)<<std::endl;
 		return 0;
 	}
-	
+
 	// List worlds if requested
-	if(cmd_args.exists("world") && cmd_args.get("world") == "list"){
-		dstream<<_("Available worlds:")<<std::endl;
+	if (cmd_args.exists("world") && cmd_args.get("world") == "list") {
+		dstream << _("Available worlds:") << std::endl;
 		std::vector<WorldSpec> worldspecs = getAvailableWorlds();
 		print_worldspecs(worldspecs, dstream);
 		return 0;
 	}
 
 	// Print startup message
-	infostream<<PROJECT_NAME<<
-			" "<<_("with")<<" SER_FMT_VER_HIGHEST="<<(int)SER_FMT_VER_HIGHEST
-			<<", "<<BUILD_INFO
-			<<std::endl;
-	
+	infostream<<PROJECT_NAME <<	" "<< _("with") << " SER_FMT_VER_HIGHEST_READ="
+		<< (int)SER_FMT_VER_HIGHEST_READ << ", " << minetest_build_info << std::endl;
+
 	/*
 		Basic initialization
 	*/
 
 	// Initialize default settings
 	set_default_settings(g_settings);
-	
+
 	// Initialize sockets
 	sockets_init();
 	atexit(sockets_cleanup);
-	
+
 	/*
 		Read config file
 	*/
-	
+
 	// Path of configuration file in use
-	std::string configpath = "";
-	
-	if(cmd_args.exists("config"))
-	{
+	g_settings_path = "";
+
+	if (cmd_args.exists("config")) {
 		bool r = g_settings->readConfigFile(cmd_args.get("config").c_str());
-		if(r == false)
-		{
-			errorstream<<"Could not read configuration from \""
-					<<cmd_args.get("config")<<"\""<<std::endl;
+		if (r == false) {
+			errorstream << "Could not read configuration from \""
+					<< cmd_args.get("config") << "\"" << std::endl;
 			return 1;
 		}
-		configpath = cmd_args.get("config");
-	}
-	else
-	{
+		g_settings_path = cmd_args.get("config");
+	} else {
 		std::vector<std::string> filenames;
 		filenames.push_back(porting::path_user +
 				DIR_DELIM + "minetest.conf");
@@ -1159,21 +977,19 @@ int main(int argc, char *argv[])
 				DIR_DELIM + ".." + DIR_DELIM + ".." + DIR_DELIM + "minetest.conf");
 #endif
 
-		for(u32 i=0; i<filenames.size(); i++)
-		{
+		for(u32 i = 0; i < filenames.size(); i++) {
 			bool r = g_settings->readConfigFile(filenames[i].c_str());
-			if(r)
-			{
-				configpath = filenames[i];
+			if (r) {
+				g_settings_path = filenames[i];
 				break;
 			}
 		}
-		
+
 		// If no path found, use the first one (menu creates the file)
-		if(configpath == "")
-			configpath = filenames[0];
+		if (g_settings_path == "")
+			g_settings_path = filenames[0];
 	}
-	
+
 	// Initialize debug streams
 #define DEBUGFILE "debug.txt"
 #if RUN_IN_PLACE
@@ -1181,99 +997,110 @@ int main(int argc, char *argv[])
 #else
 	std::string logfile = porting::path_user+DIR_DELIM+DEBUGFILE;
 #endif
-	if(cmd_args.exists("logfile"))
+	if (cmd_args.exists("logfile"))
 		logfile = cmd_args.get("logfile");
-	
+
 	log_remove_output(&main_dstream_no_stderr_log_out);
 	int loglevel = g_settings->getS32("debug_log_level");
 
 	if (loglevel == 0) //no logging
 		logfile = "";
 	else if (loglevel > 0 && loglevel <= LMT_NUM_VALUES)
-		log_add_output_maxlev(&main_dstream_no_stderr_log_out, (LogMessageLevel)(loglevel - 1));
+		log_add_output_maxlev(&main_dstream_no_stderr_log_out,
+		(LogMessageLevel)(loglevel - 1));
 
-	if(logfile != "")
+	if (logfile != "")
 		debugstreams_init(false, logfile.c_str());
 	else
 		debugstreams_init(false, NULL);
-		
-	infostream<<"logfile    = "<<logfile<<std::endl;
+
+	infostream << "logfile = " << logfile << std::endl;
 
 	// Initialize random seed
 	srand(time(0));
 	mysrand(time(0));
 
+	// Initialize HTTP fetcher
+	httpfetch_init(g_settings->getS32("curl_parallel_limit"));
+
+#ifndef __ANDROID__
 	/*
 		Run unit tests
 	*/
-
-	if((ENABLE_TESTS && cmd_args.getFlag("disable-unittests") == false)
-			|| cmd_args.getFlag("enable-unittests") == true)
-	{
-		run_tests();
+	if ((ENABLE_TESTS && cmd_args.getFlag("disable-unittests") == false)
+			|| cmd_args.getFlag("enable-unittests") == true) {
+				run_tests();
 	}
-	
+#endif
+#ifdef _MSC_VER
+	init_gettext((porting::path_share + DIR_DELIM + "locale").c_str(),
+		g_settings->get("language"), argc, argv);
+#else
+	init_gettext((porting::path_share + DIR_DELIM + "locale").c_str(),
+		g_settings->get("language"));
+#endif
+
 	/*
 		Game parameters
 	*/
 
 	// Port
 	u16 port = 30000;
-	if(cmd_args.exists("port"))
+	if (cmd_args.exists("port"))
 		port = cmd_args.getU16("port");
-	else if(g_settings->exists("port"))
+	else if (g_settings->exists("port"))
 		port = g_settings->getU16("port");
-	if(port == 0)
+	if (port == 0)
 		port = 30000;
-	
+
 	// World directory
 	std::string commanded_world = "";
-	if(cmd_args.exists("world"))
+	if (cmd_args.exists("world"))
 		commanded_world = cmd_args.get("world");
-	else if(cmd_args.exists("map-dir"))
+	else if (cmd_args.exists("map-dir"))
 		commanded_world = cmd_args.get("map-dir");
-	else if(cmd_args.exists("nonopt0")) // First nameless argument
+	else if (cmd_args.exists("nonopt0")) // First nameless argument
 		commanded_world = cmd_args.get("nonopt0");
-	else if(g_settings->exists("map-dir"))
+	else if (g_settings->exists("map-dir"))
 		commanded_world = g_settings->get("map-dir");
-	
+
 	// World name
 	std::string commanded_worldname = "";
-	if(cmd_args.exists("worldname"))
+	if (cmd_args.exists("worldname"))
 		commanded_worldname = cmd_args.get("worldname");
-	
+
 	// Strip world.mt from commanded_world
 	{
 		std::string worldmt = "world.mt";
-		if(commanded_world.size() > worldmt.size() &&
-				commanded_world.substr(commanded_world.size()-worldmt.size())
-				== worldmt){
-			dstream<<_("Supplied world.mt file - stripping it off.")<<std::endl;
-			commanded_world = commanded_world.substr(
-					0, commanded_world.size()-worldmt.size());
+		if (commanded_world.size() > worldmt.size() &&
+				commanded_world.substr(commanded_world.size() - worldmt.size())
+				== worldmt) {
+			dstream << _("Supplied world.mt file - stripping it off.") << std::endl;
+			commanded_world = commanded_world.substr(0,
+				commanded_world.size() - worldmt.size());
 		}
 	}
-	
+
 	// If a world name was specified, convert it to a path
-	if(commanded_worldname != ""){
+	if (commanded_worldname != "") {
 		// Get information about available worlds
 		std::vector<WorldSpec> worldspecs = getAvailableWorlds();
 		bool found = false;
-		for(u32 i=0; i<worldspecs.size(); i++){
+		for(u32 i = 0; i < worldspecs.size(); i++) {
 			std::string name = worldspecs[i].name;
-			if(name == commanded_worldname){
-				if(commanded_world != ""){
-					dstream<<_("--worldname takes precedence over previously "
-							"selected world.")<<std::endl;
+			if (name == commanded_worldname) {
+				if (commanded_world != "") {
+					dstream << _("--worldname takes precedence over previously "
+							"selected world.") << std::endl;
 				}
 				commanded_world = worldspecs[i].path;
 				found = true;
 				break;
 			}
 		}
-		if(!found){
-			dstream<<_("World")<<" '"<<commanded_worldname<<_("' not "
-					"available. Available worlds:")<<std::endl;
+		if (!found) {
+			dstream << _("World") << " '"<<commanded_worldname << _("' not "
+					"available. Available worlds:") << std::endl;
 			print_worldspecs(worldspecs, dstream);
 			return 1;
 		}
@@ -1281,15 +1108,16 @@ int main(int argc, char *argv[])
 
 	// Gamespec
 	SubgameSpec commanded_gamespec;
-	if(cmd_args.exists("gameid")){
+	if (cmd_args.exists("gameid")) {
 		std::string gameid = cmd_args.get("gameid");
 		commanded_gamespec = findSubgame(gameid);
-		if(!commanded_gamespec.isValid()){
-			errorstream<<"Game \""<<gameid<<"\" not found"<<std::endl;
+		if (!commanded_gamespec.isValid()) {
+			errorstream << "Game \"" << gameid << "\" not found" << std::endl;
 			return 1;
 		}
 	}
 
+
 	/*
 		Run dedicated server if asked to or no other option
 	*/
@@ -1299,7 +1127,7 @@ int main(int argc, char *argv[])
 	bool run_dedicated_server = cmd_args.getFlag("server");
 #endif
 	g_settings->set("server_dedicated", run_dedicated_server ? "true" : "false");
-	if(run_dedicated_server)
+	if (run_dedicated_server)
 	{
 		DSTACK("Dedicated server branch");
 		// Create time getter if built with Irrlicht
@@ -1309,46 +1137,43 @@ int main(int argc, char *argv[])
 
 		// World directory
 		std::string world_path;
-		verbosestream<<_("Determining world path")<<std::endl;
+		verbosestream << _("Determining world path") << std::endl;
 		bool is_legacy_world = false;
 		// If a world was commanded, use it
-		if(commanded_world != ""){
+		if (commanded_world != "") {
 			world_path = commanded_world;
-			infostream<<"Using commanded world path ["<<world_path<<"]"
-					<<std::endl;
-		}
-		// No world was specified; try to select it automatically
-		else
-		{
+			infostream << "Using commanded world path [" << world_path << "]"
+				<< std::endl;
+		} else { // No world was specified; try to select it automatically
 			// Get information about available worlds
 			std::vector<WorldSpec> worldspecs = getAvailableWorlds();
 			// If a world name was specified, select it
-			if(commanded_worldname != ""){
+			if (commanded_worldname != "") {
 				world_path = "";
-				for(u32 i=0; i<worldspecs.size(); i++){
+				for(u32 i = 0; i < worldspecs.size(); i++) {
 					std::string name = worldspecs[i].name;
-					if(name == commanded_worldname){
+					if (name == commanded_worldname) {
 						world_path = worldspecs[i].path;
 						break;
 					}
 				}
-				if(world_path == ""){
-					dstream<<_("World")<<" '"<<commanded_worldname<<"' "<<_("not "
-							"available. Available worlds:")<<std::endl;
+				if (world_path == "") {
+					dstream << _("World") << " '" << commanded_worldname << "' " << _("not "
+						"available. Available worlds:") << std::endl;
 					print_worldspecs(worldspecs, dstream);
 					return 1;
 				}
 			}
 			// If there is only a single world, use it
-			if(worldspecs.size() == 1){
+			if (worldspecs.size() == 1) {
 				world_path = worldspecs[0].path;
-				dstream<<_("Automatically selecting world at")<<" ["
-						<<world_path<<"]"<<std::endl;
+				dstream <<_("Automatically selecting world at") << " ["
+					<< world_path << "]" << std::endl;
 			// If there are multiple worlds, list them
-			} else if(worldspecs.size() > 1){
-				dstream<<_("Multiple worlds are available.")<<std::endl;
-				dstream<<_("Please select one using --worldname <name>"
-						" or --world <path>")<<std::endl;
+			} else if (worldspecs.size() > 1) {
+				dstream << _("Multiple worlds are available.") << std::endl;
+				dstream << _("Please select one using --worldname <name>"
+						" or --world <path>") << std::endl;
 				print_worldspecs(worldspecs, dstream);
 				return 1;
 			// If there are no worlds, automatically create a new one
@@ -1356,64 +1181,146 @@ int main(int argc, char *argv[])
 				// This is the ultimate default world path
 				world_path = porting::path_user + DIR_DELIM + "worlds" +
 						DIR_DELIM + "world";
-				infostream<<"Creating default world at ["
-						<<world_path<<"]"<<std::endl;
+				infostream << "Creating default world at ["
+						<< world_path << "]" << std::endl;
 			}
 		}
 
-		if(world_path == ""){
-			errorstream<<"No world path specified or found."<<std::endl;
+		if (world_path == "") {
+			errorstream << "No world path specified or found." << std::endl;
 			return 1;
 		}
-		verbosestream<<_("Using world path")<<" ["<<world_path<<"]"<<std::endl;
+		verbosestream << _("Using world path") << " [" << world_path << "]" << std::endl;
 
 		// We need a gamespec.
 		SubgameSpec gamespec;
-		verbosestream<<_("Determining gameid/gamespec")<<std::endl;
+		verbosestream << _("Determining gameid/gamespec") << std::endl;
 		// If world doesn't exist
-		if(!getWorldExists(world_path))
-		{
+		if (!getWorldExists(world_path)) {
 			// Try to take gamespec from command line
-			if(commanded_gamespec.isValid()){
+			if (commanded_gamespec.isValid()) {
 				gamespec = commanded_gamespec;
-				infostream<<"Using commanded gameid ["<<gamespec.id<<"]"<<std::endl;
-			}
-			// Otherwise we will be using "minetest"
-			else{
+				infostream << "Using commanded gameid [" << gamespec.id << "]" << std::endl;
+			} else { // Otherwise we will be using "minetest"
 				gamespec = findSubgame(g_settings->get("default_game"));
-				infostream<<"Using default gameid ["<<gamespec.id<<"]"<<std::endl;
+				infostream << "Using default gameid [" << gamespec.id << "]" << std::endl;
 			}
-		}
-		// World exists
-		else
-		{
+		} else { // World exists
 			std::string world_gameid = getWorldGameId(world_path, is_legacy_world);
 			// If commanded to use a gameid, do so
-			if(commanded_gamespec.isValid()){
+			if (commanded_gamespec.isValid()) {
 				gamespec = commanded_gamespec;
-				if(commanded_gamespec.id != world_gameid){
-					errorstream<<"WARNING: Using commanded gameid ["
-							<<gamespec.id<<"]"<<" instead of world gameid ["
-							<<world_gameid<<"]"<<std::endl;
+				if (commanded_gamespec.id != world_gameid) {
+					errorstream << "WARNING: Using commanded gameid ["
+							<< gamespec.id << "]" << " instead of world gameid ["
+							<< world_gameid << "]" << std::endl;
 				}
-			} else{
+			} else {
 				// If world contains an embedded game, use it;
 				// Otherwise find world from local system.
 				gamespec = findWorldSubgame(world_path);
-				infostream<<"Using world gameid ["<<gamespec.id<<"]"<<std::endl;
+				infostream << "Using world gameid [" << gamespec.id << "]" << std::endl;
 			}
 		}
-		if(!gamespec.isValid()){
-			errorstream<<"Subgame ["<<gamespec.id<<"] could not be found."
-					<<std::endl;
+		if (!gamespec.isValid()) {
+			errorstream << "Subgame [" << gamespec.id << "] could not be found."
+					<< std::endl;
+			return 1;
+		}
+		verbosestream << _("Using gameid") << " [" << gamespec.id<<"]" << std::endl;
+
+		// Bind address
+		std::string bind_str = g_settings->get("bind_address");
+		Address bind_addr(0, 0, 0, 0, port);
+
+		if (g_settings->getBool("ipv6_server")) {
+			bind_addr.setAddress((IPv6AddressBytes*) NULL);
+		}
+		try {
+			bind_addr.Resolve(bind_str.c_str());
+		} catch (ResolveError &e) {
+			infostream << "Resolving bind address \"" << bind_str
+			           << "\" failed: " << e.what()
+		        	   << " -- Listening on all addresses." << std::endl;
+		}
+		if (bind_addr.isIPv6() && !g_settings->getBool("enable_ipv6")) {
+			errorstream << "Unable to listen on "
+			            << bind_addr.serializeString()
+				    << L" because IPv6 is disabled" << std::endl;
 			return 1;
 		}
-		verbosestream<<_("Using gameid")<<" ["<<gamespec.id<<"]"<<std::endl;
 
 		// Create server
-		Server server(world_path, configpath, gamespec, false);
-		server.start(port);
-		
+		Server server(world_path, gamespec, false, bind_addr.isIPv6());
+
+		// Database migration
+		if (cmd_args.exists("migrate")) {
+			std::string migrate_to = cmd_args.get("migrate");
+			Settings world_mt;
+			bool success = world_mt.readConfigFile((world_path + DIR_DELIM
+				+ "world.mt").c_str());
+			if (!success) {
+				errorstream << "Cannot read world.mt" << std::endl;
+				return 1;
+			}
+			if (!world_mt.exists("backend")) {
+				errorstream << "Please specify your current backend in world.mt file:"
+					<< std::endl << "	backend = {sqlite3|leveldb|redis|dummy}" << std::endl;
+				return 1;
+			}
+			std::string backend = world_mt.get("backend");
+			Database *new_db;
+			if (backend == migrate_to) {
+				errorstream << "Cannot migrate: new backend is same"
+					<<" as the old one" << std::endl;
+				return 1;
+			}
+			if (migrate_to == "sqlite3")
+				new_db = new Database_SQLite3(&(ServerMap&)server.getMap(), world_path);
+			#if USE_LEVELDB
+			else if (migrate_to == "leveldb")
+				new_db = new Database_LevelDB(&(ServerMap&)server.getMap(), world_path);
+			#endif
+			#if USE_REDIS
+			else if (migrate_to == "redis")
+				new_db = new Database_Redis(&(ServerMap&)server.getMap(), world_path);
+			#endif
+			else {
+				errorstream << "Migration to " << migrate_to
+					<< " is not supported" << std::endl;
+				return 1;
+			}
+
+			std::list<v3s16> blocks;
+			ServerMap &old_map = ((ServerMap&)server.getMap());
+			old_map.listAllLoadableBlocks(blocks);
+			int count = 0;
+			new_db->beginSave();
+			for (std::list<v3s16>::iterator i = blocks.begin(); i != blocks.end(); i++) {
+				MapBlock *block = old_map.loadBlock(*i);
+				new_db->saveBlock(block);
+				MapSector *sector = old_map.getSectorNoGenerate(v2s16(i->X, i->Z));
+				sector->deleteBlock(block);
+				++count;
+				if (count % 500 == 0)
+					actionstream << "Migrated " << count << " blocks "
+						<< (100.0 * count / blocks.size()) << "% completed" << std::endl;
+			}
+			new_db->endSave();
+			delete new_db;
+
+			actionstream << "Successfully migrated " << count << " blocks" << std::endl;
+			world_mt.set("backend", migrate_to);
+			if (!world_mt.updateConfigFile((world_path + DIR_DELIM + "world.mt").c_str()))
+				errorstream << "Failed to update world.mt!" << std::endl;
+			else
+				actionstream << "world.mt updated" << std::endl;
+
+			return 0;
+		}
+
+		server.start(bind_addr);
+
 		// Run server
 		dedicated_server_loop(server, kill);
 
@@ -1425,17 +1332,17 @@ int main(int argc, char *argv[])
 	/*
 		More parameters
 	*/
-	
+
 	std::string address = g_settings->get("address");
-	if(commanded_world != "")
+	if (commanded_world != "")
 		address = "";
-	else if(cmd_args.exists("address"))
+	else if (cmd_args.exists("address"))
 		address = cmd_args.get("address");
-	
+
 	std::string playername = g_settings->get("name");
-	if(cmd_args.exists("name"))
+	if (cmd_args.exists("name"))
 		playername = cmd_args.get("name");
-	
+
 	bool skip_main_menu = cmd_args.getFlag("go");
 
 	/*
@@ -1443,7 +1350,7 @@ int main(int argc, char *argv[])
 	*/
 
 	// Resolution selection
-	
+
 	bool fullscreen = g_settings->getBool("fullscreen");
 	u16 screenW = g_settings->getU16("screenW");
 	u16 screenH = g_settings->getU16("screenH");
@@ -1457,33 +1364,32 @@ int main(int argc, char *argv[])
 	// Determine driver
 
 	video::E_DRIVER_TYPE driverType;
-	
+
 	std::string driverstring = g_settings->get("video_driver");
 
-	if(driverstring == "null")
+	if (driverstring == "null")
 		driverType = video::EDT_NULL;
-	else if(driverstring == "software")
+	else if (driverstring == "software")
 		driverType = video::EDT_SOFTWARE;
-	else if(driverstring == "burningsvideo")
+	else if (driverstring == "burningsvideo")
 		driverType = video::EDT_BURNINGSVIDEO;
-	else if(driverstring == "direct3d8")
+	else if (driverstring == "direct3d8")
 		driverType = video::EDT_DIRECT3D8;
-	else if(driverstring == "direct3d9")
+	else if (driverstring == "direct3d9")
 		driverType = video::EDT_DIRECT3D9;
-	else if(driverstring == "opengl")
+	else if (driverstring == "opengl")
 		driverType = video::EDT_OPENGL;
 #ifdef _IRR_COMPILE_WITH_OGLES1_
-	else if(driverstring == "ogles1")
+	else if (driverstring == "ogles1")
 		driverType = video::EDT_OGLES1;
 #endif
 #ifdef _IRR_COMPILE_WITH_OGLES2_
-	else if(driverstring == "ogles2")
+	else if (driverstring == "ogles2")
 		driverType = video::EDT_OGLES2;
 #endif
-	else
-	{
-		errorstream<<"WARNING: Invalid video_driver specified; defaulting "
-				"to opengl"<<std::endl;
+	else {
+		errorstream << "WARNING: Invalid video_driver specified; defaulting "
+			<< "to opengl" << std::endl;
 		driverType = video::EDT_OPENGL;
 	}
 
@@ -1491,9 +1397,9 @@ int main(int argc, char *argv[])
 		List video modes if requested
 	*/
 
-	MyEventReceiver receiver;
+	MyEventReceiver* receiver = new MyEventReceiver();
 
-	if(cmd_args.getFlag("videomodes")){
+	if (cmd_args.getFlag("videomodes")) {
 		IrrlichtDevice *nulldevice;
 
 		SIrrlichtCreationParameters params = SIrrlichtCreationParameters();
@@ -1504,19 +1410,20 @@ int main(int argc, char *argv[])
 		params.Fullscreen    = false;
 		params.Stencilbuffer = false;
 		params.Vsync         = vsync;
-		params.EventReceiver = &receiver;
+		params.EventReceiver = receiver;
+		params.HighPrecisionFPU = g_settings->getBool("high_precision_fpu");
 
 		nulldevice = createDeviceEx(params);
 
-		if(nulldevice == 0)
+		if (nulldevice == 0)
 			return 1;
 
-		dstream<<_("Available video modes (WxHxD):")<<std::endl;
+		dstream << _("Available video modes (WxHxD):") << std::endl;
 
 		video::IVideoModeList *videomode_list =
 				nulldevice->getVideoModeList();
 
-		if(videomode_list == 0){
+		if (videomode_list == 0) {
 			nulldevice->drop();
 			return 1;
 		}
@@ -1524,30 +1431,28 @@ int main(int argc, char *argv[])
 		s32 videomode_count = videomode_list->getVideoModeCount();
 		core::dimension2d<u32> videomode_res;
 		s32 videomode_depth;
-		for (s32 i = 0; i < videomode_count; ++i){
+		for (s32 i = 0; i < videomode_count; ++i) {
 			videomode_res = videomode_list->getVideoModeResolution(i);
 			videomode_depth = videomode_list->getVideoModeDepth(i);
-			dstream<<videomode_res.Width<<"x"<<videomode_res.Height
-					<<"x"<<videomode_depth<<std::endl;
+			dstream<<videomode_res.Width << "x" << videomode_res.Height
+					<< "x" << videomode_depth << std::endl;
 		}
 
-		dstream<<_("Active video mode (WxHxD):")<<std::endl;
+		dstream << _("Active video mode (WxHxD):") << std::endl;
 		videomode_res = videomode_list->getDesktopResolution();
 		videomode_depth = videomode_list->getDesktopDepth();
-		dstream<<videomode_res.Width<<"x"<<videomode_res.Height
-				<<"x"<<videomode_depth<<std::endl;
+		dstream << videomode_res.Width << "x" << videomode_res.Height
+				<< "x" << videomode_depth << std::endl;
 
 		nulldevice->drop();
 
+		delete receiver;
 		return 0;
 	}
 
 	/*
 		Create device and exit if creation failed
 	*/
-
-	IrrlichtDevice *device;
-
 	SIrrlichtCreationParameters params = SIrrlichtCreationParameters();
 	params.DriverType    = driverType;
 	params.WindowSize    = core::dimension2d<u32>(screenW, screenH);
@@ -1556,13 +1461,40 @@ int main(int argc, char *argv[])
 	params.Fullscreen    = fullscreen;
 	params.Stencilbuffer = false;
 	params.Vsync         = vsync;
-	params.EventReceiver = &receiver;
+	params.EventReceiver = receiver;
+	params.HighPrecisionFPU = g_settings->getBool("high_precision_fpu");
+#ifdef __ANDROID__
+	params.PrivateData = porting::app_global;
+	params.OGLES2ShaderPath = std::string(porting::path_user + DIR_DELIM +
+			"media" + DIR_DELIM + "Shaders" + DIR_DELIM).c_str();
+#endif
 
-	device = createDeviceEx(params);
+	IrrlichtDevice * device = createDeviceEx(params);
 
-	if (device == 0)
+	if (device == 0) {
+		delete receiver;
 		return 1; // could not create selected driver.
-	
+	}
+
+	// Map our log level to irrlicht engine one.
+	static const irr::ELOG_LEVEL irr_log_level[5] = {
+		ELL_NONE,
+		ELL_ERROR,
+		ELL_WARNING,
+		ELL_INFORMATION,
+#if (IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR < 8)
+		ELL_INFORMATION
+#else
+		ELL_DEBUG
+#endif
+	};
+
+	ILogger* irr_logger = device->getLogger();
+	irr_logger->setLogLevel(irr_log_level[loglevel]);
+
+	porting::initIrrlicht(device);
+	late_init_default_settings(g_settings);
+
 	/*
 		Continue initialization
 	*/
@@ -1577,67 +1509,79 @@ int main(int argc, char *argv[])
 
 	// Create time getter
 	g_timegetter = new IrrlichtTimeGetter(device);
-	
+
 	// Create game callback for menus
 	g_gamecallback = new MainGameCallback(device);
-	
+
 	/*
 		Speed tests (done after irrlicht is loaded to get timer)
 	*/
-	if(cmd_args.getFlag("speedtests"))
+	if (cmd_args.getFlag("speedtests"))
 	{
-		dstream<<"Running speed tests"<<std::endl;
+		dstream << "Running speed tests" << std::endl;
 		SpeedTests();
 		device->drop();
 		return 0;
 	}
-	
+
 	device->setResizable(true);
 
 	bool random_input = g_settings->getBool("random_input")
 			|| cmd_args.getFlag("random-input");
 	InputHandler *input = NULL;
-	if(random_input)
+
+	if (random_input) {
 		input = new RandomInputHandler();
-	else
-		input = new RealInputHandler(device, &receiver);
-	
+	} else {
+		input = new RealInputHandler(device,receiver);
+	}
+
 	scene::ISceneManager* smgr = device->getSceneManager();
 
 	guienv = device->getGUIEnvironment();
 	gui::IGUISkin* skin = guienv->getSkin();
-	#if USE_FREETYPE
 	std::string font_path = g_settings->get("font_path");
-	u16 font_size = g_settings->getU16("font_size");
-	gui::IGUIFont *font = gui::CGUITTFont::createTTFont(guienv, font_path.c_str(), font_size);
+	gui::IGUIFont *font;
+	#if USE_FREETYPE
+	bool use_freetype = g_settings->getBool("freetype");
+	if (use_freetype) {
+		std::string fallback;
+		if (is_yes(gettext("needs_fallback_font")))
+			fallback = "fallback_";
+		u16 font_size = g_settings->getU16(fallback + "font_size");
+		font_path = g_settings->get(fallback + "font_path");
+		u32 font_shadow = g_settings->getU16(fallback + "font_shadow");
+		u32 font_shadow_alpha = g_settings->getU16(fallback + "font_shadow_alpha");
+		font = gui::CGUITTFont::createTTFont(guienv, font_path.c_str(), font_size,
+			true, true, font_shadow, font_shadow_alpha);
+	} else {
+		font = guienv->getFont(font_path.c_str());
+	}
 	#else
-	gui::IGUIFont* font = guienv->getFont(getTexturePath("fontlucida.png").c_str());
+	font = guienv->getFont(font_path.c_str());
 	#endif
-	if(font)
+	if (font)
 		skin->setFont(font);
 	else
-		errorstream<<"WARNING: Font file was not found."
-				" Using default font."<<std::endl;
+		errorstream << "WARNING: Font file was not found."
+				<< " Using default font." << std::endl;
 	// If font was not found, this will get us one
 	font = skin->getFont();
 	assert(font);
-	
+
 	u32 text_height = font->getDimension(L"Hello, world!").Height;
-	infostream<<"text_height="<<text_height<<std::endl;
+	infostream << "text_height=" << text_height << std::endl;
 
-	//skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255,0,0,0));
-	skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255,255,255,255));
-	//skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(0,0,0,0));
-	//skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(0,0,0,0));
-	skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(255,0,0,0));
-	skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(255,0,0,0));
-	skin->setColor(gui::EGDC_HIGH_LIGHT, video::SColor(255,70,100,50));
-	skin->setColor(gui::EGDC_HIGH_LIGHT_TEXT, video::SColor(255,255,255,255));
+	skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255, 255, 255, 255));
+	skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(255, 0, 0, 0));
+	skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(255, 0, 0, 0));
+	skin->setColor(gui::EGDC_HIGH_LIGHT, video::SColor(255, 70, 100, 50));
+	skin->setColor(gui::EGDC_HIGH_LIGHT_TEXT, video::SColor(255, 255, 255, 255));
 
 #if (IRRLICHT_VERSION_MAJOR >= 1 && IRRLICHT_VERSION_MINOR >= 8) || IRRLICHT_VERSION_MAJOR >= 2
 	// Irrlicht 1.8 input colours
-	skin->setColor(gui::EGDC_EDITABLE, video::SColor(255,128,128,128));
-	skin->setColor(gui::EGDC_FOCUSED_EDITABLE, video::SColor(255,96,134,49));
+	skin->setColor(gui::EGDC_EDITABLE, video::SColor(255, 128, 128, 128));
+	skin->setColor(gui::EGDC_FOCUSED_EDITABLE, video::SColor(255, 96, 134, 49));
 #endif
 
 
@@ -1647,10 +1591,10 @@ int main(int argc, char *argv[])
 	if (!g_menuclouds)
 		g_menuclouds = new Clouds(g_menucloudsmgr->getRootSceneNode(),
 			g_menucloudsmgr, -1, rand(), 100);
-	g_menuclouds->update(v2f(0, 0), video::SColor(255,200,200,255));
+	g_menuclouds->update(v2f(0, 0), video::SColor(255, 200, 200, 255));
 	scene::ICameraSceneNode* camera;
 	camera = g_menucloudsmgr->addCameraSceneNode(0,
-				v3f(0,0,0), v3f(0, 60, 100));
+				v3f(0, 0, 0), v3f(0, 60, 100));
 	camera->setFarValue(10000);
 
 	/*
@@ -1674,11 +1618,12 @@ int main(int argc, char *argv[])
 	/*
 		Menu-game loop
 	*/
-	while(device->run() && kill == false)
+	while (device->run() && (kill == false) &&
+			(g_gamecallback->shutdown_requested == false))
 	{
 		// Set the window caption
 		wchar_t* text = wgettext("Main Menu");
-		device->setWindowCaption((std::wstring(L"Minetest [")+text+L"]").c_str());
+		device->setWindowCaption((std::wstring(L"Minetest [") + text + L"]").c_str());
 		delete[] text;
 
 		// This is used for catching disconnects
@@ -1689,15 +1634,15 @@ int main(int argc, char *argv[])
 				Clear everything from the GUIEnvironment
 			*/
 			guienv->clear();
-			
+
 			/*
 				We need some kind of a root node to be able to add
 				custom gui elements directly on the screen.
 				Otherwise they won't be automatically drawn.
 			*/
 			guiroot = guienv->addStaticText(L"",
-					core::rect<s32>(0, 0, 10000, 10000));
-			
+				core::rect<s32>(0, 0, 10000, 10000));
+
 			SubgameSpec gamespec;
 			WorldSpec worldspec;
 			bool simple_singleplayer_mode = false;
@@ -1713,364 +1658,173 @@ int main(int argc, char *argv[])
 
 				Loop quits when menu returns proper parameters.
 			*/
-			while(kill == false)
-			{
+			while (kill == false) {
 				// If skip_main_menu, only go through here once
-				if(skip_main_menu && !first_loop){
+				if (skip_main_menu && !first_loop) {
 					kill = true;
 					break;
 				}
 				first_loop = false;
-				
+
 				// Cursor can be non-visible when coming from the game
+				#ifndef ANDROID
 				device->getCursorControl()->setVisible(true);
+				#endif
 				// Some stuff are left to scene manager when coming from the game
 				// (map at least?)
 				smgr->clear();
-				
+
 				// Initialize menu data
 				MainMenuData menudata;
-				if(g_settings->exists("selected_mainmenu_tab"))
-					menudata.selected_tab = g_settings->getS32("selected_mainmenu_tab");
-				if(g_settings->exists("selected_serverlist"))
-					menudata.selected_serverlist = g_settings->getS32("selected_serverlist");
-				if(g_settings->exists("selected_mainmenu_game")){
-					menudata.selected_game = g_settings->get("selected_mainmenu_game");
-					menudata.selected_game_name = findSubgame(menudata.selected_game).name;
-				}
-				menudata.address = narrow_to_wide(address);
-				menudata.name = narrow_to_wide(playername);
-				menudata.port = narrow_to_wide(itos(port));
-				if(cmd_args.exists("password"))
-					menudata.password = narrow_to_wide(cmd_args.get("password"));
-				menudata.fancy_trees = g_settings->getBool("new_style_leaves");
-				menudata.smooth_lighting = g_settings->getBool("smooth_lighting");
-				menudata.clouds_3d = g_settings->getBool("enable_3d_clouds");
-				menudata.opaque_water = g_settings->getBool("opaque_water");
-				menudata.mip_map = g_settings->getBool("mip_map");
-				menudata.anisotropic_filter = g_settings->getBool("anisotropic_filter");
-				menudata.bilinear_filter = g_settings->getBool("bilinear_filter");
-				menudata.trilinear_filter = g_settings->getBool("trilinear_filter");
-				menudata.enable_shaders = g_settings->getS32("enable_shaders");
-				menudata.preload_item_visuals = g_settings->getBool("preload_item_visuals");
-				menudata.enable_particles = g_settings->getBool("enable_particles");
-				menudata.liquid_finite = g_settings->getBool("liquid_finite");
-				driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, menudata.mip_map);
-				menudata.creative_mode = g_settings->getBool("creative_mode");
-				menudata.enable_damage = g_settings->getBool("enable_damage");
+				menudata.address = address;
+				menudata.name = playername;
+				menudata.port = itos(port);
+				menudata.errormessage = wide_to_narrow(error_message);
+				error_message = L"";
+				if (cmd_args.exists("password"))
+					menudata.password = cmd_args.get("password");
+
+				driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, g_settings->getBool("mip_map"));
+
 				menudata.enable_public = g_settings->getBool("server_announce");
-				// Default to selecting nothing
-				menudata.selected_world = -1;
-				// Get world listing for the menu
+
 				std::vector<WorldSpec> worldspecs = getAvailableWorlds();
-				// If there is only one world, select it
-				if(worldspecs.size() == 1){
-					menudata.selected_world = 0;
-				}
-				// Otherwise try to select according to selected_world_path
-				else if(g_settings->exists("selected_world_path")){
-					std::string trypath = g_settings->get("selected_world_path");
-					for(u32 i=0; i<worldspecs.size(); i++){
-						if(worldspecs[i].path == trypath){
-							menudata.selected_world = i;
-							break;
-						}
-					}
-				}
+
 				// If a world was commanded, append and select it
-				if(commanded_world != ""){
-					std::string gameid = getWorldGameId(commanded_world, true);
-					std::string name = _("[--world parameter]");
-					if(gameid == ""){
-						gameid = g_settings->get("default_game");
-						name += " [new]";
+				if(commanded_world != "") {
+					worldspec.gameid = getWorldGameId(commanded_world, true);
+					worldspec.name = _("[--world parameter]");
+					if(worldspec.gameid == "") {
+						worldspec.gameid = g_settings->get("default_game");
+						worldspec.name += " [new]";
 					}
-					WorldSpec spec(commanded_world, name, gameid);
-					worldspecs.push_back(spec);
-					menudata.selected_world = worldspecs.size()-1;
-				}
-				// Copy worldspecs to menu
-				menudata.worlds = worldspecs;
-				// Get game listing
-				menudata.games = getAvailableGames();
-				// If selected game doesn't exist, take first from list
-				if(findSubgame(menudata.selected_game).id == "" &&
-						!menudata.games.empty()){
-					menudata.selected_game = menudata.games[0].id;
+					worldspec.path = commanded_world;
 				}
-				const SubgameSpec *menugame = getMenuGame(menudata);
 
-				MenuTextures menutextures;
-				menutextures.update(driver, menugame, menudata.selected_tab);
-
-				if(skip_main_menu == false)
-				{
+				if (skip_main_menu == false) {
 					video::IVideoDriver* driver = device->getVideoDriver();
-					float fps_max = g_settings->getFloat("fps_max");
-					infostream<<"Waiting for other menus"<<std::endl;
-					while(device->run() && kill == false)
-					{
-						if(noMenuActive())
+
+					infostream << "Waiting for other menus" << std::endl;
+					while (device->run() && kill == false) {
+						if (noMenuActive())
 							break;
 						driver->beginScene(true, true,
-								video::SColor(255,128,128,128));
-						drawMenuBackground(driver, menutextures);
+								video::SColor(255, 128, 128, 128));
 						guienv->drawAll();
 						driver->endScene();
 						// On some computers framerate doesn't seem to be
 						// automatically limited
 						sleep_ms(25);
 					}
-					infostream<<"Waited for other menus"<<std::endl;
-
-					GUIMainMenu *menu =
-							new GUIMainMenu(guienv, guiroot, -1, 
-								&g_menumgr, &menudata, g_gamecallback);
-					menu->allowFocusRemoval(true);
-
-					if(error_message != L"")
-					{
-						verbosestream<<"error_message = "
-								<<wide_to_narrow(error_message)<<std::endl;
-
-						GUIMessageMenu *menu2 =
-								new GUIMessageMenu(guienv, guiroot, -1, 
-									&g_menumgr, error_message.c_str());
-						menu2->drop();
-						error_message = L"";
-					}
-
-					// Time is in milliseconds, for clouds
-					u32 lasttime = device->getTimer()->getTime();
-
-					MenuMusicFetcher soundfetcher;
-					ISoundManager *sound = NULL;
-					sound = createOpenALSoundManager(&soundfetcher);
-					if(!sound)
-						sound = &dummySoundManager;
-					SimpleSoundSpec spec;
-					spec.name = "main_menu";
-					spec.gain = 1;
-					s32 handle = sound->playSound(spec, true);
-
-					infostream<<"Created main menu"<<std::endl;
+					infostream << "Waited for other menus" << std::endl;
 
-					while(device->run() && kill == false)
-					{
-						if(menu->getStatus() == true)
-							break;
-
-						// Game can be selected in the menu
-						menugame = getMenuGame(menudata);
-						menutextures.update(driver, menugame, menu->getTab());
-						// Clouds for the main menu
-						bool cloud_menu_background = g_settings->getBool("menu_clouds");
-						if(menugame){
-							// If game has regular background and no overlay, don't use clouds
-							if(cloud_menu_background && menutextures.background &&
-									!menutextures.overlay){
-								cloud_menu_background = false;
-							}
-							// If game game has overlay and no regular background, always draw clouds
-							else if(menutextures.overlay && !menutextures.background){
-								cloud_menu_background = true;
-							}
-						}
-
-						// Time calc for the clouds
-						f32 dtime=0; // in seconds
-						if (cloud_menu_background) {
-							u32 time = device->getTimer()->getTime();
-							if(time > lasttime)
-								dtime = (time - lasttime) / 1000.0;
- 							else
-								dtime = 0;
-							lasttime = time;
-						}
-
-						//driver->beginScene(true, true, video::SColor(255,0,0,0));
-						driver->beginScene(true, true, video::SColor(255,140,186,250));
-
-						if (cloud_menu_background) {
-							// *3 otherwise the clouds would move very slowly
-							g_menuclouds->step(dtime*3); 
-							g_menuclouds->render();
-							g_menucloudsmgr->drawAll();
-							drawMenuOverlay(driver, menutextures);
-							drawMenuHeader(driver, menutextures);
-							drawMenuFooter(driver, menutextures);
-						} else {
-							drawMenuBackground(driver, menutextures);
-							drawMenuHeader(driver, menutextures);
-							drawMenuFooter(driver, menutextures);
-						}
+					/* show main menu */
+					GUIEngine mymenu(device, guiroot, &g_menumgr,smgr,&menudata,kill);
 
-						guienv->drawAll();
+					//once finished you'll never end up here
+					smgr->clear();
+				}
 
-						driver->endScene();
-						
-						// On some computers framerate doesn't seem to be
-						// automatically limited
-						if (cloud_menu_background) {
-							// Time of frame without fps limit
-							float busytime;
-							u32 busytime_u32;
-							// not using getRealTime is necessary for wine
-							u32 time = device->getTimer()->getTime();
-							if(time > lasttime)
-								busytime_u32 = time - lasttime;
-							else
-								busytime_u32 = 0;
-							busytime = busytime_u32 / 1000.0;
-
-							// FPS limiter
-							u32 frametime_min = 1000./fps_max;
-			
-							if(busytime_u32 < frametime_min) {
-								u32 sleeptime = frametime_min - busytime_u32;
-								device->sleep(sleeptime);
-							}
-						} else {
-							sleep_ms(25);
-						}
-					}
-					sound->stopSound(handle);
-					if(sound != &dummySoundManager){
-						delete sound;
-						sound = NULL;
-					}
+				if (menudata.errormessage != "") {
+					error_message = narrow_to_wide(menudata.errormessage);
+					continue;
+				}
 
-					infostream<<"Dropping main menu"<<std::endl;
+				//update worldspecs (necessary as new world may have been created)
+				worldspecs = getAvailableWorlds();
 
-					menu->drop();
-				}
+				if (menudata.name == "")
+					menudata.name = std::string("Guest") + itos(myrand_range(1000,9999));
+				else
+					playername = menudata.name;
 
-				playername = wide_to_narrow(menudata.name);
-				if (playername == "")
-					playername = std::string("Guest") + itos(myrand_range(1000,9999));
-				password = translatePassword(playername, menudata.password);
+				password = translatePassword(playername, narrow_to_wide(menudata.password));
 				//infostream<<"Main: password hash: '"<<password<<"'"<<std::endl;
 
-				address = wide_to_narrow(menudata.address);
-				int newport = stoi(wide_to_narrow(menudata.port));
-				if(newport != 0)
+				address = menudata.address;
+				int newport = stoi(menudata.port);
+				if (newport != 0)
 					port = newport;
+
 				simple_singleplayer_mode = menudata.simple_singleplayer_mode;
+
 				// Save settings
-				g_settings->setS32("selected_mainmenu_tab", menudata.selected_tab);
-				g_settings->setS32("selected_serverlist", menudata.selected_serverlist);
-				g_settings->set("selected_mainmenu_game", menudata.selected_game);
-				g_settings->set("new_style_leaves", itos(menudata.fancy_trees));
-				g_settings->set("smooth_lighting", itos(menudata.smooth_lighting));
-				g_settings->set("enable_3d_clouds", itos(menudata.clouds_3d));
-				g_settings->set("opaque_water", itos(menudata.opaque_water));
-
-				g_settings->set("mip_map", itos(menudata.mip_map));
-				g_settings->set("anisotropic_filter", itos(menudata.anisotropic_filter));
-				g_settings->set("bilinear_filter", itos(menudata.bilinear_filter));
-				g_settings->set("trilinear_filter", itos(menudata.trilinear_filter));
-
-				g_settings->setS32("enable_shaders", menudata.enable_shaders);
-				g_settings->set("preload_item_visuals", itos(menudata.preload_item_visuals));
-				g_settings->set("enable_particles", itos(menudata.enable_particles));
-				g_settings->set("liquid_finite", itos(menudata.liquid_finite));
-
-				g_settings->set("creative_mode", itos(menudata.creative_mode));
-				g_settings->set("enable_damage", itos(menudata.enable_damage));
-				g_settings->set("server_announce", itos(menudata.enable_public));
 				g_settings->set("name", playername);
-				g_settings->set("address", address);
-				g_settings->set("port", itos(port));
-				if(menudata.selected_world != -1)
-					g_settings->set("selected_world_path",
-							worldspecs[menudata.selected_world].path);
 
 				// Break out of menu-game loop to shut down cleanly
-				if(device->run() == false || kill == true)
+				if (device->run() == false || kill == true)
 					break;
-				
+
 				current_playername = playername;
 				current_password = password;
 				current_address = address;
 				current_port = port;
 
 				// If using simple singleplayer mode, override
-				if(simple_singleplayer_mode){
+				if (simple_singleplayer_mode) {
 					current_playername = "singleplayer";
 					current_password = "";
 					current_address = "";
-					current_port = 30011;
-				}
-				else if (address != "")
-				{
+					current_port = myrand_range(49152, 65535);
+				} else if (address != "") {
 					ServerListSpec server;
 					server["name"] = menudata.servername;
-					server["address"] = wide_to_narrow(menudata.address);
-					server["port"] = wide_to_narrow(menudata.port);
+					server["address"] = menudata.address;
+					server["port"] = menudata.port;
 					server["description"] = menudata.serverdescription;
 					ServerList::insert(server);
 				}
-				
-				// Set world path to selected one
-				if(menudata.selected_world != -1){
+
+				if ((!skip_main_menu) &&
+						(menudata.selected_world >= 0) &&
+						(menudata.selected_world < (int)worldspecs.size())) {
+					g_settings->set("selected_world_path",
+							worldspecs[menudata.selected_world].path);
 					worldspec = worldspecs[menudata.selected_world];
-					infostream<<"Selected world: "<<worldspec.name
-							<<" ["<<worldspec.path<<"]"<<std::endl;
-				}
 
-				// Only refresh if so requested
-				if(menudata.only_refresh){
-					infostream<<"Refreshing menu"<<std::endl;
-					continue;
-				}
-				
-				// Create new world if requested
-				if(menudata.create_world_name != L"")
-				{
-					std::string path = porting::path_user + DIR_DELIM
-							"worlds" + DIR_DELIM
-							+ wide_to_narrow(menudata.create_world_name);
-					// Create world if it doesn't exist
-					if(!initializeWorld(path, menudata.create_world_gameid)){
-						error_message = wgettext("Failed to initialize world");
-						errorstream<<wide_to_narrow(error_message)<<std::endl;
-						continue;
-					}
-					g_settings->set("selected_world_path", path);
-					g_settings->set("selected_mainmenu_game", menudata.create_world_gameid);
-					continue;
 				}
 
+				infostream <<"Selected world: " << worldspec.name
+							<< " ["<<worldspec.path<<"]" <<std::endl;
+
+
 				// If local game
-				if(current_address == "")
-				{
-					if(menudata.selected_world == -1){
+				if (current_address == "") {
+					if (worldspec.path == "") {
 						error_message = wgettext("No world selected and no address "
 								"provided. Nothing to do.");
-						errorstream<<wide_to_narrow(error_message)<<std::endl;
+						errorstream << wide_to_narrow(error_message) << std::endl;
+						continue;
+					}
+
+					if (!fs::PathExists(worldspec.path)) {
+						error_message = wgettext("Provided world path doesn't exist: ")
+								+ narrow_to_wide(worldspec.path);
+						errorstream << wide_to_narrow(error_message) << std::endl;
 						continue;
 					}
+
 					// Load gamespec for required game
 					gamespec = findWorldSubgame(worldspec.path);
-					if(!gamespec.isValid() && !commanded_gamespec.isValid()){
+					if (!gamespec.isValid() && !commanded_gamespec.isValid()) {
 						error_message = wgettext("Could not find or load game \"")
 								+ narrow_to_wide(worldspec.gameid) + L"\"";
-						errorstream<<wide_to_narrow(error_message)<<std::endl;
+						errorstream << wide_to_narrow(error_message) << std::endl;
 						continue;
 					}
-					if(commanded_gamespec.isValid() &&
-							commanded_gamespec.id != worldspec.gameid){
+					if (commanded_gamespec.isValid() &&
+							commanded_gamespec.id != worldspec.gameid) {
 						errorstream<<"WARNING: Overriding gamespec from \""
-								<<worldspec.gameid<<"\" to \""
-								<<commanded_gamespec.id<<"\""<<std::endl;
+								<< worldspec.gameid << "\" to \""
+								<< commanded_gamespec.id << "\"" << std::endl;
 						gamespec = commanded_gamespec;
 					}
 
-					if(!gamespec.isValid()){
+					if (!gamespec.isValid()) {
 						error_message = wgettext("Invalid gamespec.");
 						error_message += L" (world_gameid="
-								+narrow_to_wide(worldspec.gameid)+L")";
-						errorstream<<wide_to_narrow(error_message)<<std::endl;
+								+ narrow_to_wide(worldspec.gameid) + L")";
+						errorstream << wide_to_narrow(error_message) << std::endl;
 						continue;
 					}
 				}
@@ -2078,14 +1832,22 @@ int main(int argc, char *argv[])
 				// Continue to game
 				break;
 			}
-			
+
 			// Break out of menu-game loop to shut down cleanly
-			if(device->run() == false || kill == true)
+			if (device->run() == false || kill == true) {
+				if (g_settings_path != "") {
+					g_settings->updateConfigFile(g_settings_path.c_str());
+				}
 				break;
+			}
 
 			/*
 				Run game
 			*/
+#ifdef HAVE_TOUCHSCREENGUI
+	receiver->m_touchscreengui = new TouchScreenGUI(device, receiver);
+	g_touchscreengui = receiver->m_touchscreengui;
+#endif
 			the_game(
 				kill,
 				random_input,
@@ -2098,18 +1860,22 @@ int main(int argc, char *argv[])
 				current_address,
 				current_port,
 				error_message,
-				configpath,
 				chat_backend,
 				gamespec,
 				simple_singleplayer_mode
 			);
 			smgr->clear();
+#ifdef HAVE_TOUCHSCREENGUI
+	delete g_touchscreengui;
+	g_touchscreengui = NULL;
+	receiver->m_touchscreengui = NULL;
+#endif
 
 		} //try
 		catch(con::PeerNotFoundException &e)
 		{
 			error_message = wgettext("Connection error (timed out?)");
-			errorstream<<wide_to_narrow(error_message)<<std::endl;
+			errorstream << wide_to_narrow(error_message) << std::endl;
 		}
 #ifdef NDEBUG
 		catch(std::exception &e)
@@ -2117,27 +1883,26 @@ int main(int argc, char *argv[])
 			std::string narrow_message = "Some exception: \"";
 			narrow_message += e.what();
 			narrow_message += "\"";
-			errorstream<<narrow_message<<std::endl;
+			errorstream << narrow_message << std::endl;
 			error_message = narrow_to_wide(narrow_message);
 		}
 #endif
 
 		// If no main menu, show error and exit
-		if(skip_main_menu)
-		{
-			if(error_message != L""){
-				verbosestream<<"error_message = "
-						<<wide_to_narrow(error_message)<<std::endl;
+		if (skip_main_menu) {
+			if (error_message != L"") {
+				verbosestream << "error_message = "
+						<< wide_to_narrow(error_message) << std::endl;
 				retval = 1;
 			}
 			break;
 		}
 	} // Menu-game loop
-	
-	
+
+
 	g_menuclouds->drop();
 	g_menucloudsmgr->drop();
-	
+
 	delete input;
 
 	/*
@@ -2145,34 +1910,41 @@ int main(int argc, char *argv[])
 	*/
 	device->drop();
 
-	delete font;
-
+#if USE_FREETYPE
+	if (use_freetype)
+		font->drop();
+#endif
+	delete receiver;
 #endif // !SERVER
-	
+
 	// Update configuration file
-	if(configpath != "")
-		g_settings->updateConfigFile(configpath.c_str());
-	
+	if (g_settings_path != "")
+		g_settings->updateConfigFile(g_settings_path.c_str());
+
 	// Print modified quicktune values
 	{
 		bool header_printed = false;
 		std::vector<std::string> names = getQuicktuneNames();
-		for(u32 i=0; i<names.size(); i++){
+		for(u32 i = 0; i < names.size(); i++) {
 			QuicktuneValue val = getQuicktuneValue(names[i]);
-			if(!val.modified)
+			if (!val.modified)
 				continue;
-			if(!header_printed){
-				dstream<<"Modified quicktune values:"<<std::endl;
+			if (!header_printed) {
+				dstream << "Modified quicktune values:" << std::endl;
 				header_printed = true;
 			}
-			dstream<<names[i]<<" = "<<val.getString()<<std::endl;
+			dstream<<names[i] << " = " << val.getString() << std::endl;
 		}
 	}
 
+	// Stop httpfetch thread (if started)
+	httpfetch_cleanup();
+
 	END_DEBUG_EXCEPTION_HANDLER(errorstream)
-	
+
 	debugstreams_deinit();
-	
+
+
 	return retval;
 }