X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmain.cpp;h=72daaef012a0fe1360e7e51384d7fce41823e703;hb=630f453da402c7b6f0af9ea32aa8b127ce2e4629;hp=08af6a37d8bd59794924cb89c8b68690b1d5d52f;hpb=319662c0ed047c6604d802336b54c325867fcab9;p=minetest.git

diff --git a/src/main.cpp b/src/main.cpp
index 08af6a37d..72daaef01 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -17,112 +17,103 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
-#ifdef NDEBUG
-	/*#ifdef _WIN32
-		#pragma message ("Disabling unit tests")
-	#else
-		#warning "Disabling unit tests"
-	#endif*/
-	// Disable unit tests
-	#define ENABLE_TESTS 0
-#else
-	// Enable unit tests
-	#define ENABLE_TESTS 1
-#endif
-
 #ifdef _MSC_VER
-#ifndef SERVER // Dedicated server isn't linked with Irrlicht
-	#pragma comment(lib, "Irrlicht.lib")
-	// This would get rid of the console window
-	//#pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup")
-#endif
+	#ifndef SERVER // Dedicated server isn't linked with Irrlicht
+		#pragma comment(lib, "Irrlicht.lib")
+		// This would get rid of the console window
+		//#pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup")
+	#endif
 	#pragma comment(lib, "zlibwapi.lib")
 	#pragma comment(lib, "Shell32.lib")
 #endif
 
 #include "irrlicht.h" // createDevice
 
-#include "main.h"
 #include "mainmenumanager.h"
-#include <iostream>
-#include <fstream>
-#include <locale.h>
 #include "irrlichttypes_extrabloated.h"
 #include "debug.h"
-#include "test.h"
-#include "clouds.h"
+#include "unittest/test.h"
 #include "server.h"
-#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"
-#include "tile.h"
-#include "chat.h"
 #include "defaultsettings.h"
 #include "gettext.h"
-#include "settings.h"
-#include "profiler.h"
 #include "log.h"
-#include "mods.h"
-#if USE_FREETYPE
-#include "xCGUITTFont.h"
-#endif
-#include "util/string.h"
-#include "subgame.h"
 #include "quicktune.h"
-#include "serverlist.h"
+#include "httpfetch.h"
+#include "guiEngine.h"
+#include "map.h"
+#include "player.h"
+#include "mapsector.h"
+#include "fontengine.h"
+#include "gameparams.h"
+#include "database.h"
+#include "config.h"
+#if USE_CURSES
+	#include "terminal_chat_console.h"
+#endif
+#ifndef SERVER
+#include "client/clientlauncher.h"
+#endif
 
-/*
-	Settings.
-	These are loaded from the config file.
-*/
-Settings main_settings;
-Settings *g_settings = &main_settings;
+#ifdef HAVE_TOUCHSCREENGUI
+	#include "touchscreengui.h"
+#endif
 
-// Global profiler
-Profiler main_profiler;
-Profiler *g_profiler = &main_profiler;
+#if !defined(SERVER) && \
+	(IRRLICHT_VERSION_MAJOR == 1) && \
+	(IRRLICHT_VERSION_MINOR == 8) && \
+	(IRRLICHT_VERSION_REVISION == 2)
+	#error "Irrlicht 1.8.2 is known to be broken - please update Irrlicht to version >= 1.8.3"
+#endif
 
-/*
-	Debug streams
-*/
+#define DEBUGFILE "debug.txt"
+#define DEFAULT_SERVER_PORT 30000
 
-// Connection
-std::ostream *dout_con_ptr = &dummyout;
-std::ostream *derr_con_ptr = &verbosestream;
+typedef std::map<std::string, ValueSpec> OptionList;
 
-// Server
-std::ostream *dout_server_ptr = &infostream;
-std::ostream *derr_server_ptr = &errorstream;
+/**********************************************************************
+ * Private functions
+ **********************************************************************/
 
-// Client
-std::ostream *dout_client_ptr = &infostream;
-std::ostream *derr_client_ptr = &errorstream;
+static bool get_cmdline_opts(int argc, char *argv[], Settings *cmd_args);
+static void set_allowed_options(OptionList *allowed_options);
 
-#ifndef SERVER
-/*
-	Random stuff
-*/
+static void print_help(const OptionList &allowed_options);
+static void print_allowed_options(const OptionList &allowed_options);
+static void print_version();
+static void print_worldspecs(const std::vector<WorldSpec> &worldspecs,
+							 std::ostream &os);
+static void print_modified_quicktune_values();
 
-/* mainmenumanager.h */
+static void list_game_ids();
+static void list_worlds();
+static void setup_log_params(const Settings &cmd_args);
+static bool create_userdata_path();
+static bool init_common(const Settings &cmd_args, int argc, char *argv[]);
+static void startup_message();
+static bool read_config_file(const Settings &cmd_args);
+static void init_log_streams(const Settings &cmd_args);
 
-gui::IGUIEnvironment* guienv = NULL;
-gui::IGUIStaticText *guiroot = NULL;
-MainMenuManager g_menumgr;
+static bool game_configure(GameParams *game_params, const Settings &cmd_args);
+static void game_configure_port(GameParams *game_params, const Settings &cmd_args);
 
-bool noMenuActive()
-{
-	return (g_menumgr.menuCount() == 0);
-}
+static bool game_configure_world(GameParams *game_params, const Settings &cmd_args);
+static bool get_world_from_cmdline(GameParams *game_params, const Settings &cmd_args);
+static bool get_world_from_config(GameParams *game_params, const Settings &cmd_args);
+static bool auto_select_world(GameParams *game_params);
+static std::string get_clean_world_path(const std::string &path);
 
-// Passed to menus to allow disconnecting and exiting
-MainGameCallback *g_gamecallback = NULL;
-#endif
+static bool game_configure_subgame(GameParams *game_params, const Settings &cmd_args);
+static bool get_game_from_cmdline(GameParams *game_params, const Settings &cmd_args);
+static bool determine_subgame(GameParams *game_params);
+
+static bool run_dedicated_server(const GameParams &game_params, const Settings &cmd_args);
+static bool migrate_database(const GameParams &game_params, const Settings &cmd_args);
+
+/**********************************************************************/
 
 /*
 	gettime.h implementation
@@ -141,908 +132,371 @@ u32 getTime(TimePrecision prec)
 	return porting::getTime(prec);
 }
 
-#else
-
-// A small helper class
-class TimeGetter
-{
-public:
-	virtual u32 getTime(TimePrecision prec) = 0;
-};
+#endif
 
-// A precise irrlicht one
-class IrrlichtTimeGetter: public TimeGetter
-{
-public:
-	IrrlichtTimeGetter(IrrlichtDevice *device):
-		m_device(device)
-	{}
-	u32 getTime(TimePrecision prec)
-	{
-		if (prec == PRECISION_MILLI) {
-			if(m_device == NULL)
-				return 0;
-			return m_device->getTimer()->getRealTime();
-		} else {
-			return porting::getTime(prec);
-		}
-	}
-private:
-	IrrlichtDevice *m_device;
-};
-// Not so precise one which works without irrlicht
-class SimpleTimeGetter: public TimeGetter
-{
-public:
-	u32 getTime(TimePrecision prec)
-	{
-		return porting::getTime(prec);
-	}
-};
+FileLogOutput file_log_output;
 
-// A pointer to a global instance of the time getter
-// TODO: why?
-TimeGetter *g_timegetter = NULL;
+static OptionList allowed_options;
 
-u32 getTimeMs()
+int main(int argc, char *argv[])
 {
-	if(g_timegetter == NULL)
-		return 0;
-	return g_timegetter->getTime(PRECISION_MILLI);
-}
+	int retval;
 
-u32 getTime(TimePrecision prec) {
-	if (g_timegetter == NULL)
-		return 0;
-	return g_timegetter->getTime(prec);
-}
+	debug_set_exception_handler();
 
-#endif
+	g_logger.registerThread("Main");
+	g_logger.addOutputMaxLevel(&stderr_output, LL_ACTION);
 
-class StderrLogOutput: public ILogOutput
-{
-public:
-	/* line: Full line with timestamp, level and thread */
-	void printLog(const std::string &line)
-	{
-		std::cerr<<line<<std::endl;
+	Settings cmd_args;
+	bool cmd_args_ok = get_cmdline_opts(argc, argv, &cmd_args);
+	if (!cmd_args_ok
+			|| cmd_args.getFlag("help")
+			|| cmd_args.exists("nonopt1")) {
+		print_help(allowed_options);
+		return cmd_args_ok ? 0 : 1;
 	}
-} main_stderr_log_out;
 
-class DstreamNoStderrLogOutput: public ILogOutput
-{
-public:
-	/* line: Full line with timestamp, level and thread */
-	void printLog(const std::string &line)
-	{
-		dstream_no_stderr<<line<<std::endl;
+	if (cmd_args.getFlag("version")) {
+		print_version();
+		return 0;
 	}
-} main_dstream_no_stderr_log_out;
-
-#ifndef SERVER
 
-/*
-	Event handler for Irrlicht
+	setup_log_params(cmd_args);
 
-	NOTE: Everything possible should be moved out from here,
-	      probably to InputHandler and the_game
-*/
+	porting::signal_handler_init();
 
-class MyEventReceiver : public IEventReceiver
-{
-public:
-	// This is the one method that we have to implement
-	virtual bool OnEvent(const SEvent& event)
-	{
-		/*
-			React to nothing here if a menu is active
-		*/
-		if(noMenuActive() == false)
-		{
-			return false;
-		}
+#ifdef __ANDROID__
+	porting::initAndroid();
+	porting::initializePathsAndroid();
+#else
+	porting::initializePaths();
+#endif
 
-		// Remember whether each key is down or up
-		if(event.EventType == irr::EET_KEY_INPUT_EVENT)
-		{
-			if(event.KeyInput.PressedDown) {
-				keyIsDown.set(event.KeyInput);
-				keyWasDown.set(event.KeyInput);
-			} else {
-				keyIsDown.unset(event.KeyInput);
-			}
-		}
+	if (!create_userdata_path()) {
+		errorstream << "Cannot create user data directory" << std::endl;
+		return 1;
+	}
 
-		if(event.EventType == irr::EET_MOUSE_INPUT_EVENT)
-		{
-			if(noMenuActive() == false)
-			{
-				left_active = false;
-				middle_active = false;
-				right_active = false;
-			}
-			else
-			{
-				left_active = event.MouseInput.isLeftPressed();
-				middle_active = event.MouseInput.isMiddlePressed();
-				right_active = event.MouseInput.isRightPressed();
-
-				if(event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)
-				{
-					leftclicked = true;
-				}
-				if(event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN)
-				{
-					rightclicked = true;
-				}
-				if(event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP)
-				{
-					leftreleased = true;
-				}
-				if(event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP)
-				{
-					rightreleased = true;
-				}
-				if(event.MouseInput.Event == EMIE_MOUSE_WHEEL)
-				{
-					mouse_wheel += event.MouseInput.Wheel;
-				}
-			}
-		}
+	// Initialize debug stacks
+	DSTACK(FUNCTION_NAME);
 
-		return false;
-	}
+	// Debug handler
+	BEGIN_DEBUG_EXCEPTION_HANDLER
 
-	bool IsKeyDown(const KeyPress &keyCode) const
-	{
-		return keyIsDown[keyCode];
-	}
-	
-	// Checks whether a key was down and resets the state
-	bool WasKeyDown(const KeyPress &keyCode)
-	{
-		bool b = keyWasDown[keyCode];
-		if (b)
-			keyWasDown.unset(keyCode);
-		return b;
+	// List gameids if requested
+	if (cmd_args.exists("gameid") && cmd_args.get("gameid") == "list") {
+		list_game_ids();
+		return 0;
 	}
 
-	s32 getMouseWheel()
-	{
-		s32 a = mouse_wheel;
-		mouse_wheel = 0;
-		return a;
+	// List worlds if requested
+	if (cmd_args.exists("world") && cmd_args.get("world") == "list") {
+		list_worlds();
+		return 0;
 	}
 
-	void clearInput()
-	{
-		keyIsDown.clear();
-		keyWasDown.clear();
-
-		leftclicked = false;
-		rightclicked = false;
-		leftreleased = false;
-		rightreleased = false;
-
-		left_active = false;
-		middle_active = false;
-		right_active = false;
+	if (!init_common(cmd_args, argc, argv))
+		return 1;
 
-		mouse_wheel = 0;
+#ifndef __ANDROID__
+	// Run unit tests
+	if (cmd_args.getFlag("run-unittests")) {
+		return run_tests();
 	}
+#endif
 
-	MyEventReceiver()
-	{
-		clearInput();
-	}
+	GameParams game_params;
+#ifdef SERVER
+	game_params.is_dedicated_server = true;
+#else
+	game_params.is_dedicated_server = cmd_args.getFlag("server");
+#endif
 
-	bool leftclicked;
-	bool rightclicked;
-	bool leftreleased;
-	bool rightreleased;
+	if (!game_configure(&game_params, cmd_args))
+		return 1;
 
-	bool left_active;
-	bool middle_active;
-	bool right_active;
+	sanity_check(!game_params.world_path.empty());
 
-	s32 mouse_wheel;
+	infostream << "Using commanded world path ["
+	           << game_params.world_path << "]" << std::endl;
 
-private:
-	IrrlichtDevice *m_device;
-	
-	// The current state of keys
-	KeyList keyIsDown;
-	// Whether a key has been pressed or not
-	KeyList keyWasDown;
-};
+	//Run dedicated server if asked to or no other option
+	g_settings->set("server_dedicated",
+			game_params.is_dedicated_server ? "true" : "false");
 
-/*
-	Separated input handler
-*/
+	if (game_params.is_dedicated_server)
+		return run_dedicated_server(game_params, cmd_args) ? 0 : 1;
 
-class RealInputHandler : public InputHandler
-{
-public:
-	RealInputHandler(IrrlichtDevice *device, MyEventReceiver *receiver):
-		m_device(device),
-		m_receiver(receiver)
-	{
-	}
-	virtual bool isKeyDown(const KeyPress &keyCode)
-	{
-		return m_receiver->IsKeyDown(keyCode);
-	}
-	virtual bool wasKeyDown(const KeyPress &keyCode)
-	{
-		return m_receiver->WasKeyDown(keyCode);
-	}
-	virtual v2s32 getMousePos()
-	{
-		return m_device->getCursorControl()->getPosition();
-	}
-	virtual void setMousePos(s32 x, s32 y)
-	{
-		m_device->getCursorControl()->setPosition(x, y);
-	}
+#ifndef SERVER
+	ClientLauncher launcher;
+	retval = launcher.run(game_params, cmd_args) ? 0 : 1;
+#else
+	retval = 0;
+#endif
 
-	virtual bool getLeftState()
-	{
-		return m_receiver->left_active;
-	}
-	virtual bool getRightState()
-	{
-		return m_receiver->right_active;
-	}
-	
-	virtual bool getLeftClicked()
-	{
-		return m_receiver->leftclicked;
-	}
-	virtual bool getRightClicked()
-	{
-		return m_receiver->rightclicked;
-	}
-	virtual void resetLeftClicked()
-	{
-		m_receiver->leftclicked = false;
-	}
-	virtual void resetRightClicked()
-	{
-		m_receiver->rightclicked = false;
-	}
+	// Update configuration file
+	if (g_settings_path != "")
+		g_settings->updateConfigFile(g_settings_path.c_str());
 
-	virtual bool getLeftReleased()
-	{
-		return m_receiver->leftreleased;
-	}
-	virtual bool getRightReleased()
-	{
-		return m_receiver->rightreleased;
-	}
-	virtual void resetLeftReleased()
-	{
-		m_receiver->leftreleased = false;
-	}
-	virtual void resetRightReleased()
-	{
-		m_receiver->rightreleased = false;
-	}
+	print_modified_quicktune_values();
 
-	virtual s32 getMouseWheel()
-	{
-		return m_receiver->getMouseWheel();
-	}
+	// Stop httpfetch thread (if started)
+	httpfetch_cleanup();
 
-	void clear()
-	{
-		m_receiver->clearInput();
-	}
-private:
-	IrrlichtDevice *m_device;
-	MyEventReceiver *m_receiver;
-};
+	END_DEBUG_EXCEPTION_HANDLER
 
-class RandomInputHandler : public InputHandler
-{
-public:
-	RandomInputHandler()
-	{
-		leftdown = false;
-		rightdown = false;
-		leftclicked = false;
-		rightclicked = false;
-		leftreleased = false;
-		rightreleased = false;
-		keydown.clear();
-	}
-	virtual bool isKeyDown(const KeyPress &keyCode)
-	{
-		return keydown[keyCode];
-	}
-	virtual bool wasKeyDown(const KeyPress &keyCode)
-	{
-		return false;
-	}
-	virtual v2s32 getMousePos()
-	{
-		return mousepos;
-	}
-	virtual void setMousePos(s32 x, s32 y)
-	{
-		mousepos = v2s32(x,y);
-	}
-
-	virtual bool getLeftState()
-	{
-		return leftdown;
-	}
-	virtual bool getRightState()
-	{
-		return rightdown;
-	}
-
-	virtual bool getLeftClicked()
-	{
-		return leftclicked;
-	}
-	virtual bool getRightClicked()
-	{
-		return rightclicked;
-	}
-	virtual void resetLeftClicked()
-	{
-		leftclicked = false;
-	}
-	virtual void resetRightClicked()
-	{
-		rightclicked = false;
-	}
+	return retval;
+}
 
-	virtual bool getLeftReleased()
-	{
-		return leftreleased;
-	}
-	virtual bool getRightReleased()
-	{
-		return rightreleased;
-	}
-	virtual void resetLeftReleased()
-	{
-		leftreleased = false;
-	}
-	virtual void resetRightReleased()
-	{
-		rightreleased = false;
-	}
 
-	virtual s32 getMouseWheel()
-	{
-		return 0;
-	}
+/*****************************************************************************
+ * Startup / Init
+ *****************************************************************************/
 
-	virtual void step(float dtime)
-	{
-		{
-			static float counter1 = 0;
-			counter1 -= dtime;
-			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);
-				keydown.toggle(getKeySetting("keymap_special1"));
-			}
-		}
-		{
-			static float counter1 = 0;
-			counter1 -= dtime;
-			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);
-				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));
-			}
-		}
-		{
-			static float counter1 = 0;
-			counter1 -= dtime;
-			if(counter1 < 0.0)
-			{
-				counter1 = 0.1*Rand(1, 30);
-				leftdown = !leftdown;
-				if(leftdown)
-					leftclicked = true;
-				if(!leftdown)
-					leftreleased = true;
-			}
-		}
-		{
-			static float counter1 = 0;
-			counter1 -= dtime;
-			if(counter1 < 0.0)
-			{
-				counter1 = 0.1*Rand(1, 15);
-				rightdown = !rightdown;
-				if(rightdown)
-					rightclicked = true;
-				if(!rightdown)
-					rightreleased = true;
-			}
-		}
-		mousepos += mousespeed;
-	}
 
-	s32 Rand(s32 min, s32 max)
-	{
-		return (myrand()%(max-min+1))+min;
-	}
-private:
-	KeyList keydown;
-	v2s32 mousepos;
-	v2s32 mousespeed;
-	bool leftdown;
-	bool rightdown;
-	bool leftclicked;
-	bool rightclicked;
-	bool leftreleased;
-	bool rightreleased;
-};
-
-//Draw the tiled menu background
-void drawMenuBackground(video::IVideoDriver* driver) {
-	core::dimension2d<u32> screensize = driver->getScreenSize();
-
-	std::string path = getTexturePath("menubg.png");
-	if (path[0]) {
-		static const video::ITexture *bgtexture =
-			driver->getTexture(path.c_str());
-
-		if (bgtexture) {
-			s32 scaledsize = 128;
-		
-			// The important difference between destsize and screensize is
-			// that destsize is rounded to whole scaled pixels.
-			// These formulas use component-wise multiplication and division of v2u32.
-			v2u32 texturesize = bgtexture->getSize();
-			v2u32 sourcesize = texturesize * screensize / scaledsize + v2u32(1,1);
-			v2u32 destsize = scaledsize * sourcesize / texturesize;
-		
-			// Default texture wrapping mode in Irrlicht is ETC_REPEAT.
-			driver->draw2DImage(bgtexture,
-				core::rect<s32>(0, 0, destsize.X, destsize.Y),
-				core::rect<s32>(0, 0, sourcesize.X, sourcesize.Y),
-				NULL, NULL, true);
-		}
-	}
-}
+static bool get_cmdline_opts(int argc, char *argv[], Settings *cmd_args)
+{
+	set_allowed_options(&allowed_options);
 
-//Draw the footer at the bottom of the window
-void drawMenuFooter(video::IVideoDriver* driver, bool clouds) {
-	core::dimension2d<u32> screensize = driver->getScreenSize();
-	std::string path = getTexturePath(clouds ?
-						"menufooter_clouds.png" : "menufooter.png");
-	if (path[0]) {
-		static const video::ITexture *footertexture =
-			driver->getTexture(path.c_str());
-
-		if (footertexture) {
-			f32 mult = (((f32)screensize.Width)) /
-				((f32)footertexture->getOriginalSize().Width);
-
-			v2s32 footersize(((f32)footertexture->getOriginalSize().Width) * mult,
-					((f32)footertexture->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(footertexture, rect,
-					core::rect<s32>(core::position2d<s32>(0,0),
-					core::dimension2di(footertexture->getSize())),
-					NULL, NULL, true);
-			}
-		}
-	}
+	return cmd_args->parseCommandLine(argc, argv, allowed_options);
 }
 
-// Draw the Header over the main menu
-void drawMenuHeader(video::IVideoDriver* driver) {
-	core::dimension2d<u32> screensize = driver->getScreenSize();
-
-	std::string path = getTexturePath("menuheader.png");
-	if (path[0]) {
-		static const video::ITexture *splashtexture =
-		driver->getTexture(path.c_str());
-
-		if(splashtexture) {
-			f32 mult = (((f32)screensize.Width / 2)) /
-				((f32)splashtexture->getOriginalSize().Width);
-
-			v2s32 splashsize(((f32)splashtexture->getOriginalSize().Width) * mult,
-					((f32)splashtexture->getOriginalSize().Height) * mult);
+static void set_allowed_options(OptionList *allowed_options)
+{
+	allowed_options->clear();
 
-			// 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);
+	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,
+			_("Set network port (UDP)"))));
+	allowed_options->insert(std::make_pair("run-unittests", ValueSpec(VALUETYPE_FLAG,
+			_("Run the unit tests and exit"))));
+	allowed_options->insert(std::make_pair("map-dir", ValueSpec(VALUETYPE_STRING,
+			_("Same as --world (deprecated)"))));
+	allowed_options->insert(std::make_pair("world", ValueSpec(VALUETYPE_STRING,
+			_("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,
+			_("Print even more information to console"))));
+	allowed_options->insert(std::make_pair("trace", ValueSpec(VALUETYPE_FLAG,
+			_("Print enormous amounts of information to log and console"))));
+	allowed_options->insert(std::make_pair("logfile", ValueSpec(VALUETYPE_STRING,
+			_("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)"))));
+	allowed_options->insert(std::make_pair("terminal", ValueSpec(VALUETYPE_FLAG,
+			_("Feature an interactive terminal (Only works when using minetestserver or with --server)"))));
+#ifndef SERVER
+	allowed_options->insert(std::make_pair("videomodes", ValueSpec(VALUETYPE_FLAG,
+			_("Show available video modes"))));
+	allowed_options->insert(std::make_pair("speedtests", ValueSpec(VALUETYPE_FLAG,
+			_("Run speed tests"))));
+	allowed_options->insert(std::make_pair("address", ValueSpec(VALUETYPE_STRING,
+			_("Address to connect to. ('' = local game)"))));
+	allowed_options->insert(std::make_pair("random-input", ValueSpec(VALUETYPE_FLAG,
+			_("Enable random user input, for testing"))));
+	allowed_options->insert(std::make_pair("server", ValueSpec(VALUETYPE_FLAG,
+			_("Run dedicated server"))));
+	allowed_options->insert(std::make_pair("name", ValueSpec(VALUETYPE_STRING,
+			_("Set player name"))));
+	allowed_options->insert(std::make_pair("password", ValueSpec(VALUETYPE_STRING,
+			_("Set password"))));
+	allowed_options->insert(std::make_pair("go", ValueSpec(VALUETYPE_FLAG,
+			_("Disable main menu"))));
+#endif
 
-				video::SColor bgcolor(255,50,50,50);
+}
 
-				driver->draw2DImage(splashtexture, splashrect,
-					core::rect<s32>(core::position2d<s32>(0,0),
-					core::dimension2di(splashtexture->getSize())),
-					NULL, NULL, true);
-			}
-		}
-	}
+static void print_help(const OptionList &allowed_options)
+{
+	std::cout << _("Allowed options:") << std::endl;
+	print_allowed_options(allowed_options);
 }
 
-// Draw the Splash over the clouds and under the main menu
-void drawMenuSplash(video::IVideoDriver* driver) {
-	core::dimension2d<u32> screensize = driver->getScreenSize();
-	std::string path = getTexturePath("menusplash.png");
-	if (path[0]) {
-		static const video::ITexture *splashtexture =
-			driver->getTexture(path.c_str());
+static void print_allowed_options(const OptionList &allowed_options)
+{
+	for (OptionList::const_iterator i = allowed_options.begin();
+			i != allowed_options.end(); ++i) {
+		std::ostringstream os1(std::ios::binary);
+		os1 << "  --" << i->first;
+		if (i->second.type != VALUETYPE_FLAG)
+			os1 << _(" <value>");
 
-		if(splashtexture) {
-			core::rect<s32> splashrect(0, 0, screensize.Width, screensize.Height);
+		std::cout << padStringRight(os1.str(), 24);
 
-			video::SColor bgcolor(255,50,50,50);
+		if (i->second.help != NULL)
+			std::cout << i->second.help;
 
-			driver->draw2DImage(splashtexture, splashrect,
-				core::rect<s32>(core::position2d<s32>(0,0),
-				core::dimension2di(splashtexture->getSize())),
-				NULL, NULL, true);
-		}
+		std::cout << std::endl;
 	}
 }
 
+static void print_version()
+{
+	std::cout << PROJECT_NAME_C " " << g_version_hash << std::endl;
+#ifndef SERVER
+	std::cout << "Using Irrlicht " << IRRLICHT_SDK_VERSION << std::endl;
 #endif
+	std::cout << "Build info: " << g_build_info << std::endl;
+}
 
-// These are defined global so that they're not optimized too much.
-// Can't change them to volatile.
-s16 temp16;
-f32 tempf;
-v3f tempv3f1;
-v3f tempv3f2;
-std::string tempstring;
-std::string tempstring2;
-
-void SpeedTests()
+static void list_game_ids()
 {
-	{
-		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++)
-		{
-			tempstring = "";
-			tempstring2 = "";
-			const u32 ii = 10;
-			for(u32 i=0; i<ii; i++){
-				tempstring2 += "asd";
-			}
-			for(u32 i=0; i<ii+1; i++){
-				tempstring += "asd";
-				if(tempstring == tempstring2)
-					break;
-			}
-		}
-	}
-	
-	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++){
-			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++){
-			tempf += tempv3f1.dotProduct(tempv3f2);
-			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;
-				tempf += 1;
-			}
-		}
-		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;
-		TimeTaker timer("Testing mutex speed");
-		
-		JMutex m;
-		m.Init();
-		u32 n = 0;
-		u32 i = 0;
-		do{
-			n += 10000;
-			for(; i<n; i++){
-				m.Lock();
-				m.Unlock();
-			}
-		}
-		// Do at least 10ms
-		while(timer.getTimerTime() < 10);
+	std::set<std::string> gameids = getAvailableGameIds();
+	for (std::set<std::string>::const_iterator i = gameids.begin();
+			i != gameids.end(); ++i)
+		std::cout << (*i) <<std::endl;
+}
 
-		u32 dtime = timer.stop();
-		u32 per_ms = n / dtime;
-		infostream<<"Done. "<<dtime<<"ms, "
-				<<per_ms<<"/ms"<<std::endl;
-	}
+static void list_worlds()
+{
+	std::cout << _("Available worlds:") << std::endl;
+	std::vector<WorldSpec> worldspecs = getAvailableWorlds();
+	print_worldspecs(worldspecs, std::cout);
 }
 
 static void print_worldspecs(const std::vector<WorldSpec> &worldspecs,
-		std::ostream &os)
+							 std::ostream &os)
 {
-	for(u32 i=0; i<worldspecs.size(); i++){
+	for (size_t 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;
 	}
 }
 
-int main(int argc, char *argv[])
+static void print_modified_quicktune_values()
 {
-	int retval = 0;
-
-	/*
-		Initialization
-	*/
-
-	log_add_output_maxlev(&main_stderr_log_out, LMT_ACTION);
-	log_add_output_all_levs(&main_dstream_no_stderr_log_out);
+	bool header_printed = false;
+	std::vector<std::string> names = getQuicktuneNames();
 
-	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] );
+	for (u32 i = 0; i < names.size(); i++) {
+		QuicktuneValue val = getQuicktuneValue(names[i]);
+		if (!val.modified)
+			continue;
+		if (!header_printed) {
+			dstream << "Modified quicktune values:" << std::endl;
+			header_printed = true;
+		}
+		dstream << names[i] << " = " << val.getString() << std::endl;
 	}
+}
 
-	// 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;
+static void setup_log_params(const Settings &cmd_args)
+{
+	// Quiet mode, print errors only
+	if (cmd_args.getFlag("quiet")) {
+		g_logger.removeOutput(&stderr_output);
+		g_logger.addOutputMaxLevel(&stderr_output, LL_ERROR);
 	}
-	/*
-		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("config", ValueSpec(VALUETYPE_STRING,
-			_("Load configuration from specified file"))));
-	allowed_options.insert(std::make_pair("port", ValueSpec(VALUETYPE_STRING,
-			_("Set network port (UDP)"))));
-	allowed_options.insert(std::make_pair("disable-unittests", ValueSpec(VALUETYPE_FLAG,
-			_("Disable unit tests"))));
-	allowed_options.insert(std::make_pair("enable-unittests", ValueSpec(VALUETYPE_FLAG,
-			_("Enable unit tests"))));
-	allowed_options.insert(std::make_pair("map-dir", ValueSpec(VALUETYPE_STRING,
-			_("Same as --world (deprecated)"))));
-	allowed_options.insert(std::make_pair("world", ValueSpec(VALUETYPE_STRING,
-			_("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("info", ValueSpec(VALUETYPE_FLAG,
-			_("Print more information to console"))));
-	allowed_options.insert(std::make_pair("verbose",  ValueSpec(VALUETYPE_FLAG,
-			_("Print even more information to console"))));
-	allowed_options.insert(std::make_pair("trace", ValueSpec(VALUETYPE_FLAG,
-			_("Print enormous amounts of information to log and console"))));
-	allowed_options.insert(std::make_pair("logfile", ValueSpec(VALUETYPE_STRING,
-			_("Set logfile path ('' = no logging)"))));
-	allowed_options.insert(std::make_pair("gameid", ValueSpec(VALUETYPE_STRING,
-			_("Set gameid (\"--gameid list\" prints available ones)"))));
-#ifndef SERVER
-	allowed_options.insert(std::make_pair("speedtests", ValueSpec(VALUETYPE_FLAG,
-			_("Run speed tests"))));
-	allowed_options.insert(std::make_pair("address", ValueSpec(VALUETYPE_STRING,
-			_("Address to connect to. ('' = local game)"))));
-	allowed_options.insert(std::make_pair("random-input", ValueSpec(VALUETYPE_FLAG,
-			_("Enable random user input, for testing"))));
-	allowed_options.insert(std::make_pair("server", ValueSpec(VALUETYPE_FLAG,
-			_("Run dedicated server"))));
-	allowed_options.insert(std::make_pair("name", ValueSpec(VALUETYPE_STRING,
-			_("Set player name"))));
-	allowed_options.insert(std::make_pair("password", ValueSpec(VALUETYPE_STRING,
-			_("Set password"))));
-	allowed_options.insert(std::make_pair("go", ValueSpec(VALUETYPE_FLAG,
-			_("Disable main menu"))));
-#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;
-		for(std::map<std::string, ValueSpec>::iterator
-				i = allowed_options.begin();
-				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;
-		}
 
-		return cmd_args.getFlag("help") ? 0 : 1;
-	}
-	
-	/*
-		Low-level initialization
-	*/
-	
 	// If trace is enabled, enable logging of certain things
-	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
+	if (cmd_args.getFlag("trace")) {
+		dstream << _("Enabling trace level debug output") << std::endl;
+		g_logger.setTraceEnabled(true);
+		dout_con_ptr = &verbosestream; // This is somewhat old
+		socket_enable_debug_output = true; // Sockets 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);
+		g_logger.addOutput(&stderr_output, LL_INFO);
+
 	// In certain cases, output verbose level on stderr
-	if(cmd_args.getFlag("verbose") || cmd_args.getFlag("trace"))
-		log_add_output(&main_stderr_log_out, LMT_VERBOSE);
+	if (cmd_args.getFlag("verbose") || cmd_args.getFlag("trace"))
+		g_logger.addOutput(&stderr_output, LL_VERBOSE);
+}
 
-	porting::signal_handler_init();
-	bool &kill = *porting::signal_handler_killstatus();
-	
-	porting::initializePaths();
+static bool create_userdata_path()
+{
+	bool success;
 
+#ifdef __ANDROID__
+	if (!fs::PathExists(porting::path_user)) {
+		success = fs::CreateDir(porting::path_user);
+	} else {
+		success = true;
+	}
+	porting::copyAssets();
+#else
 	// Create user data directory
-	fs::CreateDir(porting::path_user);
-
-	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;
+	success = fs::CreateDir(porting::path_user);
+#endif
 
-	// Initialize debug stacks
-	debug_stacks_init();
-	DSTACK(__FUNCTION_NAME);
+	return success;
+}
 
-	// Debug handler
-	BEGIN_DEBUG_EXCEPTION_HANDLER
-	
-	// List gameids if requested
-	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;
-		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;
-	
-	/*
-		Basic initialization
-	*/
-
-	// Initialize default settings
+static bool init_common(const Settings &cmd_args, int argc, char *argv[])
+{
+	startup_message();
 	set_default_settings(g_settings);
-	
+
 	// Initialize sockets
 	sockets_init();
 	atexit(sockets_cleanup);
-	
-	/*
-		Read config file
-	*/
-	
+
+	if (!read_config_file(cmd_args))
+		return false;
+
+	init_log_streams(cmd_args);
+
+	// Initialize random seed
+	srand(time(0));
+	mysrand(time(0));
+
+	// Initialize HTTP fetcher
+	httpfetch_init(g_settings->getS32("curl_parallel_limit"));
+
+	init_gettext(porting::path_locale.c_str(),
+		g_settings->get("language"), argc, argv);
+
+	return true;
+}
+
+static void startup_message()
+{
+	infostream << PROJECT_NAME << " " << _("with")
+	           << " SER_FMT_VER_HIGHEST_READ="
+               << (int)SER_FMT_VER_HIGHEST_READ << ", "
+               << g_build_info << std::endl;
+}
+
+static bool read_config_file(const Settings &cmd_args)
+{
 	// Path of configuration file in use
-	std::string configpath = "";
-	
-	if(cmd_args.exists("config"))
-	{
+	sanity_check(g_settings_path == "");	// Sanity check
+
+	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;
-			return 1;
+		if (!r) {
+			errorstream << "Could not read configuration from \""
+			            << cmd_args.get("config") << "\"" << std::endl;
+			return false;
 		}
-		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");
+		filenames.push_back(porting::path_user + DIR_DELIM + "minetest.conf");
 		// Legacy configuration file location
 		filenames.push_back(porting::path_user +
 				DIR_DELIM + ".." + DIR_DELIM + "minetest.conf");
+
 #if RUN_IN_PLACE
 		// Try also from a lower level (to aid having the same configuration
 		// for many RUN_IN_PLACE installs)
@@ -1050,926 +504,475 @@ int main(int argc, char *argv[])
 				DIR_DELIM + ".." + DIR_DELIM + ".." + DIR_DELIM + "minetest.conf");
 #endif
 
-		for(u32 i=0; i<filenames.size(); i++)
-		{
+		for (size_t 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"
+
+	return true;
+}
+
+static void init_log_streams(const Settings &cmd_args)
+{
 #if RUN_IN_PLACE
-	std::string logfile = DEBUGFILE;
+	std::string log_filename = DEBUGFILE;
 #else
-	std::string logfile = porting::path_user+DIR_DELIM+DEBUGFILE;
+	std::string log_filename = porting::path_user + DIR_DELIM + DEBUGFILE;
 #endif
-	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));
-
-	if(logfile != "")
-		debugstreams_init(false, logfile.c_str());
-	else
-		debugstreams_init(false, NULL);
-		
-	infostream<<"logfile    = "<<logfile<<std::endl;
+	if (cmd_args.exists("logfile"))
+		log_filename = cmd_args.get("logfile");
 
-	// Initialize random seed
-	srand(time(0));
-	mysrand(time(0));
+	g_logger.removeOutput(&file_log_output);
+	std::string conf_loglev = g_settings->get("debug_log_level");
 
-	/*
-		Run unit tests
-	*/
+	// Old integer format
+	if (std::isdigit(conf_loglev[0])) {
+		warningstream << "Deprecated use of debug_log_level with an "
+			"integer value; please update your configuration." << std::endl;
+		static const char *lev_name[] =
+			{"", "error", "action", "info", "verbose"};
+		int lev_i = atoi(conf_loglev.c_str());
+		if (lev_i < 0 || lev_i >= (int)ARRLEN(lev_name)) {
+			warningstream << "Supplied invalid debug_log_level!"
+				"  Assuming action level." << std::endl;
+			lev_i = 2;
+		}
+		conf_loglev = lev_name[lev_i];
+	}
 
-	if((ENABLE_TESTS && cmd_args.getFlag("disable-unittests") == false)
-			|| cmd_args.getFlag("enable-unittests") == true)
-	{
-		run_tests();
+	if (log_filename.empty() || conf_loglev.empty())  // No logging
+		return;
+
+	LogLevel log_level = Logger::stringToLevel(conf_loglev);
+	if (log_level == LL_MAX) {
+		warningstream << "Supplied unrecognized debug_log_level; "
+			"using maximum." << std::endl;
 	}
-	
-	/*
-		Game parameters
-	*/
-
-	// Port
-	u16 port = 30000;
-	if(cmd_args.exists("port"))
-		port = cmd_args.getU16("port");
-	else if(g_settings->exists("port"))
-		port = g_settings->getU16("port");
-	if(port == 0)
-		port = 30000;
-	
-	// World directory
+
+	verbosestream << "log_filename = " << log_filename << std::endl;
+
+	file_log_output.open(log_filename.c_str());
+	g_logger.addOutputMaxLevel(&file_log_output, log_level);
+}
+
+static bool game_configure(GameParams *game_params, const Settings &cmd_args)
+{
+	game_configure_port(game_params, cmd_args);
+
+	if (!game_configure_world(game_params, cmd_args)) {
+		errorstream << "No world path specified or found." << std::endl;
+		return false;
+	}
+
+	game_configure_subgame(game_params, cmd_args);
+
+	return true;
+}
+
+static void game_configure_port(GameParams *game_params, const Settings &cmd_args)
+{
+	if (cmd_args.exists("port"))
+		game_params->socket_port = cmd_args.getU16("port");
+	else
+		game_params->socket_port = g_settings->getU16("port");
+
+	if (game_params->socket_port == 0)
+		game_params->socket_port = DEFAULT_SERVER_PORT;
+}
+
+static bool game_configure_world(GameParams *game_params, const Settings &cmd_args)
+{
+	if (get_world_from_cmdline(game_params, cmd_args))
+		return true;
+	if (get_world_from_config(game_params, cmd_args))
+		return true;
+
+	return auto_select_world(game_params);
+}
+
+static bool get_world_from_cmdline(GameParams *game_params, const Settings &cmd_args)
+{
 	std::string commanded_world = "";
-	if(cmd_args.exists("world"))
-		commanded_world = cmd_args.get("world");
-	else if(cmd_args.exists("map-dir"))
-		commanded_world = cmd_args.get("map-dir");
-	else if(cmd_args.exists("nonopt0")) // First nameless argument
-		commanded_world = cmd_args.get("nonopt0");
-	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 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) {
+				dstream << _("Using world specified by --worldname on the "
+					"command line") << 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;
+			return false;
 		}
+
+		game_params->world_path = get_clean_world_path(commanded_world);
+		return commanded_world != "";
+	}
+
+	if (cmd_args.exists("world"))
+		commanded_world = cmd_args.get("world");
+	else if (cmd_args.exists("map-dir"))
+		commanded_world = cmd_args.get("map-dir");
+	else if (cmd_args.exists("nonopt0")) // First nameless argument
+		commanded_world = cmd_args.get("nonopt0");
+
+	game_params->world_path = get_clean_world_path(commanded_world);
+	return commanded_world != "";
+}
+
+static bool get_world_from_config(GameParams *game_params, const Settings &cmd_args)
+{
+	// World directory
+	std::string commanded_world = "";
+
+	if (g_settings->exists("map-dir"))
+		commanded_world = g_settings->get("map-dir");
+
+	game_params->world_path = get_clean_world_path(commanded_world);
+
+	return commanded_world != "";
+}
+
+static bool auto_select_world(GameParams *game_params)
+{
+	// No world was specified; try to select it automatically
+	// Get information about available worlds
+
+	verbosestream << _("Determining world path") << std::endl;
+
+	std::vector<WorldSpec> worldspecs = getAvailableWorlds();
+	std::string world_path;
+
+	// If there is only a single world, use it
+	if (worldspecs.size() == 1) {
+		world_path = worldspecs[0].path;
+		dstream <<_("Automatically selecting world at") << " ["
+		        << world_path << "]" << std::endl;
+	// If there are multiple worlds, list them
+	} else if (worldspecs.size() > 1 && game_params->is_dedicated_server) {
+		std::cerr << _("Multiple worlds are available.") << std::endl;
+		std::cerr << _("Please select one using --worldname <name>"
+				" or --world <path>") << std::endl;
+		print_worldspecs(worldspecs, std::cerr);
+		return false;
+	// If there are no worlds, automatically create a new one
+	} else {
+		// 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;
+	}
+
+	assert(world_path != "");	// Post-condition
+	game_params->world_path = world_path;
+	return true;
+}
+
+static std::string get_clean_world_path(const std::string &path)
+{
+	const std::string worldmt = "world.mt";
+	std::string clean_path;
+
+	if (path.size() > worldmt.size()
+			&& path.substr(path.size() - worldmt.size()) == worldmt) {
+		dstream << _("Supplied world.mt file - stripping it off.") << std::endl;
+		clean_path = path.substr(0, path.size() - worldmt.size());
+	} else {
+		clean_path = path;
 	}
+	return path;
+}
+
 
-	// Gamespec
+static bool game_configure_subgame(GameParams *game_params, const Settings &cmd_args)
+{
+	bool success;
+
+	success = get_game_from_cmdline(game_params, cmd_args);
+	if (!success)
+		success = determine_subgame(game_params);
+
+	return success;
+}
+
+static bool get_game_from_cmdline(GameParams *game_params, const Settings &cmd_args)
+{
 	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;
-			return 1;
+		if (!commanded_gamespec.isValid()) {
+			errorstream << "Game \"" << gameid << "\" not found" << std::endl;
+			return false;
 		}
+		dstream << _("Using game specified by --gameid on the command line")
+		        << std::endl;
+		game_params->game_spec = commanded_gamespec;
+		return true;
 	}
 
-	/*
-		Run dedicated server if asked to or no other option
-	*/
-#ifdef SERVER
-	bool run_dedicated_server = true;
-#else
-	bool run_dedicated_server = cmd_args.getFlag("server");
-#endif
-	g_settings->set("server_dedicated", run_dedicated_server ? "true" : "false");
-	if(run_dedicated_server)
-	{
-		DSTACK("Dedicated server branch");
-		// Create time getter if built with Irrlicht
-#ifndef SERVER
-		g_timegetter = new SimpleTimeGetter();
-#endif
-
-		// World directory
-		std::string world_path;
-		verbosestream<<_("Determining world path")<<std::endl;
-		bool is_legacy_world = false;
-		// If a world was commanded, use it
-		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
-		{
-			// Get information about available worlds
-			std::vector<WorldSpec> worldspecs = getAvailableWorlds();
-			// If a world name was specified, select it
-			if(commanded_worldname != ""){
-				world_path = "";
-				for(u32 i=0; i<worldspecs.size(); i++){
-					std::string name = worldspecs[i].name;
-					if(name == commanded_worldname){
-						world_path = worldspecs[i].path;
-						break;
-					}
-				}
-				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){
-				world_path = worldspecs[0].path;
-				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;
-				print_worldspecs(worldspecs, dstream);
-				return 1;
-			// If there are no worlds, automatically create a new one
-			} else {
-				// 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;
-			}
-		}
+	return false;
+}
 
-		if(world_path == ""){
-			errorstream<<"No world path specified or found."<<std::endl;
-			return 1;
-		}
-		verbosestream<<_("Using world path")<<" ["<<world_path<<"]"<<std::endl;
-
-		// We need a gamespec.
-		SubgameSpec gamespec;
-		verbosestream<<_("Determining gameid/gamespec")<<std::endl;
-		// If world doesn't exist
-		if(!getWorldExists(world_path))
-		{
-			// Try to take gamespec from command line
-			if(commanded_gamespec.isValid()){
-				gamespec = commanded_gamespec;
-				infostream<<"Using commanded gameid ["<<gamespec.id<<"]"<<std::endl;
-			}
-			// Otherwise we will be using "minetest"
-			else{
-				gamespec = findSubgame(g_settings->get("default_game"));
-				infostream<<"Using default gameid ["<<gamespec.id<<"]"<<std::endl;
+static bool determine_subgame(GameParams *game_params)
+{
+	SubgameSpec gamespec;
+
+	assert(game_params->world_path != "");	// Pre-condition
+
+	verbosestream << _("Determining gameid/gamespec") << std::endl;
+	// If world doesn't exist
+	if (game_params->world_path != ""
+			&& !getWorldExists(game_params->world_path)) {
+		// Try to take gamespec from command line
+		if (game_params->game_spec.isValid()) {
+			gamespec = game_params->game_spec;
+			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;
+			if (!gamespec.isValid()) {
+				errorstream << "Subgame specified in default_game ["
+				            << g_settings->get("default_game")
+				            << "] is invalid." << std::endl;
+				return false;
 			}
 		}
-		// World exists
-		else
-		{
-			std::string world_gameid = getWorldGameId(world_path, is_legacy_world);
-			// If commanded to use a gameid, do so
-			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;
-				}
-			} 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;
+	} else { // World exists
+		std::string world_gameid = getWorldGameId(game_params->world_path, false);
+		// If commanded to use a gameid, do so
+		if (game_params->game_spec.isValid()) {
+			gamespec = game_params->game_spec;
+			if (game_params->game_spec.id != world_gameid) {
+				warningstream << "Using commanded gameid ["
+				            << gamespec.id << "]" << " instead of world gameid ["
+				            << world_gameid << "]" << std::endl;
 			}
+		} else {
+			// If world contains an embedded game, use it;
+			// Otherwise find world from local system.
+			gamespec = findWorldSubgame(game_params->world_path);
+			infostream << "Using world gameid [" << gamespec.id << "]" << std::endl;
 		}
-		if(!gamespec.isValid()){
-			errorstream<<"Subgame ["<<gamespec.id<<"] could not be found."
-					<<std::endl;
-			return 1;
-		}
-		verbosestream<<_("Using gameid")<<" ["<<gamespec.id<<"]"<<std::endl;
-
-		// Create server
-		Server server(world_path, configpath, gamespec, false);
-		server.start(port);
-		
-		// Run server
-		dedicated_server_loop(server, kill);
-
-		return 0;
 	}
 
-#ifndef SERVER // Exclude from dedicated server build
-
-	/*
-		More parameters
-	*/
-	
-	std::string address = g_settings->get("address");
-	if(commanded_world != "")
-		address = "";
-	else if(cmd_args.exists("address"))
-		address = cmd_args.get("address");
-	
-	std::string playername = g_settings->get("name");
-	if(cmd_args.exists("name"))
-		playername = cmd_args.get("name");
-	
-	bool skip_main_menu = cmd_args.getFlag("go");
-
-	/*
-		Device initialization
-	*/
-
-	// Resolution selection
-	
-	bool fullscreen = g_settings->getBool("fullscreen");
-	u16 screenW = g_settings->getU16("screenW");
-	u16 screenH = g_settings->getU16("screenH");
-
-	// bpp, fsaa, vsync
-
-	bool vsync = g_settings->getBool("vsync");
-	u16 bits = g_settings->getU16("fullscreen_bpp");
-	u16 fsaa = g_settings->getU16("fsaa");
-
-	// Determine driver
-
-	video::E_DRIVER_TYPE driverType;
-	
-	std::string driverstring = g_settings->get("video_driver");
-
-	if(driverstring == "null")
-		driverType = video::EDT_NULL;
-	else if(driverstring == "software")
-		driverType = video::EDT_SOFTWARE;
-	else if(driverstring == "burningsvideo")
-		driverType = video::EDT_BURNINGSVIDEO;
-	else if(driverstring == "direct3d8")
-		driverType = video::EDT_DIRECT3D8;
-	else if(driverstring == "direct3d9")
-		driverType = video::EDT_DIRECT3D9;
-	else if(driverstring == "opengl")
-		driverType = video::EDT_OPENGL;
-#ifdef _IRR_COMPILE_WITH_OGLES1_
-	else if(driverstring == "ogles1")
-		driverType = video::EDT_OGLES1;
-#endif
-#ifdef _IRR_COMPILE_WITH_OGLES2_
-	else if(driverstring == "ogles2")
-		driverType = video::EDT_OGLES2;
-#endif
-	else
-	{
-		errorstream<<"WARNING: Invalid video_driver specified; defaulting "
-				"to opengl"<<std::endl;
-		driverType = video::EDT_OPENGL;
+	if (!gamespec.isValid()) {
+		errorstream << "Subgame [" << gamespec.id << "] could not be found."
+		            << std::endl;
+		return false;
 	}
 
-	/*
-		Create device and exit if creation failed
-	*/
-
-	MyEventReceiver receiver;
-
-	IrrlichtDevice *device;
-
-	SIrrlichtCreationParameters params = SIrrlichtCreationParameters();
-	params.DriverType    = driverType;
-	params.WindowSize    = core::dimension2d<u32>(screenW, screenH);
-	params.Bits          = bits;
-	params.AntiAlias     = fsaa;
-	params.Fullscreen    = fullscreen;
-	params.Stencilbuffer = false;
-	params.Vsync         = vsync;
-	params.EventReceiver = &receiver;
-
-	device = createDeviceEx(params);
-
-	if (device == 0)
-		return 1; // could not create selected driver.
-	
-	/*
-		Continue initialization
-	*/
-
-	video::IVideoDriver* driver = device->getVideoDriver();
-
-	/*
-		This changes the minimum allowed number of vertices in a VBO.
-		Default is 500.
-	*/
-	//driver->setMinHardwareBufferVertexCount(50);
-
-	// 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"))
-	{
-		dstream<<"Running speed tests"<<std::endl;
-		SpeedTests();
-		return 0;
+	game_params->game_spec = gamespec;
+	return true;
+}
+
+
+/*****************************************************************************
+ * Dedicated server
+ *****************************************************************************/
+static bool run_dedicated_server(const GameParams &game_params, const Settings &cmd_args)
+{
+	DSTACK("Dedicated server branch");
+
+	verbosestream << _("Using world path") << " ["
+	              << game_params.world_path << "]" << std::endl;
+	verbosestream << _("Using gameid") << " ["
+	              << game_params.game_spec.id << "]" << std::endl;
+
+	// Bind address
+	std::string bind_str = g_settings->get("bind_address");
+	Address bind_addr(0, 0, 0, 0, game_params.socket_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 false;
 	}
-	
-	device->setResizable(true);
-
-	bool random_input = g_settings->getBool("random_input")
-			|| cmd_args.getFlag("random-input");
-	InputHandler *input = NULL;
-	if(random_input)
-		input = new RandomInputHandler();
-	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);
-	#else
-	gui::IGUIFont* font = guienv->getFont(getTexturePath("fontlucida.png").c_str());
-	#endif
-	if(font)
-		skin->setFont(font);
-	else
-		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;
-
-	//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));
-
-#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));
-#endif
 
-	/*
-		GUI stuff
-	*/
-
-	ChatBackend chat_backend;
-
-	/*
-		If an error occurs, this is set to something and the
-		menu-game loop is restarted. It is then displayed before
-		the menu.
-	*/
-	std::wstring error_message = L"";
-
-	// The password entered during the menu screen,
-	std::string password;
-
-	bool first_loop = true;
-
-	/*
-		Menu-game loop
-	*/
-	while(device->run() && kill == false)
-	{
-		// Set the window caption
-		device->setWindowCaption((std::wstring(L"Minetest [")+wgettext("Main Menu")+L"]").c_str());
-
-		// This is used for catching disconnects
-		try
-		{
-
-			/*
-				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));
-			
-			SubgameSpec gamespec;
-			WorldSpec worldspec;
-			bool simple_singleplayer_mode = false;
-
-			// These are set up based on the menu and other things
-			std::string current_playername = "inv£lid";
-			std::string current_password = "";
-			std::string current_address = "does-not-exist";
-			int current_port = 0;
-
-			/*
-				Out-of-game menu loop.
-
-				Loop quits when menu returns proper parameters.
-			*/
-			while(kill == false)
-			{
-				// If skip_main_menu, only go through here once
-				if(skip_main_menu && !first_loop){
-					kill = true;
-					break;
-				}
-				first_loop = false;
-				
-				// Cursor can be non-visible when coming from the game
-				device->getCursorControl()->setVisible(true);
-				// 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");
-				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.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]";
-					}
-					WorldSpec spec(commanded_world, name, gameid);
-					worldspecs.push_back(spec);
-					menudata.selected_world = worldspecs.size()-1;
-				}
-				// Copy worldspecs to menu
-				menudata.worlds = worldspecs;
-
-				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())
-							break;
-						driver->beginScene(true, true,
-								video::SColor(255,128,128,128));
-						drawMenuBackground(driver);
-						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);
-
-					// Clouds for the main menu
-					bool cloud_menu_background = false;
-					Clouds *clouds = NULL;
-					if (g_settings->getBool("menu_clouds")) {
-						cloud_menu_background = true;
-						clouds = new Clouds(smgr->getRootSceneNode(),
-											smgr, -1, rand(), 100);
-						clouds->update(v2f(0, 0), video::SColor(255,200,200,255));
-
-						// A camera to see the clouds
-						scene::ICameraSceneNode* camera;
-						camera = smgr->addCameraSceneNode(0,
-									v3f(0,0,0), v3f(0, 60, 100));
-						camera->setFarValue(10000);
-					}
-
-					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();
-
-					infostream<<"Created main menu"<<std::endl;
-
-					while(device->run() && kill == false)
-					{
-						if(menu->getStatus() == true)
-							break;
-
-						// Time calc for the clouds
-						f32 dtime; // 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
-							clouds->step(dtime*3); 
-							clouds->render();
-							smgr->drawAll();
-							drawMenuSplash(driver);
-							drawMenuFooter(driver, true);
-							drawMenuHeader(driver);
-						} else {
-							drawMenuBackground(driver);
-							drawMenuFooter(driver, false);
-						}
-
-						guienv->drawAll();
-
-						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);
-						}
-					}
-					
-					infostream<<"Dropping main menu"<<std::endl;
-
-					menu->drop();
-					if (cloud_menu_background) {
-						clouds->drop();
-						smgr->clear();
-					}
-				}
-
-				playername = wide_to_narrow(menudata.name);
-				if (playername == "")
-					playername = std::string("Guest") + itos(myrand_range(1000,9999));
-				password = translatePassword(playername, 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)
-					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("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)
-					break;
-				
-				current_playername = playername;
-				current_password = password;
-				current_address = address;
-				current_port = port;
-
-				// If using simple singleplayer mode, override
-				if(simple_singleplayer_mode){
-					current_playername = "singleplayer";
-					current_password = "";
-					current_address = "";
-					current_port = 30011;
-				}
-				else if (address != "")
-				{
-					ServerListSpec server;
-					server["name"] = menudata.servername;
-					server["address"] = wide_to_narrow(menudata.address);
-					server["port"] = wide_to_narrow(menudata.port);
-					server["description"] = menudata.serverdescription;
-					ServerList::insert(server);
-				}
-				
-				// Set world path to selected one
-				if(menudata.selected_world != -1){
-					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);
-					continue;
-				}
-
-				// If local game
-				if(current_address == "")
-				{
-					if(menudata.selected_world == -1){
-						error_message = wgettext("No world selected and no address "
-								"provided. Nothing to do.");
-						errorstream<<wide_to_narrow(error_message)<<std::endl;
-						continue;
-					}
-					// Load gamespec for required game
-					gamespec = findWorldSubgame(worldspec.path);
-					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;
-						continue;
-					}
-					if(commanded_gamespec.isValid() &&
-							commanded_gamespec.id != worldspec.gameid){
-						errorstream<<"WARNING: Overriding gamespec from \""
-								<<worldspec.gameid<<"\" to \""
-								<<commanded_gamespec.id<<"\""<<std::endl;
-						gamespec = commanded_gamespec;
-					}
-
-					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;
-						continue;
-					}
-				}
-
-				// Continue to game
-				break;
-			}
-			
-			// Break out of menu-game loop to shut down cleanly
-			if(device->run() == false || kill == true)
-				break;
+	// Database migration
+	if (cmd_args.exists("migrate"))
+		return migrate_database(game_params, cmd_args);
 
-			/*
-				Run game
-			*/
-			the_game(
-				kill,
-				random_input,
-				input,
-				device,
-				font,
-				worldspec.path,
-				current_playername,
-				current_password,
-				current_address,
-				current_port,
-				error_message,
-				configpath,
-				chat_backend,
-				gamespec,
-				simple_singleplayer_mode
-			);
-
-		} //try
-		catch(con::PeerNotFoundException &e)
-		{
-			error_message = wgettext("Connection error (timed out?)");
-			errorstream<<wide_to_narrow(error_message)<<std::endl;
-		}
-		catch(ServerError &e)
-		{
-			error_message = narrow_to_wide(e.what());
-			errorstream<<wide_to_narrow(error_message)<<std::endl;
-		}
-		catch(ModError &e)
-		{
-			errorstream<<e.what()<<std::endl;
-			error_message = narrow_to_wide(e.what()) + wgettext("\nCheck debug.txt for details.");
-		}
-#ifdef NDEBUG
-		catch(std::exception &e)
-		{
-			std::string narrow_message = "Some exception: \"";
-			narrow_message += e.what();
-			narrow_message += "\"";
-			errorstream<<narrow_message<<std::endl;
-			error_message = narrow_to_wide(narrow_message);
-		}
-#endif
+	if (cmd_args.exists("terminal")) {
+#if USE_CURSES
+		bool name_ok = true;
+		std::string admin_nick = g_settings->get("name");
+
+		name_ok = name_ok && !admin_nick.empty();
+		name_ok = name_ok && string_allowed(admin_nick, PLAYERNAME_ALLOWED_CHARS);
 
-		// 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;
-				retval = 1;
+		if (!name_ok) {
+			if (admin_nick.empty()) {
+				errorstream << "No name given for admin. "
+					<< "Please check your minetest.conf that it "
+					<< "contains a 'name = ' to your main admin account."
+					<< std::endl;
+			} else {
+				errorstream << "Name for admin '"
+					<< admin_nick << "' is not valid. "
+					<< "Please check that it only contains allowed characters. "
+					<< "Valid characters are: " << PLAYERNAME_ALLOWED_CHARS_USER_EXPL
+					<< std::endl;
 			}
-			break;
+			return false;
 		}
-	} // Menu-game loop
-	
-	delete input;
+		ChatInterface iface;
+		bool &kill = *porting::signal_handler_killstatus();
 
-	/*
-		In the end, delete the Irrlicht device.
-	*/
-	device->drop();
+		try {
+			// Create server
+			Server server(game_params.world_path,
+				game_params.game_spec, false, bind_addr.isIPv6(), &iface);
 
-#endif // !SERVER
-	
-	// Update configuration file
-	if(configpath != "")
-		g_settings->updateConfigFile(configpath.c_str());
-	
-	// Print modified quicktune values
-	{
-		bool header_printed = false;
-		std::vector<std::string> names = getQuicktuneNames();
-		for(u32 i=0; i<names.size(); i++){
-			QuicktuneValue val = getQuicktuneValue(names[i]);
-			if(!val.modified)
-				continue;
-			if(!header_printed){
-				dstream<<"Modified quicktune values:"<<std::endl;
-				header_printed = true;
-			}
-			dstream<<names[i]<<" = "<<val.getString()<<std::endl;
+			g_term_console.setup(&iface, &kill, admin_nick);
+
+			g_term_console.start();
+
+			server.start(bind_addr);
+			// Run server
+			dedicated_server_loop(server, kill);
+		} catch (const ModError &e) {
+			g_term_console.stopAndWaitforThread();
+			errorstream << "ModError: " << e.what() << std::endl;
+			return false;
+		} catch (const ServerError &e) {
+			g_term_console.stopAndWaitforThread();
+			errorstream << "ServerError: " << e.what() << std::endl;
+			return false;
+		}
+
+		// Tell the console to stop, and wait for it to finish,
+		// only then leave context and free iface
+		g_term_console.stop();
+		g_term_console.wait();
+
+		g_term_console.clearKillStatus();
+	} else {
+#else
+		errorstream << "Cmd arg --terminal passed, but "
+			<< "compiled without ncurses. Ignoring." << std::endl;
+	} {
+#endif
+		try {
+			// Create server
+			Server server(game_params.world_path, game_params.game_spec, false,
+				bind_addr.isIPv6());
+			server.start(bind_addr);
+
+			// Run server
+			bool &kill = *porting::signal_handler_killstatus();
+			dedicated_server_loop(server, kill);
+
+		} catch (const ModError &e) {
+			errorstream << "ModError: " << e.what() << std::endl;
+			return false;
+		} catch (const ServerError &e) {
+			errorstream << "ServerError: " << e.what() << std::endl;
+			return false;
 		}
 	}
 
-	END_DEBUG_EXCEPTION_HANDLER(errorstream)
-	
-	debugstreams_deinit();
-	
-	return retval;
+	return true;
 }
 
-//END
+static bool migrate_database(const GameParams &game_params, const Settings &cmd_args)
+{
+	std::string migrate_to = cmd_args.get("migrate");
+	Settings world_mt;
+	std::string world_mt_path = game_params.world_path + DIR_DELIM + "world.mt";
+	if (!world_mt.readConfigFile(world_mt_path.c_str())) {
+		errorstream << "Cannot read world.mt!" << std::endl;
+		return false;
+	}
+	if (!world_mt.exists("backend")) {
+		errorstream << "Please specify your current backend in world.mt:"
+			<< std::endl
+			<< "	backend = {sqlite3|leveldb|redis|dummy}"
+			<< std::endl;
+		return false;
+	}
+	std::string backend = world_mt.get("backend");
+	if (backend == migrate_to) {
+		errorstream << "Cannot migrate: new backend is same"
+			<< " as the old one" << std::endl;
+		return false;
+	}
+	Database *old_db = ServerMap::createDatabase(backend, game_params.world_path, world_mt),
+		*new_db = ServerMap::createDatabase(migrate_to, game_params.world_path, world_mt);
+
+	u32 count = 0;
+	time_t last_update_time = 0;
+	bool &kill = *porting::signal_handler_killstatus();
+
+	std::vector<v3s16> blocks;
+	old_db->listAllLoadableBlocks(blocks);
+	new_db->beginSave();
+	for (std::vector<v3s16>::const_iterator it = blocks.begin(); it != blocks.end(); ++it) {
+		if (kill) return false;
+
+		const std::string &data = old_db->loadBlock(*it);
+		if (!data.empty()) {
+			new_db->saveBlock(*it, data);
+		} else {
+			errorstream << "Failed to load block " << PP(*it) << ", skipping it." << std::endl;
+		}
+		if (++count % 0xFF == 0 && time(NULL) - last_update_time >= 1) {
+			std::cerr << " Migrated " << count << " blocks, "
+				<< (100.0 * count / blocks.size()) << "% completed.\r";
+			new_db->endSave();
+			new_db->beginSave();
+			last_update_time = time(NULL);
+		}
+	}
+	std::cerr << std::endl;
+	new_db->endSave();
+	delete old_db;
+	delete new_db;
+
+	actionstream << "Successfully migrated " << count << " blocks" << std::endl;
+	world_mt.set("backend", migrate_to);
+	if (!world_mt.updateConfigFile(world_mt_path.c_str()))
+		errorstream << "Failed to update world.mt!" << std::endl;
+	else
+		actionstream << "world.mt updated" << std::endl;
+
+	return true;
+}