#include "stdafx.h"
//#include "Minecraft.h"

#include <ctime>

#include "ConsoleInput.h"
#include "DerivedServerLevel.h"
#include "DispenserBootstrap.h"
#include "EntityTracker.h"
#include "MinecraftServer.h"
#include "Options.h"
#include "PlayerList.h"
#include "ServerChunkCache.h"
#include "ServerConnection.h"
#include "ServerLevel.h"
#include "ServerLevelListener.h"
#include "Settings.h"
#include "..\Minecraft.World\Command.h"
#include "..\Minecraft.World\AABB.h"
#include "..\Minecraft.World\Vec3.h"
#include "..\Minecraft.World\net.minecraft.network.h"
#include "..\Minecraft.World\net.minecraft.world.level.dimension.h"
#include "..\Minecraft.World\net.minecraft.world.level.storage.h"
#include "..\Minecraft.World\net.minecraft.world.h"
#include "..\Minecraft.World\net.minecraft.world.level.h"
#include "..\Minecraft.World\net.minecraft.world.level.tile.h"
#include "..\Minecraft.World\Pos.h"
#include "..\Minecraft.World\System.h"
#include "..\Minecraft.World\StringHelpers.h"
#include "..\Minecraft.World\net.minecraft.world.entity.item.h"
#include "..\Minecraft.World\net.minecraft.world.item.h"
#include "..\Minecraft.World\net.minecraft.world.item.enchantment.h"
#include "..\Minecraft.World\net.minecraft.world.damagesource.h"
#ifdef _WINDOWS64
#include "Windows64\Network\WinsockNetLayer.h"
#endif
#include <sstream>
#ifdef SPLIT_SAVES
#include "..\Minecraft.World\ConsoleSaveFileSplit.h"
#endif
#include "..\Minecraft.World\ConsoleSaveFileOriginal.h"
#include "..\Minecraft.World\Socket.h"
#include "..\Minecraft.World\net.minecraft.world.entity.h"
#include "ProgressRenderer.h"
#include "ServerPlayer.h"
#include "GameRenderer.h"
#include "..\Minecraft.World\ThreadName.h"
#include "..\Minecraft.World\IntCache.h"
#include "..\Minecraft.World\CompressedTileStorage.h"
#include "..\Minecraft.World\SparseLightStorage.h"
#include "..\Minecraft.World\SparseDataStorage.h"
#include "..\Minecraft.World\compression.h"
#ifdef _XBOX
#include "Common\XUI\XUI_DebugSetCamera.h"
#endif
#include "PS3\PS3Extras\ShutdownManager.h"
#include "ServerCommandDispatcher.h"
#include "..\Minecraft.World\BiomeSource.h"
#include "PlayerChunkMap.h"
#include "Common\Telemetry\TelemetryManager.h"
#include "PlayerConnection.h"
#ifdef _XBOX_ONE
#include "Durango\Network\NetworkPlayerDurango.h"
#endif

#define DEBUG_SERVER_DONT_SPAWN_MOBS 0

//4J Added
MinecraftServer *MinecraftServer::server = NULL;
bool MinecraftServer::setTimeAtEndOfTick = false;
__int64 MinecraftServer::setTime = 0;
bool MinecraftServer::setTimeOfDayAtEndOfTick = false;
__int64 MinecraftServer::setTimeOfDay = 0;
bool	MinecraftServer::m_bPrimaryPlayerSignedOut=false;
bool	MinecraftServer::s_bServerHalted=false;
bool	MinecraftServer::s_bSaveOnExitAnswered=false;
#ifdef _ACK_CHUNK_SEND_THROTTLING
bool MinecraftServer::s_hasSentEnoughPackets = false;
__int64 MinecraftServer::s_tickStartTime = 0;
vector<INetworkPlayer *> MinecraftServer::s_sentTo;
#else
int MinecraftServer::s_slowQueuePlayerIndex = 0;
int MinecraftServer::s_slowQueueLastTime = 0;
bool MinecraftServer::s_slowQueuePacketSent = false;
#endif

unordered_map<wstring, int> MinecraftServer::ironTimers;

static bool ShouldUseDedicatedServerProperties()
{
#ifdef _WINDOWS64
	return g_Win64DedicatedServer;
#else
	return false;
#endif
}

static int GetDedicatedServerInt(Settings *settings, const wchar_t *key, int defaultValue)
{
	return (ShouldUseDedicatedServerProperties() && settings != NULL) ? settings->getInt(key, defaultValue) : defaultValue;
}

static bool GetDedicatedServerBool(Settings *settings, const wchar_t *key, bool defaultValue)
{
	return (ShouldUseDedicatedServerProperties() && settings != NULL) ? settings->getBoolean(key, defaultValue) : defaultValue;
}

static wstring GetDedicatedServerString(Settings *settings, const wchar_t *key, const wstring &defaultValue)
{
	return (ShouldUseDedicatedServerProperties() && settings != NULL) ? settings->getString(key, defaultValue) : defaultValue;
}

static void PrintConsoleLine(const wchar_t *prefix, const wstring &message)
{
	wprintf(L"%ls%ls\n", prefix, message.c_str());
	fflush(stdout);
}

static bool TryParseIntValue(const wstring &text, int &value)
{
	std::wistringstream stream(text);
	stream >> value;
	return !stream.fail() && stream.eof();
}

static vector<wstring> SplitConsoleCommand(const wstring &command)
{
	vector<wstring> tokens;
	std::wistringstream stream(command);
	wstring token;
	while (stream >> token)
	{
		tokens.push_back(token);
	}
	return tokens;
}

static wstring JoinConsoleCommandTokens(const vector<wstring> &tokens, size_t startIndex)
{
	wstring joined;
	for (size_t i = startIndex; i < tokens.size(); ++i)
	{
		if (!joined.empty()) joined += L" ";
		joined += tokens[i];
	}
	return joined;
}

static shared_ptr<ServerPlayer> FindPlayerByName(PlayerList *playerList, const wstring &name)
{
	if (playerList == NULL) return nullptr;

	for (size_t i = 0; i < playerList->players.size(); ++i)
	{
		shared_ptr<ServerPlayer> player = playerList->players[i];
		if (player != NULL && equalsIgnoreCase(player->getName(), name))
		{
			return player;
		}
	}

	return nullptr;
}

static void SetAllLevelTimes(MinecraftServer *server, int value)
{
	for (unsigned int i = 0; i < server->levels.length; ++i)
	{
		if (server->levels[i] != NULL)
		{
			server->levels[i]->setDayTime(value);
		}
	}
}

static bool ExecuteConsoleCommand(MinecraftServer *server, const wstring &rawCommand)
{
	if (server == NULL)
		return false;

	wstring command = trimString(rawCommand);
	if (command.empty())
		return true;

	if (command[0] == L'/')
	{
		command = trimString(command.substr(1));
	}

	vector<wstring> tokens = SplitConsoleCommand(command);
	if (tokens.empty())
		return true;

	const wstring action = toLower(tokens[0]);
	PlayerList *playerList = server->getPlayers();

	if (action == L"help" || action == L"?")
	{
		server->info(L"Commands: help, stop, list, say <message>, save-all, time <set day|night|ticks|add ticks>, weather <clear|rain|thunder> [seconds], tp <player> <target>, give <player> <itemId> [amount] [aux], enchant <player> <enchantId> [level], kill <player>");
		return true;
	}

	if (action == L"stop")
	{
		server->info(L"Stopping server...");
		MinecraftServer::HaltServer();
		return true;
	}

	if (action == L"list")
	{
		wstring playerNames = (playerList != NULL) ? playerList->getPlayerNames() : L"";
		if (playerNames.empty()) playerNames = L"(none)";
		server->info(L"Players (" + std::to_wstring((playerList != NULL) ? playerList->getPlayerCount() : 0) + L"): " + playerNames);
		return true;
	}

	if (action == L"say")
	{
		if (tokens.size() < 2)
		{
			server->warn(L"Usage: say <message>");
			return false;
		}

		wstring message = L"[Server] " + JoinConsoleCommandTokens(tokens, 1);
		if (playerList != NULL)
		{
			playerList->broadcastAll(shared_ptr<ChatPacket>(new ChatPacket(message)));
		}
		server->info(message);
		return true;
	}

	if (action == L"save-all")
	{
		if (playerList != NULL)
		{
			playerList->saveAll(NULL, false);
		}
		server->info(L"World saved.");
		return true;
	}

	if (action == L"time")
	{
		if (tokens.size() < 2)
		{
			server->warn(L"Usage: time set <day|night|ticks> | time add <ticks>");
			return false;
		}

		if (toLower(tokens[1]) == L"add")
		{
			if (tokens.size() < 3)
			{
				server->warn(L"Usage: time add <ticks>");
				return false;
			}

			int delta = 0;
			if (!TryParseIntValue(tokens[2], delta))
			{
				server->warn(L"Invalid tick value: " + tokens[2]);
				return false;
			}

			for (unsigned int i = 0; i < server->levels.length; ++i)
			{
				if (server->levels[i] != NULL)
				{
					server->levels[i]->setDayTime(server->levels[i]->getDayTime() + delta);
				}
			}

			server->info(L"Added " + std::to_wstring(delta) + L" ticks.");
			return true;
		}

		wstring timeValue = toLower(tokens[1]);
		if (timeValue == L"set")
		{
			if (tokens.size() < 3)
			{
				server->warn(L"Usage: time set <day|night|ticks>");
				return false;
			}
			timeValue = toLower(tokens[2]);
		}

		int targetTime = 0;
		if (timeValue == L"day")
		{
			targetTime = 0;
		}
		else if (timeValue == L"night")
		{
			targetTime = 12500;
		}
		else if (!TryParseIntValue(timeValue, targetTime))
		{
			server->warn(L"Invalid time value: " + timeValue);
			return false;
		}

		SetAllLevelTimes(server, targetTime);
		server->info(L"Time set to " + std::to_wstring(targetTime) + L".");
		return true;
	}

	if (action == L"weather")
	{
		if (tokens.size() < 2)
		{
			server->warn(L"Usage: weather <clear|rain|thunder> [seconds]");
			return false;
		}

		int durationSeconds = 600;
		if (tokens.size() >= 3 && !TryParseIntValue(tokens[2], durationSeconds))
		{
			server->warn(L"Invalid duration: " + tokens[2]);
			return false;
		}

		if (server->levels[0] == NULL)
		{
			server->warn(L"The overworld is not loaded.");
			return false;
		}

		LevelData *levelData = server->levels[0]->getLevelData();
		int duration = durationSeconds * SharedConstants::TICKS_PER_SECOND;
		levelData->setRainTime(duration);
		levelData->setThunderTime(duration);

		wstring weather = toLower(tokens[1]);
		if (weather == L"clear")
		{
			levelData->setRaining(false);
			levelData->setThundering(false);
		}
		else if (weather == L"rain")
		{
			levelData->setRaining(true);
			levelData->setThundering(false);
		}
		else if (weather == L"thunder")
		{
			levelData->setRaining(true);
			levelData->setThundering(true);
		}
		else
		{
			server->warn(L"Usage: weather <clear|rain|thunder> [seconds]");
			return false;
		}

		server->info(L"Weather set to " + weather + L".");
		return true;
	}

	if (action == L"tp" || action == L"teleport")
	{
		if (tokens.size() < 3)
		{
			server->warn(L"Usage: tp <player> <target>");
			return false;
		}

		shared_ptr<ServerPlayer> subject = FindPlayerByName(playerList, tokens[1]);
		shared_ptr<ServerPlayer> destination = FindPlayerByName(playerList, tokens[2]);
		if (subject == NULL)
		{
			server->warn(L"Unknown player: " + tokens[1]);
			return false;
		}
		if (destination == NULL)
		{
			server->warn(L"Unknown player: " + tokens[2]);
			return false;
		}
		if (subject->level->dimension->id != destination->level->dimension->id || !subject->isAlive())
		{
			server->warn(L"Teleport failed because the players are not in the same dimension or the source player is dead.");
			return false;
		}

		subject->ride(nullptr);
		subject->connection->teleport(destination->x, destination->y, destination->z, destination->yRot, destination->xRot);
		server->info(L"Teleported " + subject->getName() + L" to " + destination->getName() + L".");
		return true;
	}

	if (action == L"give")
	{
		if (tokens.size() < 3)
		{
			server->warn(L"Usage: give <player> <itemId> [amount] [aux]");
			return false;
		}

		shared_ptr<ServerPlayer> player = FindPlayerByName(playerList, tokens[1]);
		if (player == NULL)
		{
			server->warn(L"Unknown player: " + tokens[1]);
			return false;
		}

		int itemId = 0;
		int amount = 1;
		int aux = 0;
		if (!TryParseIntValue(tokens[2], itemId))
		{
			server->warn(L"Invalid item id: " + tokens[2]);
			return false;
		}
		if (tokens.size() >= 4 && !TryParseIntValue(tokens[3], amount))
		{
			server->warn(L"Invalid amount: " + tokens[3]);
			return false;
		}
		if (tokens.size() >= 5 && !TryParseIntValue(tokens[4], aux))
		{
			server->warn(L"Invalid aux value: " + tokens[4]);
			return false;
		}
		if (itemId <= 0 || Item::items[itemId] == NULL)
		{
			server->warn(L"Unknown item id: " + std::to_wstring(itemId));
			return false;
		}
		if (amount <= 0)
		{
			server->warn(L"Amount must be positive.");
			return false;
		}

		shared_ptr<ItemInstance> itemInstance(new ItemInstance(itemId, amount, aux));
		shared_ptr<ItemEntity> drop = player->drop(itemInstance);
		if (drop != NULL)
		{
			drop->throwTime = 0;
		}
		server->info(L"Gave item " + std::to_wstring(itemId) + L" x" + std::to_wstring(amount) + L" to " + player->getName() + L".");
		return true;
	}

	if (action == L"enchant")
	{
		if (tokens.size() < 3)
		{
			server->warn(L"Usage: enchant <player> <enchantId> [level]");
			return false;
		}

		shared_ptr<ServerPlayer> player = FindPlayerByName(playerList, tokens[1]);
		if (player == NULL)
		{
			server->warn(L"Unknown player: " + tokens[1]);
			return false;
		}

		int enchantmentId = 0;
		int enchantmentLevel = 1;
		if (!TryParseIntValue(tokens[2], enchantmentId))
		{
			server->warn(L"Invalid enchantment id: " + tokens[2]);
			return false;
		}
		if (tokens.size() >= 4 && !TryParseIntValue(tokens[3], enchantmentLevel))
		{
			server->warn(L"Invalid enchantment level: " + tokens[3]);
			return false;
		}

		shared_ptr<ItemInstance> selectedItem = player->getSelectedItem();
		if (selectedItem == NULL)
		{
			server->warn(L"The player is not holding an item.");
			return false;
		}

		Enchantment *enchantment = Enchantment::enchantments[enchantmentId];
		if (enchantment == NULL)
		{
			server->warn(L"Unknown enchantment id: " + std::to_wstring(enchantmentId));
			return false;
		}
		if (!enchantment->canEnchant(selectedItem))
		{
			server->warn(L"That enchantment cannot be applied to the selected item.");
			return false;
		}

		if (enchantmentLevel < enchantment->getMinLevel()) enchantmentLevel = enchantment->getMinLevel();
		if (enchantmentLevel > enchantment->getMaxLevel()) enchantmentLevel = enchantment->getMaxLevel();

		if (selectedItem->hasTag())
		{
			ListTag<CompoundTag> *enchantmentTags = selectedItem->getEnchantmentTags();
			if (enchantmentTags != NULL)
			{
				for (int i = 0; i < enchantmentTags->size(); i++)
				{
					int type = enchantmentTags->get(i)->getShort((wchar_t *)ItemInstance::TAG_ENCH_ID);
					if (Enchantment::enchantments[type] != NULL && !Enchantment::enchantments[type]->isCompatibleWith(enchantment))
					{
						server->warn(L"That enchantment conflicts with an existing enchantment on the selected item.");
						return false;
					}
				}
			}
		}

		selectedItem->enchant(enchantment, enchantmentLevel);
		server->info(L"Enchanted " + player->getName() + L"'s held item with " + std::to_wstring(enchantmentId) + L" " + std::to_wstring(enchantmentLevel) + L".");
		return true;
	}

	if (action == L"kill")
	{
		if (tokens.size() < 2)
		{
			server->warn(L"Usage: kill <player>");
			return false;
		}

		shared_ptr<ServerPlayer> player = FindPlayerByName(playerList, tokens[1]);
		if (player == NULL)
		{
			server->warn(L"Unknown player: " + tokens[1]);
			return false;
		}

		player->hurt(DamageSource::outOfWorld, 3.4e38f);
		server->info(L"Killed " + player->getName() + L".");
		return true;
	}

	server->warn(L"Unknown command: " + command);
	return false;
}

MinecraftServer::MinecraftServer()
{
	// 4J - added initialisers
	connection = NULL;
	settings = NULL;
	players = NULL;
	commands = NULL;
	running = true;
	m_bLoaded = false;
	stopped = false;
	tickCount = 0;
	wstring progressStatus;
	progress = 0;
	motd = L"";

	m_isServerPaused = false;
	m_serverPausedEvent = new C4JThread::Event;

	m_saveOnExit = false;
	m_suspending = false;

	m_ugcPlayersVersion = 0;
	m_texturePackId = 0;
	maxBuildHeight = Level::maxBuildHeight;
	playerIdleTimeout = 0;
	m_postUpdateThread = NULL;
	forceGameType = false;

	commandDispatcher = new ServerCommandDispatcher();
	InitializeCriticalSection(&m_consoleInputCS);

	DispenserBootstrap::bootStrap();
}

MinecraftServer::~MinecraftServer()
{
	DeleteCriticalSection(&m_consoleInputCS);
}

bool MinecraftServer::initServer(__int64 seed, NetworkGameInitData *initData, DWORD initSettings, bool findSeed)
{
	// 4J - removed
#if 0
	commands = new ConsoleCommands(this);

	Thread t = new Thread() {
		public void run() {
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			String line = null;
			try {
				while (!stopped && running && (line = br.readLine()) != null) {
					handleConsoleInput(line, MinecraftServer.this);
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	};
	t.setDaemon(true);
	t.start();


	LogConfigurator.initLogger();
	logger.info("Starting minecraft server version " + VERSION);

	if (Runtime.getRuntime().maxMemory() / 1024 / 1024 < 512) {
		logger.warning("**** NOT ENOUGH RAM!");
		logger.warning("To start the server with more ram, launch it as \"java -Xmx1024M -Xms1024M -jar minecraft_server.jar\"");
	}

	logger.info("Loading properties");
#endif
	settings = new Settings(new File(L"server.properties"));

	app.SetGameHostOption(eGameHostOption_Difficulty, GetDedicatedServerInt(settings, L"difficulty", app.GetGameHostOption(eGameHostOption_Difficulty)));
	app.SetGameHostOption(eGameHostOption_GameType, GetDedicatedServerInt(settings, L"gamemode", app.GetGameHostOption(eGameHostOption_GameType)));
	app.SetGameHostOption(eGameHostOption_Structures, GetDedicatedServerBool(settings, L"generate-structures", app.GetGameHostOption(eGameHostOption_Structures) > 0) ? 1 : 0);
	app.SetGameHostOption(eGameHostOption_BonusChest, GetDedicatedServerBool(settings, L"bonus-chest", app.GetGameHostOption(eGameHostOption_BonusChest) > 0) ? 1 : 0);
	app.SetGameHostOption(eGameHostOption_PvP, GetDedicatedServerBool(settings, L"pvp", app.GetGameHostOption(eGameHostOption_PvP) > 0) ? 1 : 0);
	app.SetGameHostOption(eGameHostOption_TrustPlayers, GetDedicatedServerBool(settings, L"trust-players", app.GetGameHostOption(eGameHostOption_TrustPlayers) > 0) ? 1 : 0);
	app.SetGameHostOption(eGameHostOption_FireSpreads, GetDedicatedServerBool(settings, L"fire-spreads", app.GetGameHostOption(eGameHostOption_FireSpreads) > 0) ? 1 : 0);
	app.SetGameHostOption(eGameHostOption_TNT, GetDedicatedServerBool(settings, L"tnt", app.GetGameHostOption(eGameHostOption_TNT) > 0) ? 1 : 0);

	app.DebugPrintf("\n*** SERVER SETTINGS ***\n");
	app.DebugPrintf("ServerSettings: host-friends-only is %s\n",(app.GetGameHostOption(eGameHostOption_FriendsOfFriends)>0)?"on":"off");
	app.DebugPrintf("ServerSettings: game-type is %s\n",(app.GetGameHostOption(eGameHostOption_GameType)==0)?"Survival Mode":"Creative Mode");
	app.DebugPrintf("ServerSettings: pvp is %s\n",(app.GetGameHostOption(eGameHostOption_PvP)>0)?"on":"off");
	app.DebugPrintf("ServerSettings: fire spreads is %s\n",(app.GetGameHostOption(eGameHostOption_FireSpreads)>0)?"on":"off");
	app.DebugPrintf("ServerSettings: tnt explodes is %s\n",(app.GetGameHostOption(eGameHostOption_TNT)>0)?"on":"off");
	app.DebugPrintf("\n");

	// TODO 4J Stu - Init a load of settings based on data passed as params
	//settings->setBooleanAndSave( L"host-friends-only", (app.GetGameHostOption(eGameHostOption_FriendsOfFriends)>0) );

	// 4J - Unused
	//localIp = settings->getString(L"server-ip", L"");
	//onlineMode = settings->getBoolean(L"online-mode", true);
	//motd = settings->getString(L"motd", L"A Minecraft Server");
	//motd.replace('�', '$');

	setAnimals(GetDedicatedServerBool(settings, L"spawn-animals", true));
	setNpcsEnabled(GetDedicatedServerBool(settings, L"spawn-npcs", true));
	setPvpAllowed(app.GetGameHostOption( eGameHostOption_PvP )>0?true:false);

	// 4J Stu - We should never have hacked clients flying when they shouldn't be like the PC version, so enable flying always
	// Fix for #46612 - TU5: Code: Multiplayer: A client can be banned for flying when accidentaly being blown by dynamite
	setFlightAllowed(GetDedicatedServerBool(settings, L"allow-flight", true));

	// 4J Stu - Enabling flight to stop it kicking us when we use it
#ifdef _DEBUG_MENUS_ENABLED
	setFlightAllowed(true);
#endif

#if 1
	connection = new ServerConnection(this);
	Socket::Initialise(connection);	// 4J - added
#else
	// 4J - removed
	InetAddress localAddress = null;
	if (localIp.length() > 0) localAddress = InetAddress.getByName(localIp);
	port = settings.getInt("server-port", DEFAULT_MINECRAFT_PORT);

	logger.info("Starting Minecraft server on " + (localIp.length() == 0 ? "*" : localIp) + ":" + port);
	try {
		connection = new ServerConnection(this, localAddress, port);
	} catch (IOException e) {
		logger.warning("**** FAILED TO BIND TO PORT!");
		logger.log(Level.WARNING, "The exception was: " + e.toString());
		logger.warning("Perhaps a server is already running on that port?");
		return false;
	}

	if (!onlineMode) {
		logger.warning("**** SERVER IS RUNNING IN OFFLINE/INSECURE MODE!");
		logger.warning("The server will make no attempt to authenticate usernames. Beware.");
		logger.warning("While this makes the game possible to play without internet access, it also opens up the ability for hackers to connect with any username they choose.");
		logger.warning("To change this, set \"online-mode\" to \"true\" in the server.settings file.");
	}
#endif
	setPlayers(new PlayerList(this));

	// 4J-JEV: Need to wait for levelGenerationOptions to load.
	while ( app.getLevelGenerationOptions() != NULL && !app.getLevelGenerationOptions()->hasLoadedData() )
		Sleep(1);

	if ( app.getLevelGenerationOptions() != NULL && !app.getLevelGenerationOptions()->ready() )
	{
		// TODO: Stop loading, add error message.
	}

	__int64 levelNanoTime = System::nanoTime();

        wstring levelName = (initData && !initData->levelName.empty()) ? initData->levelName : GetDedicatedServerString(settings, L"level-name", L"world");
		wstring levelTypeString;

	bool gameRuleUseFlatWorld = false;
	if(app.getLevelGenerationOptions() != NULL)
	{
		gameRuleUseFlatWorld = app.getLevelGenerationOptions()->getuseFlatWorld();
	}
	if(gameRuleUseFlatWorld || app.GetGameHostOption(eGameHostOption_LevelType)>0)
	{
		levelTypeString = GetDedicatedServerString(settings, L"level-type",  L"flat");
	}
	else
	{
		levelTypeString = GetDedicatedServerString(settings, L"level-type",L"default");
	}

	LevelType *pLevelType = LevelType::getLevelType(levelTypeString);
	if (pLevelType == NULL)
	{
		pLevelType = LevelType::lvl_normal;
	}

	ProgressRenderer *mcprogress = Minecraft::GetInstance()->progressRenderer;
	mcprogress->progressStart(IDS_PROGRESS_INITIALISING_SERVER);

	if( findSeed )
	{
#ifdef __PSVITA__
		seed = BiomeSource::findSeed(pLevelType, &running);
#else
		seed = BiomeSource::findSeed(pLevelType);
#endif
	}

	setMaxBuildHeight(GetDedicatedServerInt(settings, L"max-build-height", Level::maxBuildHeight));
	setMaxBuildHeight(((getMaxBuildHeight() + 8) / 16) * 16);
	setMaxBuildHeight(Mth::clamp(getMaxBuildHeight(), 64, Level::maxBuildHeight));
	//settings->setProperty(L"max-build-height", maxBuildHeight);

#if 0
	wstring levelSeedString = settings->getString(L"level-seed", L"");
	__int64 levelSeed = (new Random())->nextLong();
	if (levelSeedString.length() > 0)
	{
		long newSeed = _fromString<__int64>(levelSeedString);
		if (newSeed != 0) {
			levelSeed = newSeed;
		}
	}
#endif
	//        logger.info("Preparing level \"" + levelName + "\"");
	m_bLoaded = loadLevel(new McRegionLevelStorageSource(File(L".")), levelName, seed, pLevelType, initData);
	//        logger.info("Done (" + (System.nanoTime() - levelNanoTime) + "ns)! For help, type \"help\" or \"?\"");

	// 4J delete passed in save data now - this is only required for the tutorial which is loaded by passing data directly in rather than using the storage manager
	if( initData->saveData )
	{
		delete initData->saveData->data;
		initData->saveData->data = 0;
		initData->saveData->fileSize = 0;
	}

	g_NetworkManager.ServerReady();	// 4J added
	return m_bLoaded;

}

// 4J - added - extra thread to post processing on separate thread during level creation
int MinecraftServer::runPostUpdate(void* lpParam)
{
	ShutdownManager::HasStarted(ShutdownManager::ePostProcessThread);

	MinecraftServer *server = (MinecraftServer *)lpParam;
	Entity::useSmallIds();		// This thread can end up spawning entities as resources
	IntCache::CreateNewThreadStorage();
	AABB::CreateNewThreadStorage();
	Vec3::CreateNewThreadStorage();
	Compression::UseDefaultThreadStorage();
	Level::enableLightingCache();
	Tile::CreateNewThreadStorage();

	// Update lights for both levels until we are signalled to terminate
	do
	{
		EnterCriticalSection(&server->m_postProcessCS);
		if( server->m_postProcessRequests.size() )
		{
			MinecraftServer::postProcessRequest request = server->m_postProcessRequests.back();
			server->m_postProcessRequests.pop_back();
			LeaveCriticalSection(&server->m_postProcessCS);
			static int count = 0;
			PIXBeginNamedEvent(0,"Post processing %d ", (count++)%8);
			request.chunkSource->postProcess(request.chunkSource, request.x, request.z );
			PIXEndNamedEvent();
		}
		else
		{
			LeaveCriticalSection(&server->m_postProcessCS);
		}
		Sleep(1);
	} while (!server->m_postUpdateTerminate && ShutdownManager::ShouldRun(ShutdownManager::ePostProcessThread));
	//#ifndef __PS3__
	// One final pass through updates to make sure we're done
	EnterCriticalSection(&server->m_postProcessCS);
	int maxRequests = server->m_postProcessRequests.size();
	while(server->m_postProcessRequests.size() && ShutdownManager::ShouldRun(ShutdownManager::ePostProcessThread) )
	{
		MinecraftServer::postProcessRequest request = server->m_postProcessRequests.back();
		server->m_postProcessRequests.pop_back();
		LeaveCriticalSection(&server->m_postProcessCS);
		request.chunkSource->postProcess(request.chunkSource, request.x, request.z );
#ifdef __PS3__
#ifndef _CONTENT_PACKAGE
		if((server->m_postProcessRequests.size() % 10) == 0)
			printf("processing request %00d\n", server->m_postProcessRequests.size());
#endif
		Sleep(1);
#endif
		EnterCriticalSection(&server->m_postProcessCS);
	}
	LeaveCriticalSection(&server->m_postProcessCS);
	//#endif //__PS3__
	Tile::ReleaseThreadStorage();
	IntCache::ReleaseThreadStorage();
	AABB::ReleaseThreadStorage();
	Vec3::ReleaseThreadStorage();
	Level::destroyLightingCache();

	ShutdownManager::HasFinished(ShutdownManager::ePostProcessThread);

	return 0;
}

void	MinecraftServer::addPostProcessRequest(ChunkSource *chunkSource, int x, int z)
{
	EnterCriticalSection(&m_postProcessCS);
	m_postProcessRequests.push_back(MinecraftServer::postProcessRequest(x,z,chunkSource));
	LeaveCriticalSection(&m_postProcessCS);
}

void MinecraftServer::postProcessTerminate(ProgressRenderer *mcprogress)
{
	DWORD status = 0;

	EnterCriticalSection(&server->m_postProcessCS);
	size_t postProcessItemCount = server->m_postProcessRequests.size();
	LeaveCriticalSection(&server->m_postProcessCS);

	do
	{
		status = m_postUpdateThread->WaitForCompletion(50);
		if( status == WAIT_TIMEOUT )
		{
			EnterCriticalSection(&server->m_postProcessCS);
			size_t postProcessItemRemaining = server->m_postProcessRequests.size();
			LeaveCriticalSection(&server->m_postProcessCS);

			if( postProcessItemCount )
			{
				mcprogress->progressStagePercentage((postProcessItemCount - postProcessItemRemaining) * 100 / postProcessItemCount);
			}
			CompressedTileStorage::tick();
			SparseLightStorage::tick();
			SparseDataStorage::tick();
		}
	} while ( status == WAIT_TIMEOUT );
	delete m_postUpdateThread;
	m_postUpdateThread = NULL;
	DeleteCriticalSection(&m_postProcessCS);
}

bool MinecraftServer::loadLevel(LevelStorageSource *storageSource, const wstring& name, __int64 levelSeed, LevelType *pLevelType, NetworkGameInitData *initData)
{
	//	4J - TODO - do with new save stuff
	//    if (storageSource->requiresConversion(name))
	//	{
	//		assert(false);
	//    }
	ProgressRenderer *mcprogress = Minecraft::GetInstance()->progressRenderer;

	// 4J TODO - free levels here if there are already some?
	levels = ServerLevelArray(3);

	int gameTypeId = GetDedicatedServerInt(settings, L"gamemode", app.GetGameHostOption(eGameHostOption_GameType));//LevelSettings::GAMETYPE_SURVIVAL);
	GameType *gameType = LevelSettings::validateGameType(gameTypeId);
	app.DebugPrintf("Default game type: %d\n" , gameTypeId);

	LevelSettings *levelSettings = new LevelSettings(levelSeed, gameType, app.GetGameHostOption(eGameHostOption_Structures)>0?true:false, isHardcore(), true, pLevelType, initData->xzSize, initData->hellScale);
	if( app.GetGameHostOption(eGameHostOption_BonusChest ) ) levelSettings->enableStartingBonusItems();

	// 4J - temp - load existing level
	shared_ptr<McRegionLevelStorage> storage = nullptr;
	bool levelChunksNeedConverted = false;
	if( initData->saveData != NULL )
	{
		// We are loading a file from disk with the data passed in

#ifdef SPLIT_SAVES
		ConsoleSaveFileOriginal oldFormatSave( initData->saveData->saveName, initData->saveData->data, initData->saveData->fileSize, false, initData->savePlatform );
		ConsoleSaveFile* pSave = new ConsoleSaveFileSplit( &oldFormatSave );

		//ConsoleSaveFile* pSave = new ConsoleSaveFileSplit( initData->saveData->saveName, initData->saveData->data, initData->saveData->fileSize, false, initData->savePlatform );
#else
		ConsoleSaveFile* pSave = new ConsoleSaveFileOriginal( initData->saveData->saveName, initData->saveData->data, initData->saveData->fileSize, false, initData->savePlatform );
#endif
		if(pSave->isSaveEndianDifferent())
			levelChunksNeedConverted = true;
		pSave->ConvertToLocalPlatform(); // check if we need to convert this file from PS3->PS4

		storage = shared_ptr<McRegionLevelStorage>(new McRegionLevelStorage(pSave, File(L"."), name, true));
	}
	else
	{
		// We are loading a save from the storage manager
#ifdef SPLIT_SAVES
		bool bLevelGenBaseSave = false;
		LevelGenerationOptions *levelGen = app.getLevelGenerationOptions();
		if( levelGen != NULL && levelGen->requiresBaseSave())
		{
			DWORD fileSize = 0;
			LPVOID pvSaveData = levelGen->getBaseSaveData(fileSize);
			if(pvSaveData && fileSize != 0) bLevelGenBaseSave = true;
		}
		ConsoleSaveFileSplit *newFormatSave = NULL;
		if(bLevelGenBaseSave)
		{
			ConsoleSaveFileOriginal oldFormatSave( L"" );
			newFormatSave = new ConsoleSaveFileSplit( &oldFormatSave );
		}
		else
		{
			newFormatSave = new ConsoleSaveFileSplit( L"" );
		}

		storage = shared_ptr<McRegionLevelStorage>(new McRegionLevelStorage(newFormatSave, File(L"."), name, true));
#else
		storage = shared_ptr<McRegionLevelStorage>(new McRegionLevelStorage(new ConsoleSaveFileOriginal( L"" ), File(L"."), name, true));
#endif
	}

	//	McRegionLevelStorage *storage = new McRegionLevelStorage(new ConsoleSaveFile( L"" ), L"", L"", 0); // original
	//    McRegionLevelStorage *storage = new McRegionLevelStorage(File(L"."), name, true); // TODO
	for (unsigned int i = 0; i < levels.length; i++)
	{
		if( s_bServerHalted || !g_NetworkManager.IsInSession() )
		{
			return false;
		}

		//            String levelName = name;
		//            if (i == 1) levelName += "_nether";
		int dimension = 0;
		if (i == 1) dimension = -1;
		if (i == 2) dimension = 1;
		if (i == 0)
		{
			levels[i] = new ServerLevel(this, storage, name, dimension, levelSettings);
			if(app.getLevelGenerationOptions() != NULL)
			{
				LevelGenerationOptions *mapOptions = app.getLevelGenerationOptions();
				Pos *spawnPos = mapOptions->getSpawnPos();
				if( spawnPos != NULL )
				{
					levels[i]->setSpawnPos( spawnPos );
				}

				levels[i]->getLevelData()->setHasBeenInCreative(mapOptions->isFromDLC());
			}
		}
		else levels[i] = new DerivedServerLevel(this, storage, name, dimension, levelSettings, levels[0]);
		//        levels[i]->addListener(new ServerLevelListener(this, levels[i]));		// 4J - have moved this to the ServerLevel ctor so that it is set up in time for the first chunk to load, which might actually happen there

		// 4J Stu - We set the levels difficulty based on the minecraft options
		//levels[i]->difficulty = settings->getBoolean(L"spawn-monsters", true) ? Difficulty::EASY : Difficulty::PEACEFUL;
		Minecraft *pMinecraft = Minecraft::GetInstance();
		//		m_lastSentDifficulty = pMinecraft->options->difficulty;
		levels[i]->difficulty = app.GetGameHostOption(eGameHostOption_Difficulty); //pMinecraft->options->difficulty;
		app.DebugPrintf("MinecraftServer::loadLevel - Difficulty = %d\n",levels[i]->difficulty);

#if DEBUG_SERVER_DONT_SPAWN_MOBS
		levels[i]->setSpawnSettings(false, false);
#else
		levels[i]->setSpawnSettings(GetDedicatedServerBool(settings, L"spawn-monsters", true), animals);
#endif
		levels[i]->getLevelData()->setGameType(gameType);

		if(app.getLevelGenerationOptions() != NULL)
		{
			LevelGenerationOptions *mapOptions = app.getLevelGenerationOptions();
			levels[i]->getLevelData()->setHasBeenInCreative(mapOptions->getLevelHasBeenInCreative() );
		}

		players->setLevel(levels);
	}

	if( levels[0]->isNew )
	{
		mcprogress->progressStage(IDS_PROGRESS_GENERATING_SPAWN_AREA);
	}
	else
	{
		mcprogress->progressStage(IDS_PROGRESS_LOADING_SPAWN_AREA);
	}
	app.SetGameHostOption( eGameHostOption_HasBeenInCreative, gameType == GameType::CREATIVE || levels[0]->getHasBeenInCreative() );
	app.SetGameHostOption( eGameHostOption_Structures, levels[0]->isGenerateMapFeatures() );

	if( s_bServerHalted || !g_NetworkManager.IsInSession() ) return false;

	// 4J - Make a new thread to do post processing
	InitializeCriticalSection(&m_postProcessCS);

	// 4J-PB - fix for 108310 - TCR #001 BAS Game Stability: TU12: Code: Compliance: Crash after creating world on "journey" seed.
	// Stack gets very deep with some sand tower falling, so increased the stacj to 256K from 128k on other platforms (was already set to that on PS3 and Orbis)

	m_postUpdateThread = new C4JThread(runPostUpdate, this, "Post processing", 256*1024);

	m_postUpdateTerminate = false;
	m_postUpdateThread->SetProcessor(CPU_CORE_POST_PROCESSING);
	m_postUpdateThread->SetPriority(THREAD_PRIORITY_ABOVE_NORMAL);
	m_postUpdateThread->Run();

	__int64 startTime = System::currentTimeMillis();

	// 4J Stu - Added this to temporarily make starting games on vita faster
#ifdef __PSVITA__
	int r = 48;
#else
	int r = 196;
#endif

	//  4J JEV: load gameRules.
	ConsoleSavePath filepath(GAME_RULE_SAVENAME);
	ConsoleSaveFile *csf = getLevel(0)->getLevelStorage()->getSaveFile();
	if( csf->doesFileExist(filepath) )
	{
		DWORD numberOfBytesRead;
		byteArray ba_gameRules;

		FileEntry *fe = csf->createFile(filepath);

		ba_gameRules.length = fe->getFileSize();
		ba_gameRules.data = new BYTE[ ba_gameRules.length ];

		csf->setFilePointer(fe,0,NULL,FILE_BEGIN);
		csf->readFile(fe, ba_gameRules.data, ba_gameRules.length, &numberOfBytesRead);
		assert(numberOfBytesRead == ba_gameRules.length);

		app.m_gameRules.loadGameRules(ba_gameRules.data, ba_gameRules.length);
		csf->closeHandle(fe);
	}

	__int64 lastTime = System::currentTimeMillis();
#ifdef _LARGE_WORLDS
	if(app.GetGameNewWorldSize() > levels[0]->getLevelData()->getXZSizeOld())
	{
		if(!app.GetGameNewWorldSizeUseMoat()) // check the moat settings to see if we should be overwriting the edge tiles
		{
			overwriteBordersForNewWorldSize(levels[0]);
		}
		// we're always overwriting hell edges
		int oldHellSize = levels[0]->getLevelData()->getXZHellSizeOld();
		overwriteHellBordersForNewWorldSize(levels[1], oldHellSize);
	}
#endif

	// 4J Stu - This loop is changed in 1.0.1 to only process the first level (ie the overworld), but I think we still want to do them all
	int i = 0;
	for (int i = 0; i < levels.length ; i++)
	{
		//        logger.info("Preparing start region for level " + i);
		if (i == 0 || GetDedicatedServerBool(settings, L"allow-nether", true))
		{
			ServerLevel *level = levels[i];
			if(levelChunksNeedConverted)
			{
				// 				storage->getSaveFile()->convertLevelChunks(level)
			}

#if 0
			__int64 lastStorageTickTime = System::currentTimeMillis();

			// Test code to enable full creation of levels at start up
			int halfsidelen = ( i == 0 ) ? 27 : 9;
			for( int x = -halfsidelen; x < halfsidelen; x++ )
			{
				for( int z = -halfsidelen; z < halfsidelen; z++ )
				{
					int total = halfsidelen * halfsidelen * 4;
					int pos = z + halfsidelen + ( ( x + halfsidelen ) * 2 * halfsidelen );
					mcprogress->progressStagePercentage((pos) * 100 / total);
					level->cache->create(x,z, true);	// 4J - added parameter to disable postprocessing here

					if( System::currentTimeMillis() - lastStorageTickTime > 50 )
					{
						CompressedTileStorage::tick();
						SparseLightStorage::tick();
						SparseDataStorage::tick();
						lastStorageTickTime = System::currentTimeMillis();
					}
				}
			}
#else
			__int64 lastStorageTickTime = System::currentTimeMillis();
			Pos *spawnPos = level->getSharedSpawnPos();

			int twoRPlusOne = r*2 + 1;
			int total = twoRPlusOne * twoRPlusOne;
			for (int x = -r; x <= r && running; x += 16)
			{
				for (int z = -r; z <= r && running; z += 16)
				{
					if( s_bServerHalted || !g_NetworkManager.IsInSession() )
					{
						delete spawnPos;
						m_postUpdateTerminate = true;
						postProcessTerminate(mcprogress);
						return false;
					}
					//					printf(">>>%d %d %d\n",i,x,z);
					//                    __int64 now = System::currentTimeMillis();
					//                    if (now < lastTime) lastTime = now;
					//                    if (now > lastTime + 1000)
					{
						int pos = (x + r) * twoRPlusOne + (z + 1);
						//                        setProgress(L"Preparing spawn area", (pos) * 100 / total);
						mcprogress->progressStagePercentage((pos+r) * 100 / total);
						//                        lastTime = now;
					}
					static int count = 0;
					PIXBeginNamedEvent(0,"Creating %d ", (count++)%8);
					level->cache->create((spawnPos->x + x) >> 4, (spawnPos->z + z) >> 4, true);	// 4J - added parameter to disable postprocessing here
					PIXEndNamedEvent();
					//                    while (level->updateLights() && running)
					//                        ;
					if( System::currentTimeMillis() - lastStorageTickTime > 50 )
					{
						CompressedTileStorage::tick();
						SparseLightStorage::tick();
						SparseDataStorage::tick();
						lastStorageTickTime = System::currentTimeMillis();
					}
				}
			}

			// 4J - removed this as now doing the recheckGaps call when each chunk is post-processed, so can happen on things outside of the spawn area too
#if 0
			// 4J - added this code to propagate lighting properly in the spawn area before we go sharing it with the local client or across the network
			for (int x = -r; x <= r && running; x += 16)
			{
				for (int z = -r; z <= r && running; z += 16)
				{
					PIXBeginNamedEvent(0,"Lighting gaps for %d %d",x,z);
					level->getChunkAt(spawnPos->x + x, spawnPos->z + z)->recheckGaps(true);
					PIXEndNamedEvent();
				}
			}
#endif

			delete spawnPos;
#endif
		}
	}
	//	printf("Main thread complete at %dms\n",System::currentTimeMillis() - startTime);

	// Wait for post processing, then lighting threads, to end (post-processing may make more lighting changes)
	m_postUpdateTerminate = true;

	postProcessTerminate(mcprogress);


	// stronghold position?
	if(levels[0]->dimension->id==0)
	{

		app.DebugPrintf("===================================\n");

		if(!levels[0]->getLevelData()->getHasStronghold())
		{
			int x,z;
			if(app.GetTerrainFeaturePosition(eTerrainFeature_Stronghold,&x,&z))
			{
				levels[0]->getLevelData()->setXStronghold(x);
				levels[0]->getLevelData()->setZStronghold(z);
				levels[0]->getLevelData()->setHasStronghold();

				app.DebugPrintf("=== FOUND stronghold in terrain features list\n");

			}
			else
			{
				// can't find the stronghold position in the terrain feature list. Do we have to run a post-process?
				app.DebugPrintf("=== Can't find stronghold in terrain features list\n");
			}
		}
		else
		{
			app.DebugPrintf("=== Leveldata has stronghold position\n");
		}
		app.DebugPrintf("===================================\n");
	}

	//	printf("Post processing complete at %dms\n",System::currentTimeMillis() - startTime);

	//	printf("Lighting complete at %dms\n",System::currentTimeMillis() - startTime);

	if( s_bServerHalted || !g_NetworkManager.IsInSession() ) return false;

	if( levels[1]->isNew )
	{
		levels[1]->save(true, mcprogress);
	}

	if( s_bServerHalted || !g_NetworkManager.IsInSession() ) return false;

	if( levels[2]->isNew )
	{
		levels[2]->save(true, mcprogress);
	}

	if( s_bServerHalted || !g_NetworkManager.IsInSession() ) return false;

	// 4J - added - immediately save newly created level, like single player game
	// 4J Stu - We also want to immediately save the tutorial
	if ( levels[0]->isNew )
		saveGameRules();

	if( levels[0]->isNew )
	{
		levels[0]->save(true, mcprogress);
	}

	if( s_bServerHalted || !g_NetworkManager.IsInSession() ) return false;

	if( levels[0]->isNew || levels[1]->isNew || levels[2]->isNew )
	{
#ifndef _WINDOWS64
		// On Windows64 we skip the automatic initial save so that choosing
		// "Exit without saving" on a new world does not leave an orphaned save folder.
		levels[0]->saveToDisc(mcprogress, false);
#endif
	}

	if( s_bServerHalted || !g_NetworkManager.IsInSession() ) return false;

	/*
	* int r = 24; for (int x = -r; x <= r; x++) {
	* setProgress("Preparing spawn area", (x + r) * 100 / (r + r + 1)); for (int z
	* = -r; z <= r; z++) { if (!running) return; level.cache.create((level.xSpawn
	* >> 4) + x, (level.zSpawn >> 4) + z); while (running && level.updateLights())
	* ; } }
	*/
	endProgress();

	return true;
}

#ifdef _LARGE_WORLDS
void MinecraftServer::overwriteBordersForNewWorldSize(ServerLevel* level)
{
	// recreate the chunks round the border (2 chunks or 32 blocks deep), deleting any player data from them
	app.DebugPrintf("Expanding level size\n");
	int oldSize = level->getLevelData()->getXZSizeOld();
	// top
	int minVal = -oldSize/2;
	int maxVal = (oldSize/2)-1;
	for(int xVal = minVal; xVal <= maxVal; xVal++)
	{
		int zVal = minVal;
		level->cache->overwriteLevelChunkFromSource(xVal, zVal);
		level->cache->overwriteLevelChunkFromSource(xVal, zVal+1);
	}
	// bottom
	for(int xVal = minVal; xVal <= maxVal; xVal++)
	{
		int zVal = maxVal;
		level->cache->overwriteLevelChunkFromSource(xVal, zVal);
		level->cache->overwriteLevelChunkFromSource(xVal, zVal-1);
	}
	// left
	for(int zVal = minVal; zVal <= maxVal; zVal++)
	{
		int xVal = minVal;
		level->cache->overwriteLevelChunkFromSource(xVal, zVal);
		level->cache->overwriteLevelChunkFromSource(xVal+1, zVal);
	}
	// right
	for(int zVal = minVal; zVal <= maxVal; zVal++)
	{
		int xVal = maxVal;
		level->cache->overwriteLevelChunkFromSource(xVal, zVal);
		level->cache->overwriteLevelChunkFromSource(xVal-1, zVal);
	}
}

void MinecraftServer::overwriteHellBordersForNewWorldSize(ServerLevel* level, int oldHellSize)
{
	// recreate the chunks round the border (1 chunk or 16 blocks deep), deleting any player data from them
	app.DebugPrintf("Expanding level size\n");
	// top
	int minVal = -oldHellSize/2;
	int maxVal = (oldHellSize/2)-1;
	for(int xVal = minVal; xVal <= maxVal; xVal++)
	{
		int zVal = minVal;
		level->cache->overwriteHellLevelChunkFromSource(xVal, zVal, minVal, maxVal);
	}
	// bottom
	for(int xVal = minVal; xVal <= maxVal; xVal++)
	{
		int zVal = maxVal;
		level->cache->overwriteHellLevelChunkFromSource(xVal, zVal, minVal, maxVal);
	}
	// left
	for(int zVal = minVal; zVal <= maxVal; zVal++)
	{
		int xVal = minVal;
		level->cache->overwriteHellLevelChunkFromSource(xVal, zVal, minVal, maxVal);
	}
	// right
	for(int zVal = minVal; zVal <= maxVal; zVal++)
	{
		int xVal = maxVal;
		level->cache->overwriteHellLevelChunkFromSource(xVal, zVal, minVal, maxVal);
	}
}

#endif

void MinecraftServer::setProgress(const wstring& status, int progress)
{
	progressStatus = status;
	this->progress = progress;
	//    logger.info(status + ": " + progress + "%");
}

void MinecraftServer::endProgress()
{
	progressStatus = L"";
	this->progress = 0;
}

void MinecraftServer::saveAllChunks()
{
	//    logger.info("Saving chunks");
	for (unsigned int i = 0; i < levels.length; i++)
	{
		// 4J Stu - Due to the way save mounting is handled on XboxOne, we can actually save after the player has signed out.
#ifndef _XBOX_ONE
		if( m_bPrimaryPlayerSignedOut ) break;
#endif
		// 4J Stu - Save the levels in reverse order so we don't overwrite the level.dat
		// with the data from the nethers leveldata.
		// Fix for #7418 - Functional: Gameplay: Saving after sleeping in a bed will place player at nighttime when restarting.
		ServerLevel *level = levels[levels.length - 1 - i];
		if( level )	// 4J - added check as level can be NULL if we end up in stopServer really early on due to network failure
		{
			level->save(true, Minecraft::GetInstance()->progressRenderer);

			// Only close the level storage when we have saved the last level, otherwise we need to recreate the region files
			// when saving the next levels
			if( i == (levels.length - 1))
			{
				level->closeLevelStorage();
			}
		}
	}
}

// 4J-JEV: Added
void MinecraftServer::saveGameRules()
{
#ifndef _CONTENT_PACKAGE
	if(app.DebugSettingsOn() && app.GetGameSettingsDebugMask(ProfileManager.GetPrimaryPad())&(1L<<eDebugSetting_DistributableSave))
	{
		// Do nothing
	}
	else
#endif
	{
		byteArray ba;
		ba.data = NULL;
		app.m_gameRules.saveGameRules( &ba.data, &ba.length );

		if (ba.data != NULL)
		{
			ConsoleSaveFile *csf = getLevel(0)->getLevelStorage()->getSaveFile();
			FileEntry *fe = csf->createFile(ConsoleSavePath(GAME_RULE_SAVENAME));
			csf->setFilePointer(fe, 0, NULL, FILE_BEGIN);
			DWORD length;
			csf->writeFile(fe, ba.data, ba.length, &length );

			delete [] ba.data;

			csf->closeHandle(fe);
		}
	}
}

void MinecraftServer::Suspend()
{
	PIXBeginNamedEvent(0,"Suspending server");
	m_suspending = true;
	// Get the frequency of the timer
	LARGE_INTEGER qwTicksPerSec, qwTime, qwNewTime, qwDeltaTime;
	float fElapsedTime = 0.0f;
	QueryPerformanceFrequency( &qwTicksPerSec );
	float fSecsPerTick = 1.0f / (float)qwTicksPerSec.QuadPart;
	// Save the start time
	QueryPerformanceCounter( &qwTime );
	if(m_bLoaded && ProfileManager.IsFullVersion() && (!StorageManager.GetSaveDisabled()))
	{
		if (players != NULL)
		{
			players->saveAll(NULL);
		}
		for (unsigned int j = 0; j < levels.length; j++)
		{
			if( s_bServerHalted ) break;
			// 4J Stu - Save the levels in reverse order so we don't overwrite the level.dat
			// with the data from the nethers leveldata.
			// Fix for #7418 - Functional: Gameplay: Saving after sleeping in a bed will place player at nighttime when restarting.
			ServerLevel *level = levels[levels.length - 1 - j];
			level->Suspend();
		}
		if( !s_bServerHalted )
		{
			saveGameRules();
			levels[0]->saveToDisc(NULL, true);
		}
	}
	QueryPerformanceCounter( &qwNewTime );

	qwDeltaTime.QuadPart = qwNewTime.QuadPart - qwTime.QuadPart;
	fElapsedTime = fSecsPerTick * ((FLOAT)(qwDeltaTime.QuadPart));

	// 4J-JEV: Flush stats and call PlayerSessionExit.
	for (int iPad = 0; iPad < XUSER_MAX_COUNT; iPad++)
	{
		if (ProfileManager.IsSignedIn(iPad))
		{
			TelemetryManager->RecordPlayerSessionExit(iPad, DisconnectPacket::eDisconnect_Quitting);
		}
	}

	m_suspending = false;
	app.DebugPrintf("Suspend server: Elapsed time %f\n", fElapsedTime);
	PIXEndNamedEvent();
}

bool MinecraftServer::IsSuspending()
{
	return m_suspending;
}

void MinecraftServer::stopServer(bool didInit)
{

	// 4J-PB - need to halt the rendering of the data, since we're about to remove it
#ifdef __PS3__
	if( ShutdownManager::ShouldRun(ShutdownManager::eServerThread )	)		// This thread will take itself out if we are shutting down
#endif
	{
		Minecraft::GetInstance()->gameRenderer->DisableUpdateThread();
	}

	connection->stop();

	app.DebugPrintf("Stopping server\n");
	//    logger.info("Stopping server");
	// 4J-PB - If the primary player has signed out, then don't attempt to save anything

	// also need to check for a profile switch here - primary player signs out, and another player signs in before dismissing the dash
#ifdef _DURANGO
	// On Durango check if the primary user is signed in OR mid-sign-out
	if(ProfileManager.GetUser(0, true) != nullptr)
#else
	if((m_bPrimaryPlayerSignedOut==false) && ProfileManager.IsSignedIn(ProfileManager.GetPrimaryPad()))
#endif
	{
#if defined(_XBOX_ONE) || defined(__ORBIS__)
		// Always save on exit! Except if saves are disabled.
		if(!saveOnExitAnswered()) m_saveOnExit = true;
#endif
		// if trial version or saving is disabled, then don't save anything. Also don't save anything if we didn't actually get through the server initialisation.
		if(m_saveOnExit && ProfileManager.IsFullVersion() && (!StorageManager.GetSaveDisabled()) && didInit)
		{
			if (players != NULL)
			{
				players->saveAll(Minecraft::GetInstance()->progressRenderer, true);
			}
			// 4J Stu - Save the levels in reverse order so we don't overwrite the level.dat
			// with the data from the nethers leveldata.
			// Fix for #7418 - Functional: Gameplay: Saving after sleeping in a bed will place player at nighttime when restarting.
			//for (unsigned int i = levels.length - 1; i >= 0; i--)
			//{
			//	ServerLevel *level = levels[i];
			//	if (level != NULL)
			//	{
			saveAllChunks();
			//	}
			//}

			saveGameRules();
			app.m_gameRules.unloadCurrentGameRules();
			if( levels[0] != NULL )		// This can be null if stopServer happens very quickly due to network error
			{
				levels[0]->saveToDisc(Minecraft::GetInstance()->progressRenderer, false);
			}
		}
	}
	// reset the primary player signout flag
	m_bPrimaryPlayerSignedOut=false;
	s_bServerHalted = false;

	// On Durango/Orbis, we need to wait for all the asynchronous saving processes to complete before destroying the levels, as that will ultimately delete
	// the directory level storage & therefore the ConsoleSaveSplit instance, which needs to be around until all the sub files have completed saving.
#if defined(_DURANGO) || defined(__ORBIS__) || defined(__PSVITA__)
	while(StorageManager.GetSaveState() != C4JStorage::ESaveGame_Idle )
	{
		Sleep(10);
	}
#endif

	// 4J-PB remove the server levels
	unsigned int iServerLevelC=levels.length;
	for (unsigned int i = 0; i < iServerLevelC; i++)
	{
		if(levels[i]!=NULL)
		{
			delete levels[i];
			levels[i] = NULL;
		}
	}

#if defined(__PS3__) || defined(__ORBIS__)
	// Clear the update flags as it's possible they could be out of sync, causing a crash when starting a new world after the first new level ticks
	// Fix for PS3 #1538 - [IN GAME] If the user 'Exit without saving' from inside the Nether or The End, the title can hang when loading back into the save.
#endif

	delete connection;
	connection = NULL;
	delete players;
	players = NULL;
	delete settings;
	settings = NULL;

	g_NetworkManager.ServerStopped();
}

void MinecraftServer::halt()
{
	running = false;
}

void MinecraftServer::setMaxBuildHeight(int maxBuildHeight)
{
	this->maxBuildHeight = maxBuildHeight;
}

int MinecraftServer::getMaxBuildHeight()
{
	return maxBuildHeight;
}

PlayerList *MinecraftServer::getPlayers()
{
	return players;
}

void MinecraftServer::setPlayers(PlayerList *players)
{
	this->players = players;
}

ServerConnection *MinecraftServer::getConnection()
{
	return connection;
}

bool MinecraftServer::isAnimals()
{
	return animals;
}

void MinecraftServer::setAnimals(bool animals)
{
	this->animals = animals;
}

bool MinecraftServer::isNpcsEnabled()
{
	return npcs;
}

void MinecraftServer::setNpcsEnabled(bool npcs)
{
	this->npcs = npcs;
}

bool MinecraftServer::isPvpAllowed()
{
	return pvp;
}

void MinecraftServer::setPvpAllowed(bool pvp)
{
	this->pvp = pvp;
}

bool MinecraftServer::isFlightAllowed()
{
	return allowFlight;
}

void MinecraftServer::setFlightAllowed(bool allowFlight)
{
	this->allowFlight = allowFlight;
}

bool MinecraftServer::isCommandBlockEnabled()
{
	return false; //settings.getBoolean("enable-command-block", false);
}

bool MinecraftServer::isNetherEnabled()
{
	return true; //settings.getBoolean("allow-nether", true);
}

bool MinecraftServer::isHardcore()
{
	return false;
}

int MinecraftServer::getOperatorUserPermissionLevel()
{
	return Command::LEVEL_OWNERS; //settings.getInt("op-permission-level", Command.LEVEL_OWNERS);
}

CommandDispatcher *MinecraftServer::getCommandDispatcher()
{
	return commandDispatcher;
}

Pos *MinecraftServer::getCommandSenderWorldPosition()
{
	return new Pos(0, 0, 0);
}

Level *MinecraftServer::getCommandSenderWorld()
{
	return levels[0];
}

int MinecraftServer::getSpawnProtectionRadius()
{
	return 16;
}

bool MinecraftServer::isUnderSpawnProtection(Level *level, int x, int y, int z, shared_ptr<Player> player)
{
	if (level->dimension->id != 0) return false;
	//if (getPlayers()->getOps()->empty()) return false;
	if (getPlayers()->isOp(player->getName())) return false;
	if (getSpawnProtectionRadius() <= 0) return false;

	Pos *spawnPos = level->getSharedSpawnPos();
	int xd = Mth::abs(x - spawnPos->x);
	int zd = Mth::abs(z - spawnPos->z);
	int dist = max(xd, zd);

	return dist <= getSpawnProtectionRadius();
}

void MinecraftServer::setForceGameType(bool forceGameType)
{
	this->forceGameType = forceGameType;
}

bool MinecraftServer::getForceGameType()
{
	return forceGameType;
}

__int64 MinecraftServer::getCurrentTimeMillis()
{
	return System::currentTimeMillis();
}

int MinecraftServer::getPlayerIdleTimeout()
{
	return playerIdleTimeout;
}

void MinecraftServer::setPlayerIdleTimeout(int playerIdleTimeout)
{
	this->playerIdleTimeout = playerIdleTimeout;
}

extern int c0a, c0b, c1a, c1b, c1c, c2a, c2b;
void MinecraftServer::run(__int64 seed, void *lpParameter)
{
	NetworkGameInitData *initData = NULL;
	DWORD initSettings = 0;
	bool findSeed = false;
	if(lpParameter != NULL)
	{
		initData = (NetworkGameInitData *)lpParameter;
		initSettings = app.GetGameHostOption(eGameHostOption_All);
		findSeed = initData->findSeed;
		m_texturePackId = initData->texturePackId;
	}
	//    try {		// 4J - removed try/catch/finally
	bool didInit = false;
	if (initServer(seed, initData, initSettings,findSeed))
	{
		didInit = true;
		ServerLevel *levelNormalDimension = levels[0];
		// 4J-PB - Set the Stronghold position in the leveldata if there isn't one in there
		Minecraft *pMinecraft = Minecraft::GetInstance();
		LevelData *pLevelData=levelNormalDimension->getLevelData();

		if(pLevelData && pLevelData->getHasStronghold()==false)
		{
			int x,z;
			if(app.GetTerrainFeaturePosition(eTerrainFeature_Stronghold,&x,&z))
			{
				pLevelData->setXStronghold(x);
				pLevelData->setZStronghold(z);
				pLevelData->setHasStronghold();
			}
		}

		__int64 lastTime = getCurrentTimeMillis();
		__int64 unprocessedTime = 0;
		while (running && !s_bServerHalted)
		{
			__int64 now = getCurrentTimeMillis();

			// 4J Stu - When we pause the server, we don't want to count that as time passed
			// 4J Stu - TU-1 hotifx - Remove this line. We want to make sure that we tick connections at the proper rate when paused
			//Fix for #13191 - The host of a game can get a message informing them that the connection to the server has been lost
			//if(m_isServerPaused) lastTime = now;

			__int64 passedTime = now - lastTime;
			if (passedTime > MS_PER_TICK * 40)
			{
				//                logger.warning("Can't keep up! Did the system time change, or is the server overloaded?");
				passedTime = MS_PER_TICK * 40;
			}
			if (passedTime < 0)
			{
				//                logger.warning("Time ran backwards! Did the system time change?");
				passedTime = 0;
			}
			unprocessedTime += passedTime;
			lastTime = now;

			// 4J Added ability to pause the server
			if( !m_isServerPaused )
			{
				bool didTick = false;
				if (levels[0]->allPlayersAreSleeping())
				{
					tick();
					unprocessedTime = 0;
				}
				else
				{
					//					int tickcount = 0;
					//					__int64 beforeall = System::currentTimeMillis();
					while (unprocessedTime > MS_PER_TICK)
					{
						unprocessedTime -= MS_PER_TICK;
						chunkPacketManagement_PreTick();
//						__int64 before = System::currentTimeMillis();
						tick();
//						__int64 after = System::currentTimeMillis();
//						PIXReportCounter(L"Server time",(float)(after-before));

						chunkPacketManagement_PostTick();
					}
//					__int64 afterall = System::currentTimeMillis();
//					PIXReportCounter(L"Server time all",(float)(afterall-beforeall));
//					PIXReportCounter(L"Server ticks",(float)tickcount);
				}
			}
			else
			{
				// 4J Stu - TU1-hotfix
				//Fix for #13191 - The host of a game can get a message informing them that the connection to the server has been lost
				// The connections should tick at the same frequency even when paused
				while (unprocessedTime > MS_PER_TICK)
				{
					unprocessedTime -= MS_PER_TICK;
					// Keep ticking the connections to stop them timing out
					connection->tick();
				}
			}
			if(MinecraftServer::setTimeAtEndOfTick)
			{
				MinecraftServer::setTimeAtEndOfTick = false;
				for (unsigned int i = 0; i < levels.length; i++)
				{
					//					if (i == 0 || settings->getBoolean(L"allow-nether", true))		// 4J removed - we always have nether
					{
						ServerLevel *level = levels[i];
						level->setGameTime( MinecraftServer::setTime );
					}
				}
			}
			if(MinecraftServer::setTimeOfDayAtEndOfTick)
			{
				MinecraftServer::setTimeOfDayAtEndOfTick = false;
				for (unsigned int i = 0; i < levels.length; i++)
				{
					if (i == 0 || GetDedicatedServerBool(settings, L"allow-nether", true))
					{
						ServerLevel *level = levels[i];
						level->setDayTime( MinecraftServer::setTimeOfDay );
					}
				}
			}

			// Process delayed actions
			eXuiServerAction eAction;
			LPVOID param;
			for(int i=0;i<XUSER_MAX_COUNT;i++)
			{
				eAction = app.GetXuiServerAction(i);
				param = app.GetXuiServerActionParam(i);

				switch(eAction)
				{
				case eXuiServerAction_AutoSaveGame:
#if defined(_XBOX_ONE) || defined(__ORBIS__)
					{
						PIXBeginNamedEvent(0,"Autosave");

						// Get the frequency of the timer
						LARGE_INTEGER qwTicksPerSec, qwTime, qwNewTime, qwDeltaTime;
						float fElapsedTime = 0.0f;
						QueryPerformanceFrequency( &qwTicksPerSec );
						float fSecsPerTick = 1.0f / (float)qwTicksPerSec.QuadPart;

						// Save the start time
						QueryPerformanceCounter( &qwTime );

						if (players != NULL)
						{
							players->saveAll(NULL);
						}

						for (unsigned int j = 0; j < levels.length; j++)
						{
							if( s_bServerHalted ) break;
							// 4J Stu - Save the levels in reverse order so we don't overwrite the level.dat
							// with the data from the nethers leveldata.
							// Fix for #7418 - Functional: Gameplay: Saving after sleeping in a bed will place player at nighttime when restarting.
							ServerLevel *level = levels[levels.length - 1 - j];
							PIXBeginNamedEvent(0, "Saving level %d",levels.length - 1 - j);
							level->save(false, NULL, true);
							PIXEndNamedEvent();
						}
						if( !s_bServerHalted )
						{
							PIXBeginNamedEvent(0,"Saving game rules");
							saveGameRules();
							PIXEndNamedEvent();

							PIXBeginNamedEvent(0,"Save to disc");
							levels[0]->saveToDisc(Minecraft::GetInstance()->progressRenderer, true);
							PIXEndNamedEvent();
						}
						PIXEndNamedEvent();

						QueryPerformanceCounter( &qwNewTime );
						qwDeltaTime.QuadPart = qwNewTime.QuadPart - qwTime.QuadPart;
						fElapsedTime = fSecsPerTick * ((FLOAT)(qwDeltaTime.QuadPart));
						app.DebugPrintf("Autosave: Elapsed time %f\n", fElapsedTime);
					}
					break;
#endif
				case eXuiServerAction_SaveGame:
					app.EnterSaveNotificationSection();
					if (players != NULL)
					{
						players->saveAll(Minecraft::GetInstance()->progressRenderer);
					}

					players->broadcastAll( shared_ptr<UpdateProgressPacket>( new UpdateProgressPacket(20) ) );

					for (unsigned int j = 0; j < levels.length; j++)
					{
						if( s_bServerHalted ) break;
						// 4J Stu - Save the levels in reverse order so we don't overwrite the level.dat
						// with the data from the nethers leveldata.
						// Fix for #7418 - Functional: Gameplay: Saving after sleeping in a bed will place player at nighttime when restarting.
						ServerLevel *level = levels[levels.length - 1 - j];
						level->save(true, Minecraft::GetInstance()->progressRenderer, (eAction==eXuiServerAction_AutoSaveGame));

						players->broadcastAll( shared_ptr<UpdateProgressPacket>( new UpdateProgressPacket(33 + (j*33) ) ) );
					}
					if( !s_bServerHalted )
					{
						saveGameRules();

						levels[0]->saveToDisc(Minecraft::GetInstance()->progressRenderer, (eAction==eXuiServerAction_AutoSaveGame));
					}
					app.LeaveSaveNotificationSection();
					break;
				case eXuiServerAction_DropItem:
					// Find the player, and drop the id at their feet
					{
						shared_ptr<ServerPlayer> player = players->players.at(0);
						size_t id = (size_t) param;
						player->drop( shared_ptr<ItemInstance>( new ItemInstance(id, 1, 0 ) ) );
					}
					break;
				case eXuiServerAction_SpawnMob:
					{
						shared_ptr<ServerPlayer> player = players->players.at(0);
						eINSTANCEOF factory = (eINSTANCEOF)((size_t)param);
						shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(EntityIO::newByEnumType(factory,player->level ));
						mob->moveTo(player->x+1, player->y, player->z+1, player->level->random->nextFloat() * 360, 0);
						mob->setDespawnProtected();		// 4J added, default to being protected against despawning (has to be done after initial position is set)
						player->level->addEntity(mob);
					}
					break;
				case eXuiServerAction_PauseServer:
					m_isServerPaused = ( (size_t) param == TRUE );
					if( m_isServerPaused )
					{
						m_serverPausedEvent->Set();
					}
					break;
				case eXuiServerAction_ToggleRain:
					{
						bool isRaining = levels[0]->getLevelData()->isRaining();
						levels[0]->getLevelData()->setRaining(!isRaining);
						levels[0]->getLevelData()->setRainTime(levels[0]->random->nextInt(Level::TICKS_PER_DAY * 7) + Level::TICKS_PER_DAY / 2);
					}
					break;
				case eXuiServerAction_ToggleThunder:
					{
						bool isThundering = levels[0]->getLevelData()->isThundering();
						levels[0]->getLevelData()->setThundering(!isThundering);
						levels[0]->getLevelData()->setThunderTime(levels[0]->random->nextInt(Level::TICKS_PER_DAY * 7) + Level::TICKS_PER_DAY / 2);
					}
					break;
				case eXuiServerAction_ServerSettingChanged_Gamertags:
					players->broadcastAll( shared_ptr<ServerSettingsChangedPacket>( new ServerSettingsChangedPacket( ServerSettingsChangedPacket::HOST_OPTIONS, app.GetGameHostOption(eGameHostOption_Gamertags)) ) );
					break;
				case eXuiServerAction_ServerSettingChanged_BedrockFog:
					players->broadcastAll( shared_ptr<ServerSettingsChangedPacket>( new ServerSettingsChangedPacket( ServerSettingsChangedPacket::HOST_IN_GAME_SETTINGS, app.GetGameHostOption(eGameHostOption_All)) ) );
					break;

				case eXuiServerAction_ServerSettingChanged_Difficulty:
					players->broadcastAll( shared_ptr<ServerSettingsChangedPacket>( new ServerSettingsChangedPacket( ServerSettingsChangedPacket::HOST_DIFFICULTY, Minecraft::GetInstance()->options->difficulty) ) );
					break;
				case eXuiServerAction_ExportSchematic:
#ifndef _CONTENT_PACKAGE
					app.EnterSaveNotificationSection();

					//players->broadcastAll( shared_ptr<UpdateProgressPacket>( new UpdateProgressPacket(20) ) );

					if( !s_bServerHalted )
					{
						ConsoleSchematicFile::XboxSchematicInitParam *initData = (ConsoleSchematicFile::XboxSchematicInitParam *)param;
#ifdef _XBOX
						File targetFileDir(File::pathRoot + File::pathSeparator + L"Schematics");
#else
						File targetFileDir(L"Schematics");
#endif
						if(!targetFileDir.exists())	targetFileDir.mkdir();

						wchar_t filename[128];
						swprintf(filename,128,L"%ls%dx%dx%d.sch",initData->name,(initData->endX - initData->startX + 1), (initData->endY - initData->startY + 1), (initData->endZ - initData->startZ + 1));

						File dataFile = File( targetFileDir, wstring(filename) );
						if(dataFile.exists()) dataFile._delete();
						FileOutputStream fos = FileOutputStream(dataFile);
						DataOutputStream dos = DataOutputStream(&fos);
						ConsoleSchematicFile::generateSchematicFile(&dos, levels[0], initData->startX, initData->startY, initData->startZ, initData->endX, initData->endY, initData->endZ, initData->bSaveMobs, initData->compressionType);
						dos.close();

						delete initData;
					}
					app.LeaveSaveNotificationSection();
#endif
					break;
				case eXuiServerAction_SetCameraLocation:
#ifndef _CONTENT_PACKAGE
					{
						DebugSetCameraPosition *pos = (DebugSetCameraPosition *)param;

						app.DebugPrintf(	"DEBUG: Player=%i\n", pos->player );
						app.DebugPrintf(	"DEBUG: Teleporting to pos=(%f.2, %f.2, %f.2), looking at=(%f.2,%f.2)\n",
							pos->m_camX, pos->m_camY, pos->m_camZ,
							pos->m_yRot, pos->m_elev
							);

						shared_ptr<ServerPlayer> player = players->players.at(pos->player);
						player->debug_setPosition(	pos->m_camX, pos->m_camY, pos->m_camZ,
							pos->m_yRot, pos->m_elev	);

						// Doesn't work
						//player->setYHeadRot(pos->m_yRot);
						//player->absMoveTo(pos->m_camX, pos->m_camY, pos->m_camZ, pos->m_yRot, pos->m_elev);
					}
#endif
					break;
				}

				app.SetXuiServerAction(i,eXuiServerAction_Idle);
			}

			Sleep(1);
		}
	}
	//else
	//{
	//     while (running)
	//	{
	//        handleConsoleInputs();
	//		Sleep(10);
	//    }
	//}
#if 0
} catch (Throwable t) {
	t.printStackTrace();
	logger.log(Level.SEVERE, "Unexpected exception", t);
	while (running) {
		handleConsoleInputs();
		try {
			Thread.sleep(10);
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		}
	}
} finally {
	try {
		stopServer();
		stopped = true;
	} catch (Throwable t) {
		t.printStackTrace();
	} finally {
		System::exit(0);
	}
}
#endif

	// 4J Stu - Stop the server when the loops complete, as the finally would do
	stopServer(didInit);
	stopped = true;
}

void MinecraftServer::broadcastStartSavingPacket()
{
	players->broadcastAll( shared_ptr<GameEventPacket>( new GameEventPacket(GameEventPacket::START_SAVING, 0) ) );;
}

void MinecraftServer::broadcastStopSavingPacket()
{
	if( !s_bServerHalted )
	{
		players->broadcastAll( shared_ptr<GameEventPacket>( new GameEventPacket(GameEventPacket::STOP_SAVING, 0) ) );;
	}
}

void MinecraftServer::tick()
{
	vector<wstring> toRemove;
    for ( auto& it : ironTimers )
    {
		int t = it.second;
		if (t > 0)
		{
			ironTimers[it.first] = t - 1;
		}
		else
		{
			toRemove.push_back(it.first);
		}
	}
	for (const auto& i : toRemove)
	{
		ironTimers.erase(i);
	}

	AABB::resetPool();
	Vec3::resetPool();

	tickCount++;

	// 4J We need to update client difficulty levels based on the servers
	Minecraft *pMinecraft = Minecraft::GetInstance();
	// 4J-PB - sending this on the host changing the difficulty in the menus
	/*	if(m_lastSentDifficulty != pMinecraft->options->difficulty)
	{
	m_lastSentDifficulty = pMinecraft->options->difficulty;
	players->broadcastAll( shared_ptr<ServerSettingsChangedPacket>( new ServerSettingsChangedPacket( ServerSettingsChangedPacket::HOST_DIFFICULTY, pMinecraft->options->difficulty) ) );
	}*/

	for (unsigned int i = 0; i < levels.length; i++)
	{
		//        if (i == 0 || settings->getBoolean(L"allow-nether", true))		// 4J removed - we always have nether
		{
			ServerLevel *level = levels[i];

			// 4J Stu - We set the levels difficulty based on the minecraft options
			level->difficulty = app.GetGameHostOption(eGameHostOption_Difficulty); //pMinecraft->options->difficulty;

#if DEBUG_SERVER_DONT_SPAWN_MOBS
			level->setSpawnSettings(false, false);
#else
			level->setSpawnSettings(level->difficulty > 0 && !Minecraft::GetInstance()->isTutorial(), animals);
#endif

			if (tickCount % 20 == 0)
			{
				players->broadcastAll( shared_ptr<SetTimePacket>( new SetTimePacket(level->getGameTime(), level->getDayTime(), level->getGameRules()->getBoolean(GameRules::RULE_DAYLIGHT) ) ), level->dimension->id);
			}
			// #ifndef __PS3__
			static __int64 stc = 0;
			__int64 st0 = System::currentTimeMillis();
			PIXBeginNamedEvent(0,"Level tick %d",i);
			((Level *)level)->tick();
			__int64 st1 = System::currentTimeMillis();
			PIXEndNamedEvent();
			PIXBeginNamedEvent(0,"Update lights %d",i);

			__int64 st2 = System::currentTimeMillis();
			PIXEndNamedEvent();
			PIXBeginNamedEvent(0,"Entity tick %d",i);
			// 4J added to stop ticking entities in levels when players are not in those levels.
			// Note: now changed so that we also tick if there are entities to be removed, as this also happens as a result of calling tickEntities. If we don't do this, then the
			// entities get removed at the first point that there is a player count in the level - this has been causing a problem when going from normal dimension -> nether -> normal,
			// as the player is getting flagged as to be removed (from the normal dimension) when going to the nether, but Actually gets removed only when it returns
			if( ( players->getPlayerCount(level) > 0) || ( level->hasEntitiesToRemove() ) )
			{
#ifdef __PSVITA__
				// AP - the PlayerList->viewDistance initially starts out at 3 to make starting a level speedy
				// the problem with this is that spawned monsters are always generated on the edge of the known map
				// which means they wont process (unless they are surrounded by 2 visible chunks). This means
				// they wont checkDespawn so they are NEVER removed which results in monsters not spawning.
				// This bit of hack will modify the view distance once the level is up and running.
				int newViewDistance = 5;
				level->getServer()->getPlayers()->setViewDistance(newViewDistance);
				level->getTracker()->updateMaxRange();
				level->getChunkMap()->setRadius(level->getServer()->getPlayers()->getViewDistance());
#endif
				level->tickEntities();
			}
			PIXEndNamedEvent();

			PIXBeginNamedEvent(0,"Entity tracker tick");
			level->getTracker()->tick();
			PIXEndNamedEvent();

			__int64 st3 = System::currentTimeMillis();
			//			printf(">>>>>>>>>>>>>>>>>>>>>> Tick %d %d %d : %d\n", st1 - st0, st2 - st1, st3 - st2, st0 - stc );
			stc = st0;
			// #endif// __PS3__
		}
	}
	Entity::tickExtraWandering();	// 4J added

	PIXBeginNamedEvent(0,"Connection tick");
	connection->tick();
	PIXEndNamedEvent();
	PIXBeginNamedEvent(0,"Players tick");
	players->tick();
	PIXEndNamedEvent();

	// 4J - removed
#if 0
	for (int i = 0; i < tickables.size(); i++) {
		tickables.get(i)-tick();
	}
#endif

	//    try {		// 4J - removed try/catch
	handleConsoleInputs();
	//    } catch (Exception e) {
	//        logger.log(Level.WARNING, "Unexpected exception while parsing console command", e);
	//    }
}

void MinecraftServer::handleConsoleInput(const wstring& msg, ConsoleInputSource *source)
{
	EnterCriticalSection(&m_consoleInputCS);
	consoleInput.push_back(new ConsoleInput(msg, source));
	LeaveCriticalSection(&m_consoleInputCS);
}

void MinecraftServer::handleConsoleInputs()
{
	vector<ConsoleInput *> pendingInputs;
	EnterCriticalSection(&m_consoleInputCS);
	pendingInputs.swap(consoleInput);
	LeaveCriticalSection(&m_consoleInputCS);

	for (size_t i = 0; i < pendingInputs.size(); ++i)
	{
		ConsoleInput *input = pendingInputs[i];
		ExecuteConsoleCommand(this, input->msg);
		delete input;
	}
}

void MinecraftServer::main(__int64 seed, void *lpParameter)
{
#if __PS3__
	ShutdownManager::HasStarted(ShutdownManager::eServerThread );
#endif
	server = new MinecraftServer();
	server->run(seed, lpParameter);
	delete server;
	server = NULL;
	ShutdownManager::HasFinished(ShutdownManager::eServerThread );
}

void MinecraftServer::HaltServer(bool bPrimaryPlayerSignedOut)
{
	s_bServerHalted = true;
	if( server != NULL )
	{
		m_bPrimaryPlayerSignedOut=bPrimaryPlayerSignedOut;
		server->halt();
	}
}

File *MinecraftServer::getFile(const wstring& name)
{
	return new File(name);
}

void MinecraftServer::info(const wstring& string)
{
	PrintConsoleLine(L"[INFO] ", string);
}

void MinecraftServer::warn(const wstring& string)
{
	PrintConsoleLine(L"[WARN] ", string);
}

wstring MinecraftServer::getConsoleName()
{
	return L"CONSOLE";
}

ServerLevel *MinecraftServer::getLevel(int dimension)
{
	if (dimension == -1) return levels[1];
	else if (dimension == 1) return levels[2];
	else return levels[0];
}

// 4J added
void MinecraftServer::setLevel(int dimension, ServerLevel *level)
{
	if (dimension == -1) levels[1] = level;
	else if (dimension == 1) levels[2] = level;
	else levels[0] = level;
}

#if defined _ACK_CHUNK_SEND_THROTTLING
bool MinecraftServer::chunkPacketManagement_CanSendTo(INetworkPlayer *player)
{
	if( s_hasSentEnoughPackets ) return false;
	if( player == NULL ) return false;

	for( int i = 0; i < s_sentTo.size(); i++ )
	{
		if( s_sentTo[i]->IsSameSystem(player) )
		{
			return false;
		}
	}

#if defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
	return ( player->GetOutstandingAckCount() < 3 );
#else
	return ( player->GetOutstandingAckCount() < 2 );
#endif
}

void MinecraftServer::chunkPacketManagement_DidSendTo(INetworkPlayer *player)
{
	__int64 currentTime = System::currentTimeMillis();

	if( ( currentTime - s_tickStartTime ) >= MAX_TICK_TIME_FOR_PACKET_SENDS )
	{
		s_hasSentEnoughPackets = true;
//		app.DebugPrintf("Sending, setting enough packet flag: %dms\n",currentTime - s_tickStartTime);
	}
	else
	{
//		app.DebugPrintf("Sending, more time: %dms\n",currentTime - s_tickStartTime);
	}

	player->SentChunkPacket();

	s_sentTo.push_back(player);
}

void MinecraftServer::chunkPacketManagement_PreTick()
{
//	app.DebugPrintf("*************************************************************************************************************************************************************************\n");
	s_hasSentEnoughPackets = false;
	s_tickStartTime = System::currentTimeMillis();
	s_sentTo.clear();

	vector< shared_ptr<PlayerConnection> > *players = connection->getPlayers();

	if( players->size() )
	{
		vector< shared_ptr<PlayerConnection> > playersOrig = *players;
		players->clear();

		do
		{
			int longestTime = 0;
			auto playerConnectionBest = playersOrig.begin();
			for( auto it = playersOrig.begin(); it != playersOrig.end(); it++)
			{
				int thisTime = 0;
				INetworkPlayer *np = (*it)->getNetworkPlayer();
				if( np )
				{
					thisTime = np->GetTimeSinceLastChunkPacket_ms();
				}

				if( thisTime > longestTime )
				{
					playerConnectionBest = it;
					longestTime = thisTime;
				}
			}
			players->push_back(*playerConnectionBest);
			playersOrig.erase(playerConnectionBest);
		} while ( playersOrig.size() > 0 );
	}
}

void MinecraftServer::chunkPacketManagement_PostTick()
{
}

#else
// 4J Added
bool MinecraftServer::chunkPacketManagement_CanSendTo(INetworkPlayer *player)
{
	if( player == NULL ) return false;

	int time = GetTickCount();
	if( player->GetSessionIndex() == s_slowQueuePlayerIndex && (time - s_slowQueueLastTime) > MINECRAFT_SERVER_SLOW_QUEUE_DELAY )
	{
//		app.DebugPrintf("Slow queue OK for player #%d\n", player->GetSessionIndex());
		return true;
	}

	return false;
}

void MinecraftServer::chunkPacketManagement_DidSendTo(INetworkPlayer *player)
{
	s_slowQueuePacketSent = true;
}

void MinecraftServer::chunkPacketManagement_PreTick()
{
}

void MinecraftServer::chunkPacketManagement_PostTick()
{
	// 4J Ensure that the slow queue owner keeps cycling if it's not been used in a while
	int time = GetTickCount();
	if( ( s_slowQueuePacketSent ) || (  (time - s_slowQueueLastTime) > ( 2 * MINECRAFT_SERVER_SLOW_QUEUE_DELAY ) ) )
	{
//		app.DebugPrintf("Considering cycling: (%d) %d - %d -> %d > %d\n",s_slowQueuePacketSent, time, s_slowQueueLastTime, (time - s_slowQueueLastTime), (2*MINECRAFT_SERVER_SLOW_QUEUE_DELAY));
		MinecraftServer::cycleSlowQueueIndex();
		s_slowQueuePacketSent = false;
		s_slowQueueLastTime = time;
	}
//	else
//	{
//		app.DebugPrintf("Not considering cycling: %d - %d -> %d > %d\n",time, s_slowQueueLastTime, (time - s_slowQueueLastTime), (2*MINECRAFT_SERVER_SLOW_QUEUE_DELAY));
//	}
}

void MinecraftServer::cycleSlowQueueIndex()
{
	if( !g_NetworkManager.IsInSession() ) return;

	int startingIndex = s_slowQueuePlayerIndex;
	INetworkPlayer *currentPlayer = NULL;
	DWORD currentPlayerCount = 0;
	do
	{
		currentPlayerCount = g_NetworkManager.GetPlayerCount();
		if( startingIndex >= currentPlayerCount ) startingIndex = 0;
		++s_slowQueuePlayerIndex;

		if( currentPlayerCount > 0 )
		{
			s_slowQueuePlayerIndex %= currentPlayerCount;
			// Fix for #9530 - NETWORKING: Attempting to fill a multiplayer game beyond capacity results in a softlock for the last players to join.
			// The QNet session might be ending while we do this, so do a few more checks that the player is real
			currentPlayer = g_NetworkManager.GetPlayerByIndex( s_slowQueuePlayerIndex );
		}
		else
		{
			s_slowQueuePlayerIndex = 0;
		}
	} while ( g_NetworkManager.IsInSession() &&
		currentPlayerCount > 0 &&
		s_slowQueuePlayerIndex != startingIndex &&
		currentPlayer != NULL &&
		currentPlayer->IsLocal()
		);
//	app.DebugPrintf("Cycled slow queue index to %d\n", s_slowQueuePlayerIndex);
}
#endif

// 4J added - sets up a vector of flags to indicate which entities (with small Ids) have been removed from the level, but are still haven't constructed a network packet
// to tell a remote client about it. These small Ids shouldn't be re-used. Most of the time this method shouldn't actually do anything, in which case it will return false
// and nothing is set up.
bool MinecraftServer::flagEntitiesToBeRemoved(unsigned int *flags)
{
	bool removedFound = false;
	for( unsigned int i = 0; i < levels.length; i++ )
	{
		ServerLevel *level = levels[i];
		if( level )
		{
			level->flagEntitiesToBeRemoved( flags, &removedFound );
		}
	}
	return removedFound;
}