"  -e                  = Start Editor\n"

		"  -g [savegame]       = Start new/save game immediately\n"

		"  -G seed             = Set random seed\n"

		"  -n [ip:port#company]= Join network game\n"

		"  -p password         = Password to join server\n"

		"  -P password         = Password to join company\n"

#if !defined(_WIN32)

		"  -f                  = Fork into the background (dedicated only)\n"

#endif

		"  -I graphics_set     = Force the graphics set (see below)\n"

		"  -S sounds_set       = Force the sounds set (see below)\n"

		"  -M music_set        = Force the music set (see below)\n"

	/* Uninitialize variables that are allocated dynamically */

	GamelogReset();

	free(_config_file);

	LinkGraphSchedule::Clear();

	PoolBase::Clean(PT_ALL);

		if (startyear != INVALID_YEAR) _settings_newgame.game_creation.starting_year = startyear;

		if (generation_seed != GENERATE_NEW_SEED) _settings_newgame.game_creation.generation_seed = generation_seed;

		if (dedicated_host != NULL) {

			_network_bind_list.Clear();

			*_network_bind_list.Append() = stredup(dedicated_host);

		}

		if (dedicated_port != 0) _settings_client.network.server_port = dedicated_port;

		/* initialize the ingame console */

		IConsoleInit();

		/* Make sure _settings is filled with _settings_newgame if we switch to a game directly */

		if (_switch_mode != SM_NONE) MakeNewgameSettingsLive();

		if (_network_available && network_conn != NULL) {

			const char *port = NULL;

			const char *company = NULL;

			_switch_mode = SM_NONE;

			NetworkClientConnectGame(NetworkAddress(network_conn, rport), join_as, join_server_password, join_company_password);

		}

		/* After the scan we're not used anymore. */

		delete this;

	 GETOPT_SHORT_VALUE('s'),

	 GETOPT_SHORT_VALUE('v'),

	 GETOPT_SHORT_VALUE('b'),

	GETOPT_SHORT_OPTVAL('D'),

	GETOPT_SHORT_OPTVAL('n'),

	 GETOPT_SHORT_VALUE('l'),

#if !defined(_WIN32)

	 GETOPT_SHORT_NOVAL('f'),

#endif

	 GETOPT_SHORT_VALUE('r'),

	 GETOPT_SHORT_VALUE('t'),

	GETOPT_SHORT_OPTVAL('d'),

	/* AfterNewGRFScan sets save_config to true after scanning completed. */

	bool save_config = false;

	AfterNewGRFScan *scanner = new AfterNewGRFScan(&save_config);

	bool dedicated = false;

	char *debuglog_conn = NULL;

	extern bool _dedicated_forks;

	_dedicated_forks = false;

	_game_mode = GM_MENU;

	_switch_mode = SM_MENU;

		case 's': free(sounddriver); sounddriver = stredup(mgo.opt); break;

		case 'v': free(videodriver); videodriver = stredup(mgo.opt); break;

		case 'b': free(blitter); blitter = stredup(mgo.opt); break;

		case 'D':

			free(musicdriver);

			free(sounddriver);

		case 'P':

			scanner->join_company_password = mgo.opt;

			break;

		case 'r': ParseResolution(&resolution, mgo.opt); break;

		case 't': scanner->startyear = atoi(mgo.opt); break;

		case 'd': {

	DeterminePaths(argv[0]);

	TarScanner::DoScan(TarScanner::BASESET);

	if (dedicated) DEBUG(net, 0, "Starting dedicated version %s", _openttd_revision);

	if (_dedicated_forks && !dedicated) _dedicated_forks = false;

	/* We must fork here, or we'll end up without some resources we need (like sockets) */

	if (_dedicated_forks) DedicatedFork();

#endif

	LoadFromConfig(true);

	NetworkStartUp(); // initialize network-core

	if (debuglog_conn != NULL && _network_available) {

		const char *not_used = NULL;

		const char *port = NULL;

		NetworkStartDebugLog(NetworkAddress(debuglog_conn, rport));

	}

	if (!HandleBootstrap()) {

		ShutdownGame();

	delete scanner;

	extern FILE *_log_fd;

	if (_log_fd != NULL) {

		fclose(_log_fd);

	}

	return ret;

}

	InitializeRailGUI();

	/* We are the server, we start a new company (not dedicated),

	 * so set the default password *if* needed. */

	if (_network_server && !StrEmpty(_settings_client.network.default_company_pass)) {

		NetworkChangeCompanyPassword(_local_company, _settings_client.network.default_company_pass);

	}

	if (_settings_client.gui.pause_on_newgame) DoCommandP(0, PM_PAUSED_NORMAL, 1, CMD_PAUSE);

		case SL_OK: return true;

		case SL_REINIT:

			if (_network_dedicated) {

				/*

				 * We need to reinit a network map...

				/* We can't load the intro game as server, so disconnect first. */

				NetworkDisconnect();

			}

			switch (ogm) {

				default:

void SwitchToMode(SwitchMode new_mode)

{

	/* If we are saving something, the network stays in his current state */

	if (new_mode != SM_SAVE_GAME) {

		/* If the network is active, make it not-active */

			}

		}

	}

	/* Make sure all AI controllers are gone at quitting game */

	if (new_mode != SM_SAVE_GAME) AI::KillAll();

		case SM_RESTARTGAME: // Restart --> 'Random game' with current settings

		case SM_NEWGAME: // New Game --> 'Random game'

			if (_network_server) {

				seprintf(_network_game_info.map_name, lastof(_network_game_info.map_name), "Random Map");

			}

			MakeNewGame(false, new_mode == SM_NEWGAME);

			break;

				IConsoleCmdExec("exec scripts/game_start.scr 0");

				/* Decrease pause counter (was increased from opening load dialog) */

				DoCommandP(0, PM_PAUSED_SAVELOAD, 0, CMD_PAUSE);

				if (_network_server) {

					seprintf(_network_game_info.map_name, lastof(_network_game_info.map_name), "%s (Loaded game)", _file_to_saveload.title);

				}

			}

			break;

		}

		case SM_START_HEIGHTMAP: // Load a heightmap and start a new game from it

			if (_network_server) {

				seprintf(_network_game_info.map_name, lastof(_network_game_info.map_name), "%s (Heightmap)", _file_to_saveload.title);

			}

			MakeNewGame(true, true);

			break;

void GameLoop()

{

	if (_game_mode == GM_BOOTSTRAP) {

		/* Check for UDP stuff */

		if (_network_available) NetworkBackgroundLoop();

		InputLoop();

		return;

	}

	IncreaseSpriteLRU();

	InteractiveRandom();

	/* Check for UDP stuff */

	if (_network_available) NetworkBackgroundLoop();

		/* Singleplayer */

		StateGameLoop();

	}

	if (!_pause_mode && HasBit(_display_opt, DO_FULL_ANIMATION)) DoPaletteAnimations();