Merge branch 'smartcmd:main' into main

15 files changed, 528 insertions, 308 deletions

diff --git a/Minecraft.Client/Common/Network/GameNetworkManager.cpp b/Minecraft.Client/Common/Network/GameNetworkManager.cpp
index dbae3010..50aeae68 100644
--- a/Minecraft.Client/Common/Network/GameNetworkManager.cpp
+++ b/Minecraft.Client/Common/Network/GameNetworkManager.cpp
@@ -41,12 +41,17 @@
 #include "..\Minecraft.World\DurangoStats.h"
 #endif
 
+#ifdef _WINDOWS64
+#include "..\..\Windows64\Network\WinsockNetLayer.h"
+#include "..\..\Windows64\Windows64_Xuid.h"
+#endif
+
 // Global instance
 CGameNetworkManager g_NetworkManager;
 CPlatformNetworkManager *CGameNetworkManager::s_pPlatformNetworkManager;
 
-__int64 CGameNetworkManager::messageQueue[512];
-__int64 CGameNetworkManager::byteQueue[512];
+int64_t CGameNetworkManager::messageQueue[512];
+int64_t CGameNetworkManager::byteQueue[512];
 int CGameNetworkManager::messageQueuePos = 0;
 
 CGameNetworkManager::CGameNetworkManager()
@@ -56,8 +61,8 @@ CGameNetworkManager::CGameNetworkManager()
 	m_bFullSessionMessageOnNextSessionChange = false;
 
 #ifdef __ORBIS__
-	m_pUpsell = NULL;
-	m_pInviteInfo = NULL;
+	m_pUpsell = nullptr;
+	m_pInviteInfo = nullptr;
 #endif
 }
 
@@ -120,26 +125,26 @@ void CGameNetworkManager::DoWork()
 	s_pPlatformNetworkManager->DoWork();
 
 #ifdef __ORBIS__
-	if (m_pUpsell != NULL && m_pUpsell->hasResponse())
+	if (m_pUpsell != nullptr && m_pUpsell->hasResponse())
 	{
 		int iPad_invited = m_iPlayerInvited, iPad_checking = m_pUpsell->m_userIndex;
 
 		m_iPlayerInvited = -1;
 
 		delete m_pUpsell;
-		m_pUpsell = NULL;
+		m_pUpsell = nullptr;
 
 		if (ProfileManager.HasPlayStationPlus(iPad_checking))
 		{
 			this->GameInviteReceived(iPad_invited, m_pInviteInfo);
 
 			// m_pInviteInfo deleted by GameInviteReceived.
-			m_pInviteInfo = NULL;
+			m_pInviteInfo = nullptr;
 		}
 		else
 		{
 			delete m_pInviteInfo;
-			m_pInviteInfo = NULL;
+			m_pInviteInfo = nullptr;
 		}
 	}
 #endif
@@ -194,16 +199,18 @@ bool	CGameNetworkManager::StartNetworkGame(Minecraft *minecraft, LPVOID lpParame
 	ProfileManager.SetDeferredSignoutEnabled(true);
 #endif
 
-	__int64 seed = 0;
-	if(lpParameter != NULL)
+    int64_t seed = 0;
+	bool dedicatedNoLocalHostPlayer = false;
+    if (lpParameter != nullptr)
 	{
-		NetworkGameInitData *param = (NetworkGameInitData *)lpParameter;
+		NetworkGameInitData *param = static_cast<NetworkGameInitData *>(lpParameter);
 		seed = param->seed;
+		dedicatedNoLocalHostPlayer = param->dedicatedNoLocalHostPlayer;
 
 		app.setLevelGenerationOptions(param->levelGen);
-		if(param->levelGen != NULL)
+		if(param->levelGen != nullptr)
 		{
-			if(app.getLevelGenerationOptions() == NULL)
+			if(app.getLevelGenerationOptions() == nullptr)
 			{
 				app.DebugPrintf("Game rule was not loaded, and seed is required. Exiting.\n");
 				return false;
@@ -248,10 +255,10 @@ bool	CGameNetworkManager::StartNetworkGame(Minecraft *minecraft, LPVOID lpParame
 								pchFilename, // file name
 								GENERIC_READ, // access mode
 								0, // share mode // TODO 4J Stu - Will we need to share file? Probably not but...
-								NULL, // Unused
+								nullptr, // Unused
 								OPEN_EXISTING , // how to create // TODO 4J Stu - Assuming that the file already exists if we are opening to read from it
 								FILE_FLAG_SEQUENTIAL_SCAN, // file attributes
-								NULL // Unsupported
+								nullptr // Unsupported
 								);
 #else
 							const char *pchFilename=wstringtofilename(grf.getPath());
@@ -259,18 +266,18 @@ bool	CGameNetworkManager::StartNetworkGame(Minecraft *minecraft, LPVOID lpParame
 								pchFilename, // file name
 								GENERIC_READ, // access mode
 								0, // share mode // TODO 4J Stu - Will we need to share file? Probably not but...
-								NULL, // Unused
+								nullptr, // Unused
 								OPEN_EXISTING , // how to create // TODO 4J Stu - Assuming that the file already exists if we are opening to read from it
 								FILE_FLAG_SEQUENTIAL_SCAN, // file attributes
-								NULL // Unsupported
+								nullptr // Unsupported
 								);
 #endif
 
 							if( fileHandle != INVALID_HANDLE_VALUE )
 							{
-								DWORD bytesRead,dwFileSize = GetFileSize(fileHandle,NULL);
+								DWORD bytesRead,dwFileSize = GetFileSize(fileHandle,nullptr);
 								PBYTE pbData =  (PBYTE) new BYTE[dwFileSize];
-								BOOL bSuccess = ReadFile(fileHandle,pbData,dwFileSize,&bytesRead,NULL);
+								BOOL bSuccess = ReadFile(fileHandle,pbData,dwFileSize,&bytesRead,nullptr);
 								if(bSuccess==FALSE)
 								{
 									app.FatalLoadError();
@@ -287,7 +294,7 @@ bool	CGameNetworkManager::StartNetworkGame(Minecraft *minecraft, LPVOID lpParame
 		}
 	}
 
-	static __int64 sseed = seed;	// Create static version so this will be valid until next call to this function & whilst thread is running
+	static int64_t sseed = seed;	// Create static version so this will be valid until next call to this function & whilst thread is running
 	ServerStoppedCreate(false);
 	if( g_NetworkManager.IsHost() )
 	{
@@ -312,7 +319,7 @@ bool	CGameNetworkManager::StartNetworkGame(Minecraft *minecraft, LPVOID lpParame
 	}
 	else
 	{
-		Socket::Initialise(NULL);
+		Socket::Initialise(nullptr);
 	}
 
 #ifndef _XBOX
@@ -354,47 +361,59 @@ bool	CGameNetworkManager::StartNetworkGame(Minecraft *minecraft, LPVOID lpParame
 	// PRIMARY PLAYER
 
 	vector<ClientConnection *> createdConnections;
-	ClientConnection *connection;
+	ClientConnection *connection = nullptr;
 
-	if( g_NetworkManager.IsHost() )
+	if( g_NetworkManager.IsHost() && dedicatedNoLocalHostPlayer )
+	{
+		app.DebugPrintf("Dedicated server mode: skipping local host client connection\n");
+
+		// Keep telemetry behavior consistent with the host path.
+		INT multiplayerInstanceId = TelemetryManager->GenerateMultiplayerInstanceId();
+		TelemetryManager->SetMultiplayerInstanceId(multiplayerInstanceId);
+
+		app.SetGameMode( eMode_Multiplayer );
+	}
+	else if( g_NetworkManager.IsHost() )
 	{
-		connection = new ClientConnection(minecraft, NULL);
+		connection = new ClientConnection(minecraft, nullptr);
 	}
 	else
 	{
 		INetworkPlayer *pNetworkPlayer = g_NetworkManager.GetLocalPlayerByUserIndex(ProfileManager.GetLockedProfile());
-		if(pNetworkPlayer == NULL)
+		if(pNetworkPlayer == nullptr)
 		{
 			MinecraftServer::HaltServer();
 			app.DebugPrintf("%d\n",ProfileManager.GetLockedProfile());
-			// If the player is NULL here then something went wrong in the session setup, and continuing will end up in a crash
+			// If the player is nullptr here then something went wrong in the session setup, and continuing will end up in a crash
 			return false;
 		}
 
 		Socket *socket = pNetworkPlayer->GetSocket();
 
 		// Fix for #13259 - CRASH: Gameplay: loading process is halted when player loads saved data
-		if(socket == NULL)
+		if(socket == nullptr)
 		{
 			assert(false);
 			MinecraftServer::HaltServer();
-			// If the socket is NULL here then something went wrong in the session setup, and continuing will end up in a crash
+			// If the socket is nullptr here then something went wrong in the session setup, and continuing will end up in a crash
 			return false;
 		}
 
 		connection = new ClientConnection(minecraft, socket);
 	}
 
-	if( !connection->createdOk )
+	if (connection != nullptr)
 	{
-		assert(false);
-		delete connection;
-		connection = NULL;
-		MinecraftServer::HaltServer();
-		return false;
-	}
+		if( !connection->createdOk )
+		{
+			assert(false);
+			delete connection;
+			connection = nullptr;
+			MinecraftServer::HaltServer();
+			return false;
+		}
 
-	connection->send( shared_ptr<PreLoginPacket>( new PreLoginPacket(minecraft->user->name) ) );
+		connection->send(std::make_shared<PreLoginPacket>(minecraft->user->name));
 
 	// Tick connection until we're ready to go. The stages involved in this are:
 	// (1) Creating the ClientConnection sends a prelogin packet to the server
@@ -429,9 +448,9 @@ bool	CGameNetworkManager::StartNetworkGame(Minecraft *minecraft, LPVOID lpParame
 		connection->close();
 	}
 
-	if( connection->isStarted() && !connection->isClosed() )
-	{
-		createdConnections.push_back( connection );
+		if( connection->isStarted() && !connection->isClosed() )
+		{
+			createdConnections.push_back( connection );
 
 		int primaryPad = ProfileManager.GetPrimaryPad();
 		app.SetRichPresenceContext(primaryPad,CONTEXT_GAME_STATE_BLANK);
@@ -453,7 +472,7 @@ bool	CGameNetworkManager::StartNetworkGame(Minecraft *minecraft, LPVOID lpParame
 			// Already have setup the primary pad
 			if(idx == ProfileManager.GetPrimaryPad() ) continue;
 
-			if( GetLocalPlayerByUserIndex(idx) != NULL && !ProfileManager.IsSignedIn(idx) )
+			if( GetLocalPlayerByUserIndex(idx) != nullptr && !ProfileManager.IsSignedIn(idx) )
 			{
 				INetworkPlayer *pNetworkPlayer = g_NetworkManager.GetLocalPlayerByUserIndex(idx);
 				Socket *socket = pNetworkPlayer->GetSocket();
@@ -467,7 +486,7 @@ bool	CGameNetworkManager::StartNetworkGame(Minecraft *minecraft, LPVOID lpParame
 			// when joining any other way, so just because they are signed in doesn't mean they are in the session
 			// 4J Stu - If they are in the session, then we should add them to the game. Otherwise we won't be able to add them later
 			INetworkPlayer *pNetworkPlayer = g_NetworkManager.GetLocalPlayerByUserIndex(idx);
-			if( pNetworkPlayer == NULL )
+			if( pNetworkPlayer == nullptr )
 				continue;
 
 			ClientConnection *connection;
@@ -481,7 +500,7 @@ bool	CGameNetworkManager::StartNetworkGame(Minecraft *minecraft, LPVOID lpParame
 			// Open the socket on the server end to accept incoming data
 			Socket::addIncomingSocket(socket);
 
-			connection->send( shared_ptr<PreLoginPacket>( new PreLoginPacket(convStringToWstring( ProfileManager.GetGamertag(idx) )) ) );
+			connection->send(std::make_shared<PreLoginPacket>(convStringToWstring(ProfileManager.GetGamertag(idx))));
 
 			createdConnections.push_back( connection );
 
@@ -528,13 +547,14 @@ bool	CGameNetworkManager::StartNetworkGame(Minecraft *minecraft, LPVOID lpParame
 			}
 		}
 
-		app.SetGameMode( eMode_Multiplayer );
-	}
-	else if ( connection->isClosed() || !IsInSession())
-	{
+			app.SetGameMode( eMode_Multiplayer );
+		}
+		else if ( connection->isClosed() || !IsInSession())
+		{
 //		assert(false);
-		MinecraftServer::HaltServer();
-		return false;
+			MinecraftServer::HaltServer();
+			return false;
+		}
 	}
 
 
@@ -744,7 +764,7 @@ CGameNetworkManager::eJoinGameResult CGameNetworkManager::JoinGame(FriendSession
 	// Make sure that the Primary Pad is in by default
 	localUsersMask |= GetLocalPlayerMask( ProfileManager.GetPrimaryPad() );
 
-	return (eJoinGameResult)(s_pPlatformNetworkManager->JoinGame( searchResult, localUsersMask, primaryUserIndex ));
+	return static_cast<eJoinGameResult>(s_pPlatformNetworkManager->JoinGame(searchResult, localUsersMask, primaryUserIndex));
 }
 
 void CGameNetworkManager::CancelJoinGame(LPVOID lpParam)
@@ -762,7 +782,7 @@ bool CGameNetworkManager::LeaveGame(bool bMigrateHost)
 
 int CGameNetworkManager::JoinFromInvite_SignInReturned(void *pParam,bool bContinue, int iPad)
 {
-	INVITE_INFO * pInviteInfo = (INVITE_INFO *)pParam;
+	INVITE_INFO * pInviteInfo = static_cast<INVITE_INFO *>(pParam);
 
 	if(bContinue==true)
 	{
@@ -801,9 +821,9 @@ int CGameNetworkManager::JoinFromInvite_SignInReturned(void *pParam,bool bContin
 			// Check if user-created content is allowed, as we cannot play multiplayer if it's not
 			bool noUGC = false;
 #if defined(__PS3__) || defined(__PSVITA__)
-			ProfileManager.GetChatAndContentRestrictions(iPad,false,&noUGC,NULL,NULL);
+			ProfileManager.GetChatAndContentRestrictions(iPad,false,&noUGC,nullptr,nullptr);
 #elif defined(__ORBIS__)
-			ProfileManager.GetChatAndContentRestrictions(iPad,false,NULL,&noUGC,NULL);
+			ProfileManager.GetChatAndContentRestrictions(iPad,false,nullptr,&noUGC,nullptr);
 #endif
 
 			if(noUGC)
@@ -823,7 +843,7 @@ int CGameNetworkManager::JoinFromInvite_SignInReturned(void *pParam,bool bContin
 			{
 #if defined(__ORBIS__) || defined(__PSVITA__)
 				bool chatRestricted = false;
-				ProfileManager.GetChatAndContentRestrictions(iPad,false,&chatRestricted,NULL,NULL);
+				ProfileManager.GetChatAndContentRestrictions(iPad,false,&chatRestricted,nullptr,nullptr);
 				if(chatRestricted)
 				{
 					ProfileManager.DisplaySystemMessage( 0, ProfileManager.GetPrimaryPad() );
@@ -912,7 +932,7 @@ int CGameNetworkManager::RunNetworkGameThreadProc( void* lpParameter )
 			app.SetDisconnectReason( DisconnectPacket::eDisconnect_ConnectionCreationFailed );
 		}
 		// If we failed before the server started, clear the game rules. Otherwise the server will clear it up.
-		if(MinecraftServer::getInstance() == NULL) app.m_gameRules.unloadCurrentGameRules();
+		if(MinecraftServer::getInstance() == nullptr) app.m_gameRules.unloadCurrentGameRules();
 		Tile::ReleaseThreadStorage();
 		return -1;
 	}
@@ -929,21 +949,26 @@ int CGameNetworkManager::RunNetworkGameThreadProc( void* lpParameter )
 
 int CGameNetworkManager::ServerThreadProc( void* lpParameter )
 {
-	__int64 seed = 0;
-	if(lpParameter != NULL)
+    int64_t seed = 0;
+    if (lpParameter != nullptr)
 	{
-		NetworkGameInitData *param = (NetworkGameInitData *)lpParameter;
+		NetworkGameInitData *param = static_cast<NetworkGameInitData *>(lpParameter);
 		seed = param->seed;
 		app.SetGameHostOption(eGameHostOption_All,param->settings);
 
 		// 4J Stu - If we are loading a DLC save that's separate from the texture pack, load
-		if( param->levelGen != NULL && (param->texturePackId == 0 || param->levelGen->getRequiredTexturePackId() != param->texturePackId) )
+		if (param != nullptr && param->levelGen != nullptr && param->levelGen->isFromDLC())
 		{
 			while((Minecraft::GetInstance()->skins->needsUIUpdate() || ui.IsReloadingSkin()))
 			{
 				Sleep(1);
 			}
 			param->levelGen->loadBaseSaveData();
+
+			while (!param->levelGen->hasLoadedData())
+			{
+				Sleep(1);
+			}
 		}
 	}
 
@@ -966,7 +991,7 @@ int CGameNetworkManager::ServerThreadProc( void* lpParameter )
 	IntCache::ReleaseThreadStorage();
 	Level::destroyLightingCache();
 
-	if(lpParameter != NULL) delete lpParameter;
+	if(lpParameter != nullptr) delete lpParameter;
 
 	return S_OK;
 }
@@ -979,7 +1004,7 @@ int	CGameNetworkManager::ExitAndJoinFromInviteThreadProc( void* lpParam )
 	Compression::UseDefaultThreadStorage();
 
 	//app.SetGameStarted(false);
-	UIScene_PauseMenu::_ExitWorld(NULL);
+	UIScene_PauseMenu::_ExitWorld(nullptr);
 
 	while( g_NetworkManager.IsInSession() )
 	{
@@ -988,7 +1013,7 @@ int	CGameNetworkManager::ExitAndJoinFromInviteThreadProc( void* lpParam )
 
 	// Xbox should always be online when receiving invites - on PS3 we need to check & ask the user to sign in
 #if !defined(__PS3__) && !defined(__PSVITA__)
-	JoinFromInviteData *inviteData = (JoinFromInviteData *)lpParam;
+	JoinFromInviteData *inviteData = static_cast<JoinFromInviteData *>(lpParam);
 	app.SetAction(inviteData->dwUserIndex, eAppAction_JoinFromInvite, lpParam);
 #else
 	if(ProfileManager.IsSignedInLive(ProfileManager.GetPrimaryPad()))
@@ -1216,14 +1241,14 @@ int CGameNetworkManager::ChangeSessionTypeThreadProc( void* lpParam )
 #endif
 
 	// Null the network player of all the server players that are local, to stop them being removed from the server when removed from the session
-	if( pServer != NULL )
+	if( pServer != nullptr )
 	{
 		PlayerList *players = pServer->getPlayers();
 		for(auto& servPlayer : players->players)
 		{
 			if( servPlayer->connection->isLocal() && !servPlayer->connection->isGuest() )
 			{
-				servPlayer->connection->connection->getSocket()->setPlayer(NULL);
+				servPlayer->connection->connection->getSocket()->setPlayer(nullptr);
 			}
 		}
 	}
@@ -1259,7 +1284,7 @@ int CGameNetworkManager::ChangeSessionTypeThreadProc( void* lpParam )
 	char numLocalPlayers = 0;
 	for(unsigned int index = 0; index < XUSER_MAX_COUNT; ++index)
 	{
-		if(ProfileManager.IsSignedIn(index) && pMinecraft->localplayers[index] != NULL )
+		if(ProfileManager.IsSignedIn(index) && pMinecraft->localplayers[index] != nullptr )
 		{
 			numLocalPlayers++;
 			localUsersMask |= GetLocalPlayerMask(index);
@@ -1277,11 +1302,11 @@ int CGameNetworkManager::ChangeSessionTypeThreadProc( void* lpParam )
 	}
 
 	// Restore the network player of all the server players that are local
-	if( pServer != NULL )
+	if( pServer != nullptr )
 	{
 		for(unsigned int index = 0; index < XUSER_MAX_COUNT; ++index)
 		{
-			if(ProfileManager.IsSignedIn(index) && pMinecraft->localplayers[index] != NULL )
+			if(ProfileManager.IsSignedIn(index) && pMinecraft->localplayers[index] != nullptr )
 			{
 				PlayerUID localPlayerXuid = pMinecraft->localplayers[index]->getXuid();
 
@@ -1295,7 +1320,7 @@ int CGameNetworkManager::ChangeSessionTypeThreadProc( void* lpParam )
 				}
 
 				// Player might have a pending connection
-				if (pMinecraft->m_pendingLocalConnections[index] != NULL)
+				if (pMinecraft->m_pendingLocalConnections[index] != nullptr)
 				{
 					// Update the network player
 					pMinecraft->m_pendingLocalConnections[index]->getConnection()->getSocket()->setPlayer(g_NetworkManager.GetLocalPlayerByUserIndex(index));
@@ -1361,8 +1386,8 @@ void CGameNetworkManager::renderQueueMeter()
 #ifdef _XBOX
 	int height = 720;
 
-	CGameNetworkManager::byteQueue[(CGameNetworkManager::messageQueuePos) & (CGameNetworkManager::messageQueue_length - 1)] = GetHostPlayer()->GetSendQueueSizeBytes(NULL, false);
-	CGameNetworkManager::messageQueue[(CGameNetworkManager::messageQueuePos++) & (CGameNetworkManager::messageQueue_length - 1)] = GetHostPlayer()->GetSendQueueSizeMessages(NULL, false);
+	CGameNetworkManager::byteQueue[(CGameNetworkManager::messageQueuePos) & (CGameNetworkManager::messageQueue_length - 1)] = GetHostPlayer()->GetSendQueueSizeBytes(nullptr, false);
+	CGameNetworkManager::messageQueue[(CGameNetworkManager::messageQueuePos++) & (CGameNetworkManager::messageQueue_length - 1)] = GetHostPlayer()->GetSendQueueSizeMessages(nullptr, false);
 
 	Minecraft *pMinecraft = Minecraft::GetInstance();
 	pMinecraft->gui->renderGraph(CGameNetworkManager::messageQueue_length, CGameNetworkManager::messageQueuePos, CGameNetworkManager::messageQueue, 10, 1000, CGameNetworkManager::byteQueue, 100, 25000);
@@ -1426,7 +1451,7 @@ void CGameNetworkManager::StateChange_AnyToStarting()
 	{
 		LoadingInputParams *loadingParams = new LoadingInputParams();
 		loadingParams->func = &CGameNetworkManager::RunNetworkGameThreadProc;
-		loadingParams->lpParam = NULL;
+		loadingParams->lpParam = nullptr;
 
 		UIFullscreenProgressCompletionData *completionData = new UIFullscreenProgressCompletionData();
 		completionData->bShowBackground=TRUE;
@@ -1447,7 +1472,7 @@ void CGameNetworkManager::StateChange_AnyToEnding(bool bStateWasPlaying)
 		for(unsigned int i = 0; i < XUSER_MAX_COUNT; ++i)
 		{
 			INetworkPlayer *pNetworkPlayer = g_NetworkManager.GetLocalPlayerByUserIndex(i);
-			if(pNetworkPlayer != NULL && ProfileManager.IsSignedIn( i ) )
+			if(pNetworkPlayer != nullptr && ProfileManager.IsSignedIn( i ) )
 			{
 				app.DebugPrintf("Stats save for an offline game for the player at index %d\n", i );
 				Minecraft::GetInstance()->forceStatsSave(pNetworkPlayer->GetUserIndex());
@@ -1482,12 +1507,12 @@ void CGameNetworkManager::CreateSocket( INetworkPlayer *pNetworkPlayer, bool loc
 {
 	Minecraft *pMinecraft = Minecraft::GetInstance();
 
-	Socket *socket = NULL;
+	Socket *socket = nullptr;
 	shared_ptr<MultiplayerLocalPlayer> mpPlayer = nullptr;
 	int userIdx = pNetworkPlayer->GetUserIndex();
 	if (userIdx >= 0 && userIdx < XUSER_MAX_COUNT)
 		mpPlayer = pMinecraft->localplayers[userIdx];
-	if( localPlayer && mpPlayer != NULL && mpPlayer->connection != NULL)
+	if( localPlayer && mpPlayer != nullptr && mpPlayer->connection != nullptr)
 	{
 		// If we already have a MultiplayerLocalPlayer here then we are doing a session type change
 		socket = mpPlayer->connection->getSocket();
@@ -1501,6 +1526,45 @@ void CGameNetworkManager::CreateSocket( INetworkPlayer *pNetworkPlayer, bool loc
 	}
 	else
 	{
+#ifdef _WINDOWS64
+		// Non-host split-screen: open a dedicated TCP connection for this pad
+		if (localPlayer && !g_NetworkManager.IsHost() && g_NetworkManager.IsInGameplay())
+		{
+			int padIdx = pNetworkPlayer->GetUserIndex();
+			BYTE assignedSmallId = 0;
+
+			if (!WinsockNetLayer::JoinSplitScreen(padIdx, &assignedSmallId))
+			{
+				app.DebugPrintf("Split-screen pad %d: failed to open TCP to host\n", padIdx);
+				pMinecraft->connectionDisconnected(padIdx, DisconnectPacket::eDisconnect_ConnectionCreationFailed);
+				return;
+			}
+
+			// Update the local IQNetPlayer (at pad index) with the host-assigned smallId.
+			// The NetworkPlayerXbox created by NotifyPlayerJoined already points to
+			// m_player[padIdx], so we just set the smallId for network routing.
+			IQNet::m_player[padIdx].m_smallId = assignedSmallId;
+			IQNet::m_player[padIdx].m_resolvedXuid = Win64Xuid::DeriveXuidForPad(Win64Xuid::ResolvePersistentXuid(), padIdx);
+
+			// Network socket (not hostLocal) — data goes through TCP via GetLocalSocket
+			socket = new Socket(pNetworkPlayer, false, false);
+			pNetworkPlayer->SetSocket(socket);
+
+			ClientConnection* connection = new ClientConnection(pMinecraft, socket, padIdx);
+			if (connection->createdOk)
+			{
+				connection->send(shared_ptr<PreLoginPacket>(new PreLoginPacket(pNetworkPlayer->GetOnlineName())));
+				pMinecraft->addPendingLocalConnection(padIdx, connection);
+			}
+			else
+			{
+				pMinecraft->connectionDisconnected(padIdx, DisconnectPacket::eDisconnect_ConnectionCreationFailed);
+				delete connection;
+			}
+			return;
+		}
+#endif
+
 		socket = new Socket( pNetworkPlayer, g_NetworkManager.IsHost(), g_NetworkManager.IsHost() && localPlayer );
 		pNetworkPlayer->SetSocket( socket );
 
@@ -1523,14 +1587,14 @@ void CGameNetworkManager::CreateSocket( INetworkPlayer *pNetworkPlayer, bool loc
 
 			if( connection->createdOk )
 			{
-				connection->send( shared_ptr<PreLoginPacket>( new PreLoginPacket( pNetworkPlayer->GetOnlineName() ) ) );
+				connection->send(std::make_shared<PreLoginPacket>(pNetworkPlayer->GetOnlineName()));
 				pMinecraft->addPendingLocalConnection(idx, connection);
 			}
 			else
 			{
 				pMinecraft->connectionDisconnected( idx , DisconnectPacket::eDisconnect_ConnectionCreationFailed );
 				delete connection;
-				connection = NULL;
+				connection = nullptr;
 			}
 		}
 	}
@@ -1540,10 +1604,10 @@ void CGameNetworkManager::CreateSocket( INetworkPlayer *pNetworkPlayer, bool loc
 void CGameNetworkManager::CloseConnection( INetworkPlayer *pNetworkPlayer )
 {
 	MinecraftServer *server = MinecraftServer::getInstance();
-	if( server != NULL )
+	if( server != nullptr )
 	{
 		PlayerList *players = server->getPlayers();
-		if( players != NULL )
+		if( players != nullptr )
 		{
 			players->closePlayerConnectionBySmallId(pNetworkPlayer->GetSmallId());
 		}
@@ -1559,7 +1623,7 @@ void CGameNetworkManager::PlayerJoining( INetworkPlayer *pNetworkPlayer )
 		for (int iPad=0; iPad<XUSER_MAX_COUNT; ++iPad)
 		{
 			INetworkPlayer *pNetworkPlayer = g_NetworkManager.GetLocalPlayerByUserIndex(iPad);
-			if (pNetworkPlayer == NULL)	continue;
+			if (pNetworkPlayer == nullptr)	continue;
 
 			app.SetRichPresenceContext(iPad,CONTEXT_GAME_STATE_BLANK);
 			if (multiplayer)
@@ -1586,7 +1650,7 @@ void CGameNetworkManager::PlayerJoining( INetworkPlayer *pNetworkPlayer )
         {
 			for(int idx = 0; idx < XUSER_MAX_COUNT; ++idx)
 			{
-				if(Minecraft::GetInstance()->localplayers[idx] != NULL)
+				if(Minecraft::GetInstance()->localplayers[idx] != nullptr)
 				{
 					TelemetryManager->RecordLevelStart(idx, eSen_FriendOrMatch_Playing_With_Invited_Friends, eSen_CompeteOrCoop_Coop_and_Competitive, Minecraft::GetInstance()->level->difficulty, app.GetLocalPlayerCount(), g_NetworkManager.GetOnlinePlayerCount());
 				}
@@ -1609,7 +1673,7 @@ void CGameNetworkManager::PlayerLeaving( INetworkPlayer *pNetworkPlayer )
 	{
 		for(int idx = 0; idx < XUSER_MAX_COUNT; ++idx)
 		{
-			if(Minecraft::GetInstance()->localplayers[idx] != NULL)
+			if(Minecraft::GetInstance()->localplayers[idx] != nullptr)
 			{
 				TelemetryManager->RecordLevelStart(idx, eSen_FriendOrMatch_Playing_With_Invited_Friends, eSen_CompeteOrCoop_Coop_and_Competitive, Minecraft::GetInstance()->level->difficulty, app.GetLocalPlayerCount(), g_NetworkManager.GetOnlinePlayerCount());
 			}
@@ -1632,7 +1696,7 @@ void CGameNetworkManager::WriteStats( INetworkPlayer *pNetworkPlayer )
 void CGameNetworkManager::GameInviteReceived( int userIndex, const INVITE_INFO *pInviteInfo)
 {
 #ifdef __ORBIS__
-	if (m_pUpsell != NULL)
+	if (m_pUpsell != nullptr)
 	{
 		delete pInviteInfo;
 		return;
@@ -1721,7 +1785,7 @@ void CGameNetworkManager::GameInviteReceived( int userIndex, const INVITE_INFO *
 		{
 			// 4J-PB we shouldn't bring any inactive players into the game, except for the invited player (who may be an inactive player)
 			// 4J Stu - If we are not in a game, then bring in all players signed in
-			if(index==userIndex || pMinecraft->localplayers[index]!=NULL )
+			if(index==userIndex || pMinecraft->localplayers[index]!=nullptr )
 			{
 				++joiningUsers;
 				if( !ProfileManager.AllowedToPlayMultiplayer(index) ) noPrivileges = true;
@@ -1736,7 +1800,7 @@ void CGameNetworkManager::GameInviteReceived( int userIndex, const INVITE_INFO *
 	BOOL pccAllowed = TRUE;
 	BOOL pccFriendsAllowed = TRUE;
 #if defined(__PS3__) || defined(__PSVITA__)
-	ProfileManager.GetChatAndContentRestrictions(userIndex,false,&noUGC,&bContentRestricted,NULL);
+	ProfileManager.GetChatAndContentRestrictions(userIndex,false,&noUGC,&bContentRestricted,nullptr);
 #else
 	ProfileManager.AllowedPlayerCreatedContent(ProfileManager.GetPrimaryPad(),false,&pccAllowed,&pccFriendsAllowed);
 	if(!pccAllowed && !pccFriendsAllowed) noUGC = true;
@@ -1781,14 +1845,14 @@ void CGameNetworkManager::GameInviteReceived( int userIndex, const INVITE_INFO *
 		uiIDA[0]=IDS_CONFIRM_OK;
 
 		// 4J-PB - it's possible there is no primary pad here, when accepting an invite from the dashboard
-		//StorageManager.RequestMessageBox( IDS_NO_MULTIPLAYER_PRIVILEGE_TITLE, IDS_NO_MULTIPLAYER_PRIVILEGE_JOIN_TEXT, uiIDA,1,ProfileManager.GetPrimaryPad(),NULL,NULL, app.GetStringTable());
+		//StorageManager.RequestMessageBox( IDS_NO_MULTIPLAYER_PRIVILEGE_TITLE, IDS_NO_MULTIPLAYER_PRIVILEGE_JOIN_TEXT, uiIDA,1,ProfileManager.GetPrimaryPad(),nullptr,nullptr, app.GetStringTable());
 		ui.RequestErrorMessage( IDS_NO_MULTIPLAYER_PRIVILEGE_TITLE, IDS_NO_MULTIPLAYER_PRIVILEGE_JOIN_TEXT, uiIDA,1,XUSER_INDEX_ANY);
 	}
 	else
 	{
 #if defined(__ORBIS__) || defined(__PSVITA__)
 		bool chatRestricted = false;
-		ProfileManager.GetChatAndContentRestrictions(ProfileManager.GetPrimaryPad(),false,&chatRestricted,NULL,NULL);
+		ProfileManager.GetChatAndContentRestrictions(ProfileManager.GetPrimaryPad(),false,&chatRestricted,nullptr,nullptr);
 		if(chatRestricted)
 		{
 			ProfileManager.DisplaySystemMessage( SCE_MSG_DIALOG_SYSMSG_TYPE_TRC_PSN_CHAT_RESTRICTION, ProfileManager.GetPrimaryPad() );
@@ -1984,7 +2048,7 @@ const char *CGameNetworkManager::GetOnlineName(int playerIdx)
 
 void CGameNetworkManager::ServerReadyCreate(bool create)
 {
-	m_hServerReadyEvent = ( create ? ( new C4JThread::Event ) : NULL );
+	m_hServerReadyEvent = ( create ? ( new C4JThread::Event ) : nullptr );
 }
 
 void CGameNetworkManager::ServerReady()
@@ -2000,17 +2064,17 @@ void CGameNetworkManager::ServerReadyWait()
 void CGameNetworkManager::ServerReadyDestroy()
 {
 	delete m_hServerReadyEvent;
-	m_hServerReadyEvent = NULL;
+	m_hServerReadyEvent = nullptr;
 }
 
 bool CGameNetworkManager::ServerReadyValid()
 {
-	return ( m_hServerReadyEvent != NULL );
+	return ( m_hServerReadyEvent != nullptr );
 }
 
 void CGameNetworkManager::ServerStoppedCreate(bool create)
 {
-	m_hServerStoppedEvent = ( create ? ( new C4JThread::Event ) : NULL );
+	m_hServerStoppedEvent = ( create ? ( new C4JThread::Event ) : nullptr );
 }
 
 void CGameNetworkManager::ServerStopped()
@@ -2051,12 +2115,12 @@ void CGameNetworkManager::ServerStoppedWait()
 void CGameNetworkManager::ServerStoppedDestroy()
 {
 	delete m_hServerStoppedEvent;
-	m_hServerStoppedEvent = NULL;
+	m_hServerStoppedEvent = nullptr;
 }
 
 bool CGameNetworkManager::ServerStoppedValid()
 {
-	return ( m_hServerStoppedEvent != NULL );
+	return ( m_hServerStoppedEvent != nullptr );
 }
 
 int CGameNetworkManager::GetJoiningReadyPercentage()
diff --git a/Minecraft.Client/Common/Network/GameNetworkManager.h b/Minecraft.Client/Common/Network/GameNetworkManager.h
index bb7633c2..3357b3cd 100644
--- a/Minecraft.Client/Common/Network/GameNetworkManager.h
+++ b/Minecraft.Client/Common/Network/GameNetworkManager.h
@@ -100,26 +100,26 @@ public:
 	void			SetSessionsUpdatedCallback( void (*SessionsUpdatedCallback)(LPVOID pParam), LPVOID pSearchParam );
 	void			GetFullFriendSessionInfo( FriendSessionInfo *foundSession, void (* FriendSessionUpdatedFn)(bool success, void *pParam), void *pParam );
 	void			ForceFriendsSessionRefresh();
-	
+
 	// Session joining and leaving
 
 	bool			JoinGameFromInviteInfo( int userIndex, int userMask, const INVITE_INFO *pInviteInfo);
-	eJoinGameResult	JoinGame(FriendSessionInfo *searchResult, int localUsersMask);	
+	eJoinGameResult	JoinGame(FriendSessionInfo *searchResult, int localUsersMask);
 	static void		CancelJoinGame(LPVOID lpParam); // Not part of the shared interface
 	bool			LeaveGame(bool bMigrateHost);
 	static int		JoinFromInvite_SignInReturned(void *pParam,bool bContinue, int iPad);
-	void			UpdateAndSetGameSessionData(INetworkPlayer *pNetworkPlayerLeaving = NULL);
+	void			UpdateAndSetGameSessionData(INetworkPlayer *pNetworkPlayerLeaving = nullptr);
 	void			SendInviteGUI(int iPad);
 	void			ResetLeavingGame();
 
 	// Threads
-	
+
 	bool			IsNetworkThreadRunning();
 	static int		RunNetworkGameThreadProc( void* lpParameter );
 	static int		ServerThreadProc( void* lpParameter );
 	static int		ExitAndJoinFromInviteThreadProc( void* lpParam );
 
-#if (defined __PS3__) || (defined __ORBIS__) || (defined __PSVITA__) 
+#if (defined __PS3__) || (defined __ORBIS__) || (defined __PSVITA__)
 	static int		MustSignInReturned_0(void *pParam,int iPad,C4JStorage::EMessageResult result);
 	static int		PSNSignInReturned_0(void* pParam, bool bContinue, int iPad);
 
@@ -130,24 +130,24 @@ public:
 	static void		_LeaveGame();
 	static int		ChangeSessionTypeThreadProc( void* lpParam );
 
-	// System flags	
+	// System flags
 
 	void SystemFlagSet(INetworkPlayer *pNetworkPlayer, int index);
 	bool SystemFlagGet(INetworkPlayer *pNetworkPlayer, int index);
 
 	// Events
 
-	void ServerReadyCreate(bool create);	// Create the signal (or set to NULL)
+	void ServerReadyCreate(bool create);	// Create the signal (or set to nullptr)
 	void ServerReady();						// Signal that we are ready
 	void ServerReadyWait();					// Wait for the signal
 	void ServerReadyDestroy();				// Destroy signal
-	bool ServerReadyValid();				// Is non-NULL
+	bool ServerReadyValid();				// Is non-nullptr
 
 	void ServerStoppedCreate(bool create);	// Create the signal
 	void ServerStopped();					// Signal that we are ready
-	void ServerStoppedWait();				// Wait for the signal	
-	void ServerStoppedDestroy();			// Destroy signal	
-	bool ServerStoppedValid();				// Is non-NULL
+    void ServerStoppedWait();               // Wait for the signal
+    void ServerStoppedDestroy();            // Destroy signal
+    bool ServerStoppedValid();              // Is non-nullptr
 
 #ifdef __PSVITA__
 	static bool usingAdhocMode();
@@ -164,9 +164,9 @@ public:
 
 	// Used for debugging output
 	static const int messageQueue_length = 512;
-	static __int64 messageQueue[messageQueue_length];
+	static int64_t messageQueue[messageQueue_length];
 	static const int byteQueue_length = 512;
-    static __int64 byteQueue[byteQueue_length];
+    static int64_t byteQueue[byteQueue_length];
 	static int messageQueuePos;
 
 	// Methods called from PlatformNetworkManager
diff --git a/Minecraft.Client/Common/Network/PlatformNetworkManagerInterface.h b/Minecraft.Client/Common/Network/PlatformNetworkManagerInterface.h
index 31c415a7..3ed0f888 100644
--- a/Minecraft.Client/Common/Network/PlatformNetworkManagerInterface.h
+++ b/Minecraft.Client/Common/Network/PlatformNetworkManagerInterface.h
@@ -93,7 +93,7 @@ private:
 
 
 public:
-	virtual void UpdateAndSetGameSessionData(INetworkPlayer *pNetworkPlayerLeaving = NULL) = 0;
+	virtual void UpdateAndSetGameSessionData(INetworkPlayer *pNetworkPlayerLeaving = nullptr) = 0;
 
 private:
 	virtual bool RemoveLocalPlayer( INetworkPlayer *pNetworkPlayer ) = 0;
diff --git a/Minecraft.Client/Common/Network/PlatformNetworkManagerStub.cpp b/Minecraft.Client/Common/Network/PlatformNetworkManagerStub.cpp
index 85531e47..1e625098 100644
--- a/Minecraft.Client/Common/Network/PlatformNetworkManagerStub.cpp
+++ b/Minecraft.Client/Common/Network/PlatformNetworkManagerStub.cpp
@@ -5,8 +5,11 @@
 #include "..\..\Xbox\Network\NetworkPlayerXbox.h"
 #ifdef _WINDOWS64
 #include "..\..\Windows64\Network\WinsockNetLayer.h"
+#include "..\..\Windows64\Windows64_Xuid.h"
 #include "..\..\Minecraft.h"
 #include "..\..\User.h"
+#include "..\..\MinecraftServer.h"
+#include "..\..\PlayerList.h"
 #include <iostream>
 #endif
 
@@ -23,7 +26,7 @@ void CPlatformNetworkManagerStub::NotifyPlayerJoined(IQNetPlayer *pQNetPlayer	)
 	bool createFakeSocket = false;
 	bool localPlayer = false;
 
-	NetworkPlayerXbox *networkPlayer = (NetworkPlayerXbox *)addNetworkPlayer(pQNetPlayer);
+	NetworkPlayerXbox *networkPlayer = static_cast<NetworkPlayerXbox *>(addNetworkPlayer(pQNetPlayer));
 
     if( pQNetPlayer->IsLocal() )
     {
@@ -87,8 +90,8 @@ void CPlatformNetworkManagerStub::NotifyPlayerJoined(IQNetPlayer *pQNetPlayer	)
         pQNetPlayer,
         pQNetPlayer->GetGamertag(),
         pszDescription,
-        (int) pQNetPlayer->HasVoice(),
-        (int) pQNetPlayer->HasCamera() );
+        pQNetPlayer->HasVoice(),
+        pQNetPlayer->HasCamera() );
 
 
 	if( m_pIQNet->IsHost() )
@@ -100,7 +103,7 @@ void CPlatformNetworkManagerStub::NotifyPlayerJoined(IQNetPlayer *pQNetPlayer	)
 
 	for( int idx = 0; idx < XUSER_MAX_COUNT; ++idx)
 	{
-		if(playerChangedCallback[idx] != NULL)
+		if(playerChangedCallback[idx] != nullptr)
 			playerChangedCallback[idx]( playerChangedCallbackParam[idx], networkPlayer, false );
 	}
 
@@ -109,7 +112,7 @@ void CPlatformNetworkManagerStub::NotifyPlayerJoined(IQNetPlayer *pQNetPlayer	)
 		int localPlayerCount = 0;
 		for(unsigned int idx = 0; idx < XUSER_MAX_COUNT; ++idx)
 		{
-			if( m_pIQNet->GetLocalPlayerByUserIndex(idx) != NULL ) ++localPlayerCount;
+			if( m_pIQNet->GetLocalPlayerByUserIndex(idx) != nullptr ) ++localPlayerCount;
 		}
 
 		float appTime = app.getAppTime();
@@ -124,11 +127,11 @@ void CPlatformNetworkManagerStub::NotifyPlayerLeaving(IQNetPlayer* pQNetPlayer)
 	app.DebugPrintf("Player 0x%p \"%ls\" leaving.\n", pQNetPlayer, pQNetPlayer->GetGamertag());
 
 	INetworkPlayer* networkPlayer = getNetworkPlayer(pQNetPlayer);
-	if (networkPlayer == NULL)
+	if (networkPlayer == nullptr)
 		return;
 
 	Socket* socket = networkPlayer->GetSocket();
-	if (socket != NULL)
+	if (socket != nullptr)
 	{
 		if (m_pIQNet->IsHost())
 			g_NetworkManager.CloseConnection(networkPlayer);
@@ -143,7 +146,7 @@ void CPlatformNetworkManagerStub::NotifyPlayerLeaving(IQNetPlayer* pQNetPlayer)
 
 	for (int idx = 0; idx < XUSER_MAX_COUNT; ++idx)
 	{
-		if (playerChangedCallback[idx] != NULL)
+		if (playerChangedCallback[idx] != nullptr)
 			playerChangedCallback[idx](playerChangedCallbackParam[idx], networkPlayer, true);
 	}
 
@@ -159,7 +162,7 @@ bool CPlatformNetworkManagerStub::Initialise(CGameNetworkManager *pGameNetworkMa
 	g_pPlatformNetworkManager = this;
 	for( int i = 0; i < XUSER_MAX_COUNT; i++ )
 	{
-		playerChangedCallback[ i ] = NULL;
+		playerChangedCallback[ i ] = nullptr;
 	}
 
 	m_bLeavingGame = false;
@@ -170,8 +173,8 @@ bool CPlatformNetworkManagerStub::Initialise(CGameNetworkManager *pGameNetworkMa
 	m_bSearchPending = false;
 
 	m_bIsOfflineGame = false;
-	m_pSearchParam = NULL;
-	m_SessionsUpdatedCallback = NULL;
+	m_pSearchParam = nullptr;
+	m_SessionsUpdatedCallback = nullptr;
 
 	for(unsigned int i = 0; i < XUSER_MAX_COUNT; ++i)
 	{
@@ -179,10 +182,10 @@ bool CPlatformNetworkManagerStub::Initialise(CGameNetworkManager *pGameNetworkMa
 		m_lastSearchStartTime[i] = 0;
 
 		// The results that will be filled in with the current search
-		m_pSearchResults[i] = NULL;
-		m_pQoSResult[i] = NULL;
-		m_pCurrentSearchResults[i] = NULL;
-		m_pCurrentQoSResult[i] = NULL;
+		m_pSearchResults[i] = nullptr;
+		m_pQoSResult[i] = nullptr;
+		m_pCurrentSearchResults[i] = nullptr;
+		m_pCurrentQoSResult[i] = nullptr;
 		m_currentSearchResultsCount[i] = 0;
 	}
 
@@ -228,23 +231,73 @@ void CPlatformNetworkManagerStub::DoWork()
 		while (WinsockNetLayer::PopDisconnectedSmallId(&disconnectedSmallId))
 		{
 			IQNetPlayer* qnetPlayer = m_pIQNet->GetPlayerBySmallId(disconnectedSmallId);
-			if (qnetPlayer != NULL && qnetPlayer->m_smallId == disconnectedSmallId)
+			if (qnetPlayer != nullptr && qnetPlayer->m_smallId == disconnectedSmallId)
 			{
 				NotifyPlayerLeaving(qnetPlayer);
 				qnetPlayer->m_smallId = 0;
 				qnetPlayer->m_isRemote = false;
 				qnetPlayer->m_isHostPlayer = false;
+				qnetPlayer->m_resolvedXuid = INVALID_XUID;
 				qnetPlayer->m_gamertag[0] = 0;
 				qnetPlayer->SetCustomDataValue(0);
-				WinsockNetLayer::PushFreeSmallId(disconnectedSmallId);
-				if (IQNet::s_playerCount > 1)
+				// Recalculate s_playerCount as the highest active slot + 1.
+				// A blind decrement would hide players at higher-indexed slots when a
+				// lower-indexed player disconnects first: GetPlayerBySmallId scans
+				// [0, s_playerCount) so any slot at or above the decremented count
+				// becomes invisible, causing its disconnect to be missed (ghost player).
+				while (IQNet::s_playerCount > 1 &&
+					   IQNet::m_player[IQNet::s_playerCount - 1].GetCustomDataValue() == 0)
 					IQNet::s_playerCount--;
 			}
+			// NOTE: Do NOT call PushFreeSmallId here. The old PlayerConnection's
+			// write thread may still be alive (it dies in PlayerList::tick when
+			// m_smallIdsToClose is processed). If we recycle the smallId now,
+			// AcceptThread can reuse it for a new connection, and the old write
+			// thread's getPlayer() lookup will resolve to the NEW player, sending
+			// stale game packets to the new client's TCP socket — corrupting its
+			// login handshake (bad packet id crash). PushFreeSmallId and
+			// ClearSocketForSmallId are called from PlayerList::tick after the
+			// old Connection threads are dead.
+			//
+			// Clear chunk visibility flags for this system so rejoin gets fresh chunk state.
+			SystemFlagRemoveBySmallId(disconnectedSmallId);
+		}
+	}
+
+	// Client-side host disconnect detection:
+	// if TCP is gone, propagate through normal network-disconnect flow so UI returns to menus.
+	// The processing from the Xbox version will be reused.
+	if (_iQNetStubState == QNET_STATE_GAME_PLAY && !m_pIQNet->IsHost() && !m_bLeavingGame)
+	{
+		if (!WinsockNetLayer::IsConnected())
+		{
+			if (!m_bLeaveGameOnTick)
+			{
+				m_bLeaveGameOnTick = true;
+				g_NetworkManager.HandleDisconnect(false);
+			}
+		}
+		else
+		{
+			m_bLeaveGameOnTick = false;
 		}
 	}
 #endif
 }
 
+bool CPlatformNetworkManagerStub::CanAcceptMoreConnections()
+{
+#ifdef _WINDOWS64
+	MinecraftServer* server = MinecraftServer::getInstance();
+	if (server == NULL) return true;
+	PlayerList* list = server->getPlayerList();
+	if (list == NULL) return true;
+	return static_cast<unsigned int>(list->players.size()) < static_cast<unsigned int>(list->getMaxPlayers());
+#else
+	return true;
+#endif
+}
+
 int CPlatformNetworkManagerStub::GetPlayerCount()
 {
 	return m_pIQNet->GetPlayerCount();
@@ -267,12 +320,40 @@ int CPlatformNetworkManagerStub::GetLocalPlayerMask(int playerIndex)
 
 bool CPlatformNetworkManagerStub::AddLocalPlayerByUserIndex( int userIndex )
 {
-	NotifyPlayerJoined(m_pIQNet->GetLocalPlayerByUserIndex(userIndex));
-	return ( m_pIQNet->AddLocalPlayerByUserIndex(userIndex) == S_OK );
+	if ( m_pIQNet->AddLocalPlayerByUserIndex(userIndex) != S_OK )
+		return false;
+	// Player is now registered in IQNet — get a pointer and notify the network layer.
+	// Use the static array directly: GetLocalPlayerByUserIndex checks customData which
+	// isn't set until addNetworkPlayer runs inside NotifyPlayerJoined.
+	NotifyPlayerJoined(&IQNet::m_player[userIndex]);
+	return true;
 }
 
 bool CPlatformNetworkManagerStub::RemoveLocalPlayerByUserIndex( int userIndex )
 {
+#ifdef _WINDOWS64
+	if (userIndex > 0 && userIndex < XUSER_MAX_COUNT && !m_pIQNet->IsHost())
+	{
+		IQNetPlayer* qp = &IQNet::m_player[userIndex];
+
+		// Notify the network layer before clearing the slot
+		if (qp->GetCustomDataValue() != 0)
+		{
+			NotifyPlayerLeaving(qp);
+		}
+
+		// Close the split-screen TCP connection and reset WinsockNetLayer state
+		WinsockNetLayer::CloseSplitScreenConnection(userIndex);
+
+		// Clear the IQNet slot so it can be reused on rejoin
+		qp->m_smallId = 0;
+		qp->m_isRemote = false;
+		qp->m_isHostPlayer = false;
+		qp->m_resolvedXuid = INVALID_XUID;
+		qp->m_gamertag[0] = 0;
+		qp->SetCustomDataValue(0);
+	}
+#endif
 	return true;
 }
 
@@ -300,6 +381,7 @@ bool CPlatformNetworkManagerStub::LeaveGame(bool bMigrateHost)
 	if( m_bLeavingGame ) return true;
 
 	m_bLeavingGame = true;
+	m_bLeaveGameOnTick = false;
 
 #ifdef _WINDOWS64
 	WinsockNetLayer::StopAdvertising();
@@ -348,13 +430,16 @@ void CPlatformNetworkManagerStub::HostGame(int localUsersMask, bool bOnlineGame,
 	localUsersMask |= GetLocalPlayerMask( g_NetworkManager.GetPrimaryPad() );
 
 	m_bLeavingGame = false;
+	m_bLeaveGameOnTick = false;
 
 	m_pIQNet->HostGame();
 
 #ifdef _WINDOWS64
 	IQNet::m_player[0].m_smallId = 0;
 	IQNet::m_player[0].m_isRemote = false;
+	// world host is pinned to legacy host XUID to keep old player data compatibility.
 	IQNet::m_player[0].m_isHostPlayer = true;
+	IQNet::m_player[0].m_resolvedXuid = Win64Xuid::GetLegacyEmbeddedHostXuid();
 	IQNet::s_playerCount = 1;
 #endif
 
@@ -362,7 +447,7 @@ void CPlatformNetworkManagerStub::HostGame(int localUsersMask, bool bOnlineGame,
 
 #ifdef _WINDOWS64
 	int port = WIN64_NET_DEFAULT_PORT;
-	const char* bindIp = NULL;
+	const char* bindIp = nullptr;
 	if (g_Win64DedicatedServer)
 	{
 		if (g_Win64DedicatedServerPort > 0)
@@ -375,9 +460,23 @@ void CPlatformNetworkManagerStub::HostGame(int localUsersMask, bool bOnlineGame,
 
 	if (WinsockNetLayer::IsActive())
 	{
-		const wchar_t* hostName = IQNet::m_player[0].m_gamertag;
-		unsigned int settings = app.GetGameHostOption(eGameHostOption_All);
-		WinsockNetLayer::StartAdvertising(port, hostName, settings, 0, 0, MINECRAFT_NET_VERSION);
+		// For Dedicated Server, refer to `lan-advertise` in `server.properties`
+		bool enableLanAdvertising = true;
+		if (g_Win64DedicatedServer)
+		{
+			enableLanAdvertising = g_Win64DedicatedServerLanAdvertise;
+		}
+
+		if (enableLanAdvertising)
+		{
+			const wchar_t* hostName = IQNet::m_player[0].m_gamertag;
+			unsigned int settings = app.GetGameHostOption(eGameHostOption_All);
+			WinsockNetLayer::StartAdvertising(port, hostName, settings, 0, 0, MINECRAFT_NET_VERSION);
+		}
+		else
+		{
+			WinsockNetLayer::StopAdvertising();
+		}
 	}
 #endif
 //#endif
@@ -395,7 +494,7 @@ bool CPlatformNetworkManagerStub::_StartGame()
 int CPlatformNetworkManagerStub::JoinGame(FriendSessionInfo* searchResult, int localUsersMask, int primaryUserIndex)
 {
 #ifdef _WINDOWS64
-	if (searchResult == NULL)
+	if (searchResult == nullptr)
 		return CGameNetworkManager::JOINGAME_FAIL_GENERAL;
 
 	const char* hostIP = searchResult->data.hostIP;
@@ -405,12 +504,15 @@ int CPlatformNetworkManagerStub::JoinGame(FriendSessionInfo* searchResult, int l
 		return CGameNetworkManager::JOINGAME_FAIL_GENERAL;
 
 	m_bLeavingGame = false;
+	m_bLeaveGameOnTick = false;
 	IQNet::s_isHosting = false;
 	m_pIQNet->ClientJoinGame();
 
 	IQNet::m_player[0].m_smallId = 0;
 	IQNet::m_player[0].m_isRemote = true;
 	IQNet::m_player[0].m_isHostPlayer = true;
+	// Remote host still maps to legacy host XUID in mixed old/new sessions.
+	IQNet::m_player[0].m_resolvedXuid = Win64Xuid::GetLegacyEmbeddedHostXuid();
 	wcsncpy_s(IQNet::m_player[0].m_gamertag, 32, searchResult->data.hostName, _TRUNCATE);
 
 	WinsockNetLayer::StopDiscovery();
@@ -426,6 +528,8 @@ int CPlatformNetworkManagerStub::JoinGame(FriendSessionInfo* searchResult, int l
 	IQNet::m_player[localSmallId].m_smallId = localSmallId;
 	IQNet::m_player[localSmallId].m_isRemote = false;
 	IQNet::m_player[localSmallId].m_isHostPlayer = false;
+	// Local non-host identity is the persistent uid.dat XUID.
+	IQNet::m_player[localSmallId].m_resolvedXuid = Win64Xuid::ResolvePersistentXuid();
 
 	Minecraft* pMinecraft = Minecraft::GetInstance();
 	wcscpy_s(IQNet::m_player[localSmallId].m_gamertag, 32, pMinecraft->user->name.c_str());
@@ -465,8 +569,8 @@ void CPlatformNetworkManagerStub::UnRegisterPlayerChangedCallback(int iPad, void
 {
 	if(playerChangedCallbackParam[iPad] == callbackParam)
 	{
-		playerChangedCallback[iPad] = NULL;
-		playerChangedCallbackParam[iPad] = NULL;
+		playerChangedCallback[iPad] = nullptr;
+		playerChangedCallbackParam[iPad] = nullptr;
 	}
 }
 
@@ -486,7 +590,7 @@ bool CPlatformNetworkManagerStub::_RunNetworkGame()
 		if (IQNet::m_player[i].m_isRemote)
 		{
 			INetworkPlayer* pNetworkPlayer = getNetworkPlayer(&IQNet::m_player[i]);
-			if (pNetworkPlayer != NULL && pNetworkPlayer->GetSocket() != NULL)
+			if (pNetworkPlayer != nullptr && pNetworkPlayer->GetSocket() != nullptr)
 			{
 				Socket::addIncomingSocket(pNetworkPlayer->GetSocket());
 			}
@@ -496,14 +600,14 @@ bool CPlatformNetworkManagerStub::_RunNetworkGame()
 	return true;
 }
 
-void CPlatformNetworkManagerStub::UpdateAndSetGameSessionData(INetworkPlayer *pNetworkPlayerLeaving /*= NULL*/)
+void CPlatformNetworkManagerStub::UpdateAndSetGameSessionData(INetworkPlayer *pNetworkPlayerLeaving /*= nullptr*/)
 {
 // 	DWORD playerCount = m_pIQNet->GetPlayerCount();
 //
 // 	if( this->m_bLeavingGame )
 // 		return;
 //
-// 	if( GetHostPlayer() == NULL )
+// 	if( GetHostPlayer() == nullptr )
 // 		return;
 //
 // 	for(unsigned int i = 0; i < MINECRAFT_NET_MAX_PLAYERS; ++i)
@@ -523,13 +627,13 @@ void CPlatformNetworkManagerStub::UpdateAndSetGameSessionData(INetworkPlayer *pN
 // 			}
 // 			else
 // 			{
-// 				m_hostGameSessionData.players[i] = NULL;
+// 				m_hostGameSessionData.players[i] = nullptr;
 // 				memset(m_hostGameSessionData.szPlayers[i],0,XUSER_NAME_SIZE);
 // 			}
 // 		}
 // 		else
 // 		{
-// 			m_hostGameSessionData.players[i] = NULL;
+// 			m_hostGameSessionData.players[i] = nullptr;
 // 			memset(m_hostGameSessionData.szPlayers[i],0,XUSER_NAME_SIZE);
 // 		}
 // 	}
@@ -540,18 +644,18 @@ void CPlatformNetworkManagerStub::UpdateAndSetGameSessionData(INetworkPlayer *pN
 
 int CPlatformNetworkManagerStub::RemovePlayerOnSocketClosedThreadProc( void* lpParam )
 {
-	INetworkPlayer *pNetworkPlayer = (INetworkPlayer *)lpParam;
+	INetworkPlayer *pNetworkPlayer = static_cast<INetworkPlayer *>(lpParam);
 
 	Socket *socket = pNetworkPlayer->GetSocket();
 
-	if( socket != NULL )
+	if( socket != nullptr )
 	{
 		//printf("Waiting for socket closed event\n");
 		socket->m_socketClosedEvent->WaitForSignal(INFINITE);
 
 		//printf("Socket closed event has fired\n");
 		// 4J Stu - Clear our reference to this socket
-		pNetworkPlayer->SetSocket( NULL );
+		pNetworkPlayer->SetSocket( nullptr );
 		delete socket;
 	}
 
@@ -573,6 +677,7 @@ CPlatformNetworkManagerStub::PlayerFlags::PlayerFlags(INetworkPlayer *pNetworkPl
 	this->flags = new unsigned char [ count / 8 ];
 	memset( this->flags, 0, count / 8 );
 	this->count = count;
+	this->m_smallId = (pNetworkPlayer && pNetworkPlayer->IsLocal()) ? 256 : (pNetworkPlayer ? static_cast<int>(pNetworkPlayer->GetSmallId()) : -1);
 }
 CPlatformNetworkManagerStub::PlayerFlags::~PlayerFlags()
 {
@@ -610,6 +715,23 @@ void CPlatformNetworkManagerStub::SystemFlagRemovePlayer(INetworkPlayer *pNetwor
 	}
 }
 
+// Clear chunk flags for a system when they disconnect (by smallId). Call even when we don't find the player,
+// so we always clear and the smallId can be reused without stale "chunk seen" state.
+void CPlatformNetworkManagerStub::SystemFlagRemoveBySmallId(int smallId)
+{
+	if (smallId < 0) return;
+	for (unsigned int i = 0; i < m_playerFlags.size(); i++)
+	{
+		if (m_playerFlags[i]->m_smallId == smallId)
+		{
+			delete m_playerFlags[i];
+			m_playerFlags[i] = m_playerFlags.back();
+			m_playerFlags.pop_back();
+			return;
+		}
+	}
+}
+
 void CPlatformNetworkManagerStub::SystemFlagReset()
 {
 	for( unsigned int i = 0; i < m_playerFlags.size(); i++ )
@@ -623,7 +745,7 @@ void CPlatformNetworkManagerStub::SystemFlagReset()
 void CPlatformNetworkManagerStub::SystemFlagSet(INetworkPlayer *pNetworkPlayer, int index)
 {
 	if( ( index < 0 ) || ( index >= m_flagIndexSize ) ) return;
-	if( pNetworkPlayer == NULL ) return;
+	if( pNetworkPlayer == nullptr ) return;
 
 	for( unsigned int i = 0; i < m_playerFlags.size(); i++ )
 	{
@@ -639,7 +761,7 @@ void CPlatformNetworkManagerStub::SystemFlagSet(INetworkPlayer *pNetworkPlayer,
 bool CPlatformNetworkManagerStub::SystemFlagGet(INetworkPlayer *pNetworkPlayer, int index)
 {
 	if( ( index < 0 ) || ( index >= m_flagIndexSize ) ) return false;
-	if( pNetworkPlayer == NULL )
+	if( pNetworkPlayer == nullptr )
 	{
 		return false;
 	}
@@ -667,7 +789,7 @@ wstring CPlatformNetworkManagerStub::GatherRTTStats()
 
 	for(unsigned int i = 0; i < GetPlayerCount(); ++i)
 	{
-		IQNetPlayer *pQNetPlayer = ((NetworkPlayerXbox *)GetPlayerByIndex( i ))->GetQNetPlayer();
+		IQNetPlayer *pQNetPlayer = static_cast<NetworkPlayerXbox *>(GetPlayerByIndex(i))->GetQNetPlayer();
 
 		if(!pQNetPlayer->IsLocal())
 		{
@@ -682,7 +804,7 @@ wstring CPlatformNetworkManagerStub::GatherRTTStats()
 void CPlatformNetworkManagerStub::TickSearch()
 {
 #ifdef _WINDOWS64
-	if (m_SessionsUpdatedCallback == NULL)
+	if (m_SessionsUpdatedCallback == nullptr)
 		return;
 
 	static DWORD lastSearchTime = 0;
@@ -711,7 +833,7 @@ void CPlatformNetworkManagerStub::SearchForGames()
 		size_t nameLen = wcslen(lanSessions[i].hostName);
 		info->displayLabel = new wchar_t[nameLen + 1];
 		wcscpy_s(info->displayLabel, nameLen + 1, lanSessions[i].hostName);
-		info->displayLabelLength = (unsigned char)nameLen;
+		info->displayLabelLength = static_cast<unsigned char>(nameLen);
 		info->displayLabelViewableStartIndex = 0;
 
 		info->data.netVersion = lanSessions[i].netVersion;
@@ -726,63 +848,64 @@ void CPlatformNetworkManagerStub::SearchForGames()
 		info->data.playerCount = lanSessions[i].playerCount;
 		info->data.maxPlayers = lanSessions[i].maxPlayers;
 
-		info->sessionId = (SessionID)((unsigned __int64)inet_addr(lanSessions[i].hostIP) | ((unsigned __int64)lanSessions[i].hostPort << 32));
+        info->sessionId = static_cast<uint64_t>(inet_addr(lanSessions[i].hostIP)) |
+                          static_cast<uint64_t>(lanSessions[i].hostPort) << 32;
 
 		friendsSessions[0].push_back(info);
 	}
 
-	std::FILE* file = std::fopen("servers.txt", "r");
-
-	if (file) {
-		wstring wline;
-		int phase = 0;
-
-		string ip;
-		wstring port;
-		wstring name;
+	if (std::FILE* file = std::fopen("servers.db", "rb")) {
+		char magic[4] = {};
+		if (std::fread(magic, 1, 4, file) == 4 && memcmp(magic, "MCSV", 4) == 0)
+		{
+			uint32_t version = 0, count = 0;
+			std::fread(&version, sizeof(uint32_t), 1, file);
+			std::fread(&count, sizeof(uint32_t), 1, file);
 
-		char buffer[512];
-		while (std::fgets(buffer, sizeof(buffer), file)) {
-			if (phase == 0) {
-				ip = buffer;
-				if (!ip.empty() && (ip.back() == '\n' || ip.back() == '\r'))
-					ip.pop_back();
-				phase = 1;
-			}
-			else if (phase == 1) {
-				wline = convStringToWstring(buffer);
-				port = wline;
-				phase = 2;
-			}
-			else if (phase == 2) {
-				wline = convStringToWstring(buffer);
-				name = wline;
-				phase = 0;
-
-				//THEY GET DELETED AFTER USE LIKE 30 LINES UP!!
-				FriendSessionInfo* info = new FriendSessionInfo();
-				wchar_t label[128];
-				wcsncpy_s(label, sizeof(label)/sizeof(wchar_t), name.c_str(), _TRUNCATE);
-				size_t nameLen = wcslen(label);
-				info->displayLabel = new wchar_t[nameLen+1];
-				wcscpy_s(info->displayLabel, nameLen + 1, label);
-				info->displayLabelLength = (unsigned char)nameLen;
-				info->displayLabelViewableStartIndex = 0;
-				info->data.isReadyToJoin = true;
-				info->data.isJoinable = true;
-				strncpy_s(info->data.hostIP, sizeof(info->data.hostIP), ip.c_str(), _TRUNCATE);
-				info->data.hostPort = stoi(port);
-				info->sessionId = (SessionID)(static_cast<uint64_t>(inet_addr(ip.c_str())) | (static_cast<uint64_t>(stoi(port)) << 32));
-				friendsSessions[0].push_back(info);
+			if (version == 1)
+			{
+				for (uint32_t s = 0; s < count; s++)
+				{
+					uint16_t ipLen = 0, port = 0, nameLen = 0;
+					if (std::fread(&ipLen, sizeof(uint16_t), 1, file) != 1) break;
+					if (ipLen == 0 || ipLen > 256) break;
+
+					char ipBuf[257] = {};
+					if (std::fread(ipBuf, 1, ipLen, file) != ipLen) break;
+					if (std::fread(&port, sizeof(uint16_t), 1, file) != 1) break;
+
+					if (std::fread(&nameLen, sizeof(uint16_t), 1, file) != 1) break;
+					if (nameLen > 256) break;
+
+					char nameBuf[257] = {};
+					if (nameLen > 0)
+					{
+						if (std::fread(nameBuf, 1, nameLen, file) != nameLen) break;
+					}
+
+					wstring wName = convStringToWstring(nameBuf);
+
+					FriendSessionInfo* info = new FriendSessionInfo();
+					size_t nLen = wName.length();
+					info->displayLabel = new wchar_t[nLen + 1];
+					wcscpy_s(info->displayLabel, nLen + 1, wName.c_str());
+					info->displayLabelLength = static_cast<unsigned char>(nLen);
+					info->displayLabelViewableStartIndex = 0;
+					info->data.isReadyToJoin = true;
+					info->data.isJoinable = true;
+					strncpy_s(info->data.hostIP, sizeof(info->data.hostIP), ipBuf, _TRUNCATE);
+					info->data.hostPort = port;
+					info->sessionId = static_cast<uint64_t>(inet_addr(ipBuf)) | static_cast<uint64_t>(port) << 32;
+					friendsSessions[0].push_back(info);
+				}
 			}
 		}
-
 		std::fclose(file);
 	}
 
-	m_searchResultsCount[0] = (int)friendsSessions[0].size();
+	m_searchResultsCount[0] = static_cast<int>(friendsSessions[0].size());
 
-	if (m_SessionsUpdatedCallback != NULL)
+	if (m_SessionsUpdatedCallback != nullptr)
 		m_SessionsUpdatedCallback(m_pSearchParam);
 #endif
 }
@@ -802,7 +925,7 @@ vector<FriendSessionInfo *> *CPlatformNetworkManagerStub::GetSessionList(int iPa
 {
 	vector<FriendSessionInfo*>* filteredList = new vector<FriendSessionInfo*>();
 	for (size_t i = 0; i < friendsSessions[0].size(); i++)
-		filteredList->push_back(friendsSessions[0][i]);
+		filteredList->push_back(new FriendSessionInfo(*friendsSessions[0][i]));
 	return filteredList;
 }
 
@@ -830,7 +953,7 @@ void CPlatformNetworkManagerStub::ForceFriendsSessionRefresh()
 		m_searchResultsCount[i] = 0;
 		m_lastSearchStartTime[i] = 0;
 		delete m_pSearchResults[i];
-		m_pSearchResults[i] = NULL;
+		m_pSearchResults[i] = nullptr;
 	}
 }
 
@@ -857,7 +980,7 @@ void CPlatformNetworkManagerStub::removeNetworkPlayer(IQNetPlayer *pQNetPlayer)
 
 INetworkPlayer *CPlatformNetworkManagerStub::getNetworkPlayer(IQNetPlayer *pQNetPlayer)
 {
-	return pQNetPlayer ? (INetworkPlayer *)(pQNetPlayer->GetCustomDataValue()) : NULL;
+	return pQNetPlayer ? (INetworkPlayer *)(pQNetPlayer->GetCustomDataValue()) : nullptr;
 }
 
 
diff --git a/Minecraft.Client/Common/Network/PlatformNetworkManagerStub.h b/Minecraft.Client/Common/Network/PlatformNetworkManagerStub.h
index 28953cec..4a3f4068 100644
--- a/Minecraft.Client/Common/Network/PlatformNetworkManagerStub.h
+++ b/Minecraft.Client/Common/Network/PlatformNetworkManagerStub.h
@@ -81,7 +81,7 @@ private:
 	GameSessionData m_hostGameSessionData;
 	CGameNetworkManager *m_pGameNetworkManager;
 public:
-	virtual void UpdateAndSetGameSessionData(INetworkPlayer *pNetworkPlayerLeaving = NULL);
+	virtual void UpdateAndSetGameSessionData(INetworkPlayer *pNetworkPlayerLeaving = nullptr);
 
 private:
 	// TODO 4J Stu - Do we need to be able to have more than one of these?
@@ -98,12 +98,14 @@ private:
 		INetworkPlayer *m_pNetworkPlayer;
 		unsigned char *flags;
 		unsigned int count;
+		int m_smallId;
 		PlayerFlags(INetworkPlayer *pNetworkPlayer, unsigned int count);
 		~PlayerFlags();
 	};
 	vector<PlayerFlags *> m_playerFlags;
 	void SystemFlagAddPlayer(INetworkPlayer *pNetworkPlayer);
 	void SystemFlagRemovePlayer(INetworkPlayer *pNetworkPlayer);
+	void SystemFlagRemoveBySmallId(int smallId);
 	void SystemFlagReset();
 public:
 	virtual void SystemFlagSet(INetworkPlayer *pNetworkPlayer, int index);
@@ -161,6 +163,9 @@ public:
 	virtual void GetFullFriendSessionInfo( FriendSessionInfo *foundSession, void (* FriendSessionUpdatedFn)(bool success, void *pParam), void *pParam );
 	virtual void ForceFriendsSessionRefresh();
 
+	// Win64: used by accept thread to reject connections when server is at max players (so we don't assign smallId > max).
+	bool CanAcceptMoreConnections();
+
 public:
 	void NotifyPlayerJoined( IQNetPlayer *pQNetPlayer );
 	void NotifyPlayerLeaving(IQNetPlayer* pQNetPlayer);
diff --git a/Minecraft.Client/Common/Network/SessionInfo.h b/Minecraft.Client/Common/Network/SessionInfo.h
index ce6365bc..4e091c87 100644
--- a/Minecraft.Client/Common/Network/SessionInfo.h
+++ b/Minecraft.Client/Common/Network/SessionInfo.h
@@ -113,15 +113,42 @@ public:
 
 	FriendSessionInfo()
 	{
-		displayLabel = NULL;
+		displayLabel = nullptr;
 		displayLabelLength = 0;
 		displayLabelViewableStartIndex = 0;
 		hasPartyMember = false;
 	}
 
+	FriendSessionInfo(const FriendSessionInfo& other)
+	{
+		sessionId = other.sessionId;
+#ifdef _XBOX
+		searchResult = other.searchResult;
+#elif defined(__PS3__) || defined(__ORBIS__) || defined (__PSVITA__)
+		searchResult = other.searchResult;
+#elif defined(_DURANGO)
+		searchResult = other.searchResult;
+#endif
+		displayLabelLength = other.displayLabelLength;
+		displayLabelViewableStartIndex = other.displayLabelViewableStartIndex;
+		data = other.data;
+		hasPartyMember = other.hasPartyMember;
+		if (other.displayLabel != NULL)
+		{
+			displayLabel = new wchar_t[displayLabelLength + 1];
+			wcscpy_s(displayLabel, displayLabelLength + 1, other.displayLabel);
+		}
+		else
+		{
+			displayLabel = NULL;
+		}
+	}
+
+	FriendSessionInfo& operator=(const FriendSessionInfo&) = delete;
+
 	~FriendSessionInfo()
 	{
-		if (displayLabel != NULL)
-			delete displayLabel;
+		if (displayLabel != nullptr)
+			delete[] displayLabel;
 	}
 };
diff --git a/Minecraft.Client/Common/Network/Sony/NetworkPlayerSony.cpp b/Minecraft.Client/Common/Network/Sony/NetworkPlayerSony.cpp
index a7a4628b..a1cc4038 100644
--- a/Minecraft.Client/Common/Network/Sony/NetworkPlayerSony.cpp
+++ b/Minecraft.Client/Common/Network/Sony/NetworkPlayerSony.cpp
@@ -4,7 +4,7 @@
 NetworkPlayerSony::NetworkPlayerSony(SQRNetworkPlayer *qnetPlayer)
 {
 	m_sqrPlayer = qnetPlayer;
-	m_pSocket = NULL;
+	m_pSocket = nullptr;
 	m_lastChunkPacketTime = 0;
 }
 
@@ -16,12 +16,12 @@ unsigned char NetworkPlayerSony::GetSmallId()
 void NetworkPlayerSony::SendData(INetworkPlayer *player, const void *pvData, int dataSize, bool lowPriority, bool ack)
 {
 	// TODO - handle priority
-	m_sqrPlayer->SendData( ((NetworkPlayerSony *)player)->m_sqrPlayer, pvData, dataSize, ack );
+	m_sqrPlayer->SendData( static_cast<NetworkPlayerSony *>(player)->m_sqrPlayer, pvData, dataSize, ack );
 }
 
 bool NetworkPlayerSony::IsSameSystem(INetworkPlayer *player)
 {
-	return m_sqrPlayer->IsSameSystem(((NetworkPlayerSony *)player)->m_sqrPlayer);
+	return m_sqrPlayer->IsSameSystem(static_cast<NetworkPlayerSony *>(player)->m_sqrPlayer);
 }
 
 int NetworkPlayerSony::GetOutstandingAckCount()
@@ -132,6 +132,6 @@ int NetworkPlayerSony::GetTimeSinceLastChunkPacket_ms()
 		return INT_MAX;
 	}
 
-	__int64 currentTime = System::currentTimeMillis();
-	return (int)( currentTime - m_lastChunkPacketTime );
+	int64_t currentTime = System::currentTimeMillis();
+	return static_cast<int>(currentTime - m_lastChunkPacketTime);
 }
diff --git a/Minecraft.Client/Common/Network/Sony/NetworkPlayerSony.h b/Minecraft.Client/Common/Network/Sony/NetworkPlayerSony.h
index f3415a41..2c61f78d 100644
--- a/Minecraft.Client/Common/Network/Sony/NetworkPlayerSony.h
+++ b/Minecraft.Client/Common/Network/Sony/NetworkPlayerSony.h
@@ -39,5 +39,5 @@ public:
 private:
 	SQRNetworkPlayer *m_sqrPlayer;
 	Socket *m_pSocket;
-	__int64 m_lastChunkPacketTime;
+	int64_t m_lastChunkPacketTime;
 };
diff --git a/Minecraft.Client/Common/Network/Sony/PlatformNetworkManagerSony.cpp b/Minecraft.Client/Common/Network/Sony/PlatformNetworkManagerSony.cpp
index a9799d26..107101f4 100644
--- a/Minecraft.Client/Common/Network/Sony/PlatformNetworkManagerSony.cpp
+++ b/Minecraft.Client/Common/Network/Sony/PlatformNetworkManagerSony.cpp
@@ -123,7 +123,7 @@ void CPlatformNetworkManagerSony::HandleDataReceived(SQRNetworkPlayer *playerFro
 		INetworkPlayer *pPlayerFrom = getNetworkPlayer(playerFrom);
 		Socket *socket = pPlayerFrom->GetSocket();
 
-		if(socket != NULL)
+		if(socket != nullptr)
 			socket->pushDataToQueue(data, dataSize, false);
 	}
 	else
@@ -132,7 +132,7 @@ void CPlatformNetworkManagerSony::HandleDataReceived(SQRNetworkPlayer *playerFro
 		INetworkPlayer *pPlayerTo = getNetworkPlayer(playerTo);
 		Socket *socket = pPlayerTo->GetSocket();
 		//app.DebugPrintf( "Pushing data into read queue for user \"%ls\"\n", apPlayersTo[dwPlayer]->GetGamertag());
-		if(socket != NULL)
+		if(socket != nullptr)
 			socket->pushDataToQueue(data, dataSize);
 	}
 }
@@ -226,7 +226,7 @@ void CPlatformNetworkManagerSony::HandlePlayerJoined(SQRNetworkPlayer *
 
 	for( int idx = 0; idx < XUSER_MAX_COUNT; ++idx)
 	{
-		if(playerChangedCallback[idx] != NULL)
+		if(playerChangedCallback[idx] != nullptr)
 			playerChangedCallback[idx]( playerChangedCallbackParam[idx], networkPlayer, false );
 	}
 
@@ -235,7 +235,7 @@ void CPlatformNetworkManagerSony::HandlePlayerJoined(SQRNetworkPlayer *
 		int localPlayerCount = 0;
 		for(unsigned int idx = 0; idx < XUSER_MAX_COUNT; ++idx)
 		{
-			if( m_pSQRNet->GetLocalPlayerByUserIndex(idx) != NULL ) ++localPlayerCount;
+			if( m_pSQRNet->GetLocalPlayerByUserIndex(idx) != nullptr ) ++localPlayerCount;
 		}
 
 		float appTime = app.getAppTime();
@@ -258,7 +258,7 @@ void CPlatformNetworkManagerSony::HandlePlayerLeaving(SQRNetworkPlayer *pSQRPlay
 	{
 		// Get our wrapper object associated with this player.
 		Socket *socket = networkPlayer->GetSocket();
-		if( socket != NULL )
+		if( socket != nullptr )
 		{
 			// If we are in game then remove this player from the game as well.
 			// We may get here either from the player requesting to exit the game,
@@ -274,19 +274,19 @@ void CPlatformNetworkManagerSony::HandlePlayerLeaving(SQRNetworkPlayer *pSQRPlay
 			// We need this as long as the game server still needs to communicate with the player
 			//delete socket;
 
-			networkPlayer->SetSocket( NULL );
+			networkPlayer->SetSocket( nullptr );
 		}
 
 		if( m_pSQRNet->IsHost() && !m_bHostChanged )
 		{
 			if( isSystemPrimaryPlayer(pSQRPlayer) )
 			{
-				SQRNetworkPlayer *pNewSQRPrimaryPlayer = NULL;
+				SQRNetworkPlayer *pNewSQRPrimaryPlayer = nullptr;
 				for(unsigned int i = 0; i < m_pSQRNet->GetPlayerCount(); ++i )
 				{
 					SQRNetworkPlayer *pSQRPlayer2 = m_pSQRNet->GetPlayerByIndex( i );
 
-					if ( pSQRPlayer2 != NULL && pSQRPlayer2 != pSQRPlayer && pSQRPlayer2->IsSameSystem( pSQRPlayer ) )
+					if ( pSQRPlayer2 != nullptr && pSQRPlayer2 != pSQRPlayer && pSQRPlayer2->IsSameSystem( pSQRPlayer ) )
 					{
 						pNewSQRPrimaryPlayer = pSQRPlayer2;
 						break;
@@ -298,7 +298,7 @@ void CPlatformNetworkManagerSony::HandlePlayerLeaving(SQRNetworkPlayer *pSQRPlay
 					m_machineSQRPrimaryPlayers.erase( it );
 				}
 
-				if( pNewSQRPrimaryPlayer != NULL )
+				if( pNewSQRPrimaryPlayer != nullptr )
 					m_machineSQRPrimaryPlayers.push_back( pNewSQRPrimaryPlayer );
 			}
 
@@ -311,7 +311,7 @@ void CPlatformNetworkManagerSony::HandlePlayerLeaving(SQRNetworkPlayer *pSQRPlay
 
 		for( int idx = 0; idx < XUSER_MAX_COUNT; ++idx)
 		{
-			if(playerChangedCallback[idx] != NULL)
+			if(playerChangedCallback[idx] != nullptr)
 				playerChangedCallback[idx]( playerChangedCallbackParam[idx], networkPlayer, true );
 		}
 
@@ -320,7 +320,7 @@ void CPlatformNetworkManagerSony::HandlePlayerLeaving(SQRNetworkPlayer *pSQRPlay
 			int localPlayerCount = 0;
 			for(unsigned int idx = 0; idx < XUSER_MAX_COUNT; ++idx)
 			{
-				if( m_pSQRNet->GetLocalPlayerByUserIndex(idx) != NULL ) ++localPlayerCount;
+				if( m_pSQRNet->GetLocalPlayerByUserIndex(idx) != nullptr ) ++localPlayerCount;
 			}
 
 			float appTime = app.getAppTime();
@@ -391,7 +391,7 @@ bool CPlatformNetworkManagerSony::Initialise(CGameNetworkManager *pGameNetworkMa
 	if(ProfileManager.IsSignedInPSN(ProfileManager.GetPrimaryPad()))
 	{
 		// we're signed into the PSN, but we won't be online yet, force a sign-in online here
-		m_pSQRNet_Vita->AttemptPSNSignIn(NULL, NULL);
+		m_pSQRNet_Vita->AttemptPSNSignIn(nullptr, nullptr);
 	}
 
 
@@ -402,7 +402,7 @@ bool CPlatformNetworkManagerSony::Initialise(CGameNetworkManager *pGameNetworkMa
 	g_pPlatformNetworkManager = this;
 	for( int i = 0; i < XUSER_MAX_COUNT; i++ )
 	{
-		playerChangedCallback[ i ] = NULL;
+		playerChangedCallback[ i ] = nullptr;
 	}
 
 	m_bLeavingGame = false;
@@ -413,11 +413,11 @@ bool CPlatformNetworkManagerSony::Initialise(CGameNetworkManager *pGameNetworkMa
 	m_bSearchPending = false;
 
 	m_bIsOfflineGame = false;
-	m_pSearchParam = NULL;
-	m_SessionsUpdatedCallback = NULL;
+	m_pSearchParam = nullptr;
+	m_SessionsUpdatedCallback = nullptr;
 
 	m_searchResultsCount = 0;
-	m_pSearchResults = NULL;
+	m_pSearchResults = nullptr;
 
 	m_lastSearchStartTime = 0;
 
@@ -622,11 +622,11 @@ bool CPlatformNetworkManagerSony::RemoveLocalPlayerByUserIndex( int userIndex )
 	SQRNetworkPlayer *pSQRPlayer = m_pSQRNet->GetLocalPlayerByUserIndex(userIndex);
 	INetworkPlayer *pNetworkPlayer = getNetworkPlayer(pSQRPlayer);
 
-	if(pNetworkPlayer != NULL)
+	if(pNetworkPlayer != nullptr)
 	{
 		Socket *socket = pNetworkPlayer->GetSocket();
 
-		if( socket != NULL )
+		if( socket != nullptr )
 		{
 			// We can't remove the player from qnet until we have stopped using it to communicate
 			C4JThread* thread = new C4JThread(&CPlatformNetworkManagerSony::RemovePlayerOnSocketClosedThreadProc, pNetworkPlayer, "RemovePlayerOnSocketClosed");
@@ -702,11 +702,11 @@ bool CPlatformNetworkManagerSony::LeaveGame(bool bMigrateHost)
 	SQRNetworkPlayer *pSQRPlayer = m_pSQRNet->GetLocalPlayerByUserIndex(g_NetworkManager.GetPrimaryPad());
 	INetworkPlayer *pNetworkPlayer = getNetworkPlayer(pSQRPlayer);
 
-	if(pNetworkPlayer != NULL)
+	if(pNetworkPlayer != nullptr)
 	{
 		Socket *socket = pNetworkPlayer->GetSocket();
 
-		if( socket != NULL )
+		if( socket != nullptr )
 		{
 			//printf("Waiting for socket closed event\n");
 			DWORD result = socket->m_socketClosedEvent->WaitForSignal(INFINITE);
@@ -718,13 +718,13 @@ bool CPlatformNetworkManagerSony::LeaveGame(bool bMigrateHost)
 				// 4J Stu - Clear our reference to this socket
 				pSQRPlayer = m_pSQRNet->GetLocalPlayerByUserIndex(g_NetworkManager.GetPrimaryPad());
 				pNetworkPlayer = getNetworkPlayer(pSQRPlayer);
-				pNetworkPlayer->SetSocket( NULL );
+				pNetworkPlayer->SetSocket( nullptr );
 			}
 			delete socket;
 		}
 		else
 		{
-			//printf("Socket is already NULL\n");
+			//printf("Socket is already nullptr\n");
 		}
 	}
 
@@ -878,8 +878,8 @@ void CPlatformNetworkManagerSony::UnRegisterPlayerChangedCallback(int iPad, void
 {
 	if(playerChangedCallbackParam[iPad] == callbackParam)
 	{
-		playerChangedCallback[iPad] = NULL;
-		playerChangedCallbackParam[iPad] = NULL;
+		playerChangedCallback[iPad] = nullptr;
+		playerChangedCallbackParam[iPad] = nullptr;
 	}
 }
 
@@ -917,7 +917,7 @@ bool CPlatformNetworkManagerSony::_RunNetworkGame()
 
 // Note that this does less than the xbox equivalent as we have HandleResyncPlayerRequest that is called by the underlying SQRNetworkManager when players are added/removed etc., so this
 // call is only used to update the game host settings & then do the final push out of the data.
-void CPlatformNetworkManagerSony::UpdateAndSetGameSessionData(INetworkPlayer *pNetworkPlayerLeaving /*= NULL*/)
+void CPlatformNetworkManagerSony::UpdateAndSetGameSessionData(INetworkPlayer *pNetworkPlayerLeaving /*= nullptr*/)
 {
 	if( this->m_bLeavingGame )
 		return;
@@ -934,7 +934,7 @@ void CPlatformNetworkManagerSony::UpdateAndSetGameSessionData(INetworkPlayer *pN
 
 	// If this is called With a pNetworkPlayerLeaving, then the call has ultimately started within SQRNetworkManager::RemoveRemotePlayersAndSync, so we don't need to sync each change
 	// as that function does a sync at the end of all changes.
-	if( pNetworkPlayerLeaving == NULL )
+	if( pNetworkPlayerLeaving == nullptr )
 	{
 		m_pSQRNet->UpdateExternalRoomData();
 	}
@@ -946,14 +946,14 @@ int CPlatformNetworkManagerSony::RemovePlayerOnSocketClosedThreadProc( void* lpP
 
 	Socket *socket = pNetworkPlayer->GetSocket();
 
-	if( socket != NULL )
+	if( socket != nullptr )
 	{
 		//printf("Waiting for socket closed event\n");
 		socket->m_socketClosedEvent->WaitForSignal(INFINITE);
 
 		//printf("Socket closed event has fired\n");
 		// 4J Stu - Clear our reference to this socket
-		pNetworkPlayer->SetSocket( NULL );
+		pNetworkPlayer->SetSocket( nullptr );
 		delete socket;
 	}
 
@@ -1030,7 +1030,7 @@ void CPlatformNetworkManagerSony::SystemFlagReset()
 void CPlatformNetworkManagerSony::SystemFlagSet(INetworkPlayer *pNetworkPlayer, int index)
 {
 	if( ( index < 0 ) || ( index >= m_flagIndexSize ) ) return;
-	if( pNetworkPlayer == NULL ) return;
+	if( pNetworkPlayer == nullptr ) return;
 
 	for( unsigned int i = 0; i < m_playerFlags.size(); i++ )
 	{
@@ -1046,7 +1046,7 @@ void CPlatformNetworkManagerSony::SystemFlagSet(INetworkPlayer *pNetworkPlayer,
 bool CPlatformNetworkManagerSony::SystemFlagGet(INetworkPlayer *pNetworkPlayer, int index)
 {
 	if( ( index < 0 ) || ( index >= m_flagIndexSize ) ) return false;
-	if( pNetworkPlayer == NULL )
+	if( pNetworkPlayer == nullptr )
 	{
 		return false;
 	}
@@ -1064,8 +1064,8 @@ bool CPlatformNetworkManagerSony::SystemFlagGet(INetworkPlayer *pNetworkPlayer,
 wstring CPlatformNetworkManagerSony::GatherStats()
 {
 #if 0
-	return L"Queue messages: " + std::to_wstring(((NetworkPlayerXbox *)GetHostPlayer())->GetQNetPlayer()->GetSendQueueSize( NULL, QNET_GETSENDQUEUESIZE_MESSAGES ) )
-		+ L" Queue bytes: " + std::to_wstring( ((NetworkPlayerXbox *)GetHostPlayer())->GetQNetPlayer()->GetSendQueueSize( NULL, QNET_GETSENDQUEUESIZE_BYTES  ) );
+	return L"Queue messages: " + std::to_wstring(((NetworkPlayerXbox *)GetHostPlayer())->GetQNetPlayer()->GetSendQueueSize( nullptr, QNET_GETSENDQUEUESIZE_MESSAGES ) )
+		+ L" Queue bytes: " + std::to_wstring( ((NetworkPlayerXbox *)GetHostPlayer())->GetQNetPlayer()->GetSendQueueSize( nullptr, QNET_GETSENDQUEUESIZE_BYTES  ) );
 #else
 	return L"";
 #endif
@@ -1111,7 +1111,7 @@ void CPlatformNetworkManagerSony::TickSearch()
 			}
 			m_bSearchPending = false;
 
-			if( m_SessionsUpdatedCallback != NULL ) m_SessionsUpdatedCallback(m_pSearchParam);
+			if( m_SessionsUpdatedCallback != nullptr ) m_SessionsUpdatedCallback(m_pSearchParam);
 		}
 	}
 	else
@@ -1126,7 +1126,7 @@ void CPlatformNetworkManagerSony::TickSearch()
 			if( usingAdhocMode())
 				searchDelay = 5000;
 #endif
-			if( m_SessionsUpdatedCallback != NULL && (m_lastSearchStartTime + searchDelay) < GetTickCount() )
+			if( m_SessionsUpdatedCallback != nullptr && (m_lastSearchStartTime + searchDelay) < GetTickCount() )
 			{
 				if( m_pSQRNet->FriendRoomManagerSearch() )
 				{
@@ -1189,7 +1189,7 @@ bool CPlatformNetworkManagerSony::GetGameSessionInfo(int iPad, SessionID session
 			if(memcmp( &pSearchResult->info.sessionID, &sessionId, sizeof(SessionID) ) != 0) continue;
 
 			bool foundSession = false;
-			FriendSessionInfo *sessionInfo = NULL;
+			FriendSessionInfo *sessionInfo = nullptr;
 			auto itFriendSession = friendsSessions[iPad].begin();
 			for(itFriendSession = friendsSessions[iPad].begin(); itFriendSession < friendsSessions[iPad].end(); ++itFriendSession)
 			{
@@ -1231,7 +1231,7 @@ bool CPlatformNetworkManagerSony::GetGameSessionInfo(int iPad, SessionID session
 					sessionInfo->data.isJoinable)
 				{
 					foundSessionInfo->data = sessionInfo->data;
-					if(foundSessionInfo->displayLabel != NULL) delete [] foundSessionInfo->displayLabel;
+					if(foundSessionInfo->displayLabel != nullptr) delete [] foundSessionInfo->displayLabel;
 					foundSessionInfo->displayLabel = new wchar_t[100];
 					memcpy(foundSessionInfo->displayLabel, sessionInfo->displayLabel, 100 * sizeof(wchar_t) );
 					foundSessionInfo->displayLabelLength = sessionInfo->displayLabelLength;
@@ -1267,7 +1267,7 @@ void CPlatformNetworkManagerSony::ForceFriendsSessionRefresh()
 	m_lastSearchStartTime = 0;
 	m_searchResultsCount = 0;
 	delete m_pSearchResults;
-	m_pSearchResults = NULL;
+	m_pSearchResults = nullptr;
 }
 
 INetworkPlayer *CPlatformNetworkManagerSony::addNetworkPlayer(SQRNetworkPlayer *pSQRPlayer)
@@ -1293,7 +1293,7 @@ void CPlatformNetworkManagerSony::removeNetworkPlayer(SQRNetworkPlayer *pSQRPlay
 
 INetworkPlayer *CPlatformNetworkManagerSony::getNetworkPlayer(SQRNetworkPlayer *pSQRPlayer)
 {
-	return pSQRPlayer ? (INetworkPlayer *)(pSQRPlayer->GetCustomDataValue()) : NULL;
+	return pSQRPlayer ? (INetworkPlayer *)(pSQRPlayer->GetCustomDataValue()) : nullptr;
 }
 
 
diff --git a/Minecraft.Client/Common/Network/Sony/PlatformNetworkManagerSony.h b/Minecraft.Client/Common/Network/Sony/PlatformNetworkManagerSony.h
index 258acd83..9131e897 100644
--- a/Minecraft.Client/Common/Network/Sony/PlatformNetworkManagerSony.h
+++ b/Minecraft.Client/Common/Network/Sony/PlatformNetworkManagerSony.h
@@ -102,7 +102,7 @@ private:
 	GameSessionData m_hostGameSessionData;
 	CGameNetworkManager *m_pGameNetworkManager;
 public:
-	virtual void UpdateAndSetGameSessionData(INetworkPlayer *pNetworkPlayerLeaving = NULL);
+	virtual void UpdateAndSetGameSessionData(INetworkPlayer *pNetworkPlayerLeaving = nullptr);
 
 private:
 	// TODO 4J Stu - Do we need to be able to have more than one of these?
diff --git a/Minecraft.Client/Common/Network/Sony/SQRNetworkManager.cpp b/Minecraft.Client/Common/Network/Sony/SQRNetworkManager.cpp
index f23a0a63..7561c17d 100644
--- a/Minecraft.Client/Common/Network/Sony/SQRNetworkManager.cpp
+++ b/Minecraft.Client/Common/Network/Sony/SQRNetworkManager.cpp
@@ -16,7 +16,7 @@ int SQRNetworkManager::GetSendQueueSizeBytes()
 	for(int i = 0; i < playerCount; ++i)
 	{
 		SQRNetworkPlayer *player = GetPlayerByIndex( i );
-		if( player != NULL )
+		if( player != nullptr )
 		{
 			queueSize += player->GetTotalSendQueueBytes();
 		}
@@ -31,7 +31,7 @@ int SQRNetworkManager::GetSendQueueSizeMessages()
 	for(int i = 0; i < playerCount; ++i)
 	{
 		SQRNetworkPlayer *player = GetPlayerByIndex( i );
-		if( player != NULL )
+		if( player != nullptr )
 		{
 			queueSize += player->GetTotalSendQueueMessages();
 		}
diff --git a/Minecraft.Client/Common/Network/Sony/SQRNetworkPlayer.cpp b/Minecraft.Client/Common/Network/Sony/SQRNetworkPlayer.cpp
index a040b28b..4ed27824 100644
--- a/Minecraft.Client/Common/Network/Sony/SQRNetworkPlayer.cpp
+++ b/Minecraft.Client/Common/Network/Sony/SQRNetworkPlayer.cpp
@@ -145,7 +145,7 @@ bool SQRNetworkPlayer::IsReady()
 {
 	return ( ( m_flags & SNP_FLAG_READY_MASK ) == SNP_FLAG_READY_MASK );
 }
-	
+
 PlayerUID SQRNetworkPlayer::GetUID()
 {
 	return m_ISD.m_UID;
@@ -224,7 +224,7 @@ void SQRNetworkPlayer::SendData( SQRNetworkPlayer *pPlayerTarget, const void *da
 {
 	AckFlags ackFlags = ack ? e_flag_AckRequested : e_flag_AckNotRequested;
 	// Our network is connected as a star. If we are the host, then we can send to any remote player. If we're a client, we can send only to the host.
-	// The host can also send to other local players, but this doesn't need to go through Rudp. 
+	// The host can also send to other local players, but this doesn't need to go through Rudp.
 	if( m_host )
 	{
 		if( ( m_type == SNP_TYPE_HOST ) && ( pPlayerTarget->m_type == SNP_TYPE_LOCAL ) )
@@ -279,14 +279,14 @@ void SQRNetworkPlayer::SendInternal(const void *data, unsigned int dataSize, Ack
 	{
 		// no data, just the flag
 		assert(dataSize == 0);
-		assert(data == NULL);
+		assert(data == nullptr);
 		int dataSize = dataRemaining;
 		if( dataSize > SNP_MAX_PAYLOAD ) dataSize = SNP_MAX_PAYLOAD;
-		sendBlock.start = NULL;
-		sendBlock.end = NULL;
-		sendBlock.current = NULL;
+		sendBlock.start = nullptr;
+		sendBlock.end = nullptr;
+		sendBlock.current = nullptr;
 		sendBlock.ack = ackFlags;
-		m_sendQueue.push(sendBlock);		
+		m_sendQueue.push(sendBlock);
 	}
 	else
 	{
@@ -299,13 +299,13 @@ void SQRNetworkPlayer::SendInternal(const void *data, unsigned int dataSize, Ack
 		sendBlock.current = sendBlock.start;
 			sendBlock.ack = ackFlags;
 		memcpy( sendBlock.start, dataCurrent, dataSize);
-		m_sendQueue.push(sendBlock);		
+		m_sendQueue.push(sendBlock);
 		dataRemaining -= dataSize;
 		dataCurrent += dataSize;
 	}
 
 	}
-	m_totalBytesInSendQueue += dataSize; 
+	m_totalBytesInSendQueue += dataSize;
 
 	// if the queue had something in it already, then the UDP callback will fire and call SendMoreInternal
 	// so we don't call it here, to avoid a deadlock
@@ -343,7 +343,7 @@ int SQRNetworkPlayer::WriteDataPacket(const void* data, int dataSize, AckFlags a
 		// nothing was sent!
 	}
 	else
-	{ 
+	{
 		assert(ret==packetSize || ret > headerSize); // we must make sure we've sent the entire packet or the header and some data at least
 		ret -= headerSize;
 		if(ackFlags == e_flag_AckRequested)
@@ -387,9 +387,9 @@ int SQRNetworkPlayer::ReadDataPacket(void* data, int dataSize)
 
 	unsigned char* packetData = new unsigned char[packetSize];
 #ifdef __PS3__
-	int bytesRead = cellRudpRead( m_rudpCtx, packetData, packetSize, 0, NULL );
+	int bytesRead = cellRudpRead( m_rudpCtx, packetData, packetSize, 0, nullptr );
 #else // __ORBIS__ && __PSVITA__
-	int bytesRead = sceRudpRead( m_rudpCtx, packetData, packetSize, 0, NULL );
+	int bytesRead = sceRudpRead( m_rudpCtx, packetData, packetSize, 0, nullptr );
 #endif
 	if(bytesRead == sc_wouldBlockFlag)
 	{
@@ -426,9 +426,9 @@ void SQRNetworkPlayer::ReadAck()
 {
 	DataPacketHeader header;
 #ifdef __PS3__
-	int bytesRead = cellRudpRead( m_rudpCtx, &header, sizeof(header), 0, NULL );
+	int bytesRead = cellRudpRead( m_rudpCtx, &header, sizeof(header), 0, nullptr );
 #else // __ORBIS__ && __PSVITA__
-	int bytesRead = sceRudpRead( m_rudpCtx, &header, sizeof(header), 0, NULL );
+	int bytesRead = sceRudpRead( m_rudpCtx, &header, sizeof(header), 0, nullptr );
 #endif
 	if(bytesRead == sc_wouldBlockFlag)
 	{
@@ -443,7 +443,7 @@ void SQRNetworkPlayer::ReadAck()
 
 #ifndef _CONTENT_PACKAGE
 #ifdef PRINT_ACK_STATS
-	__int64 timeTaken = System::currentTimeMillis() - m_ackStats[0];
+	int64_t timeTaken = System::currentTimeMillis() - m_ackStats[0];
 	if(timeTaken < m_minAckTime)
 		m_minAckTime = timeTaken;
 	if(timeTaken > m_maxAckTime)
@@ -459,7 +459,7 @@ void SQRNetworkPlayer::ReadAck()
 
 void SQRNetworkPlayer::WriteAck()
 {
-	SendInternal(NULL, 0, e_flag_AckReturning);
+	SendInternal(nullptr, 0, e_flag_AckReturning);
 }
 
 int SQRNetworkPlayer::GetOutstandingAckCount()
@@ -525,7 +525,7 @@ void SQRNetworkPlayer::SendMoreInternal()
 				{
 					keepSending = true;
 				}
-			} 
+			}
 			else if( ( ret >= 0 ) || ( ret == sc_wouldBlockFlag ) )
 			{
 
@@ -543,7 +543,7 @@ void SQRNetworkPlayer::SendMoreInternal()
 					// Is CELL_RUDP_ERROR_WOULDBLOCK, nothing has yet been sent
 					remainingBytes = dataSize;
 				}
-				m_sendQueue.front().current = m_sendQueue.front().end - remainingBytes;	
+				m_sendQueue.front().current = m_sendQueue.front().end - remainingBytes;
 			}
 		}
 	} while (keepSending);
diff --git a/Minecraft.Client/Common/Network/Sony/SQRNetworkPlayer.h b/Minecraft.Client/Common/Network/Sony/SQRNetworkPlayer.h
index d0efe635..c67069d1 100644
--- a/Minecraft.Client/Common/Network/Sony/SQRNetworkPlayer.h
+++ b/Minecraft.Client/Common/Network/Sony/SQRNetworkPlayer.h
@@ -63,16 +63,16 @@ class SQRNetworkPlayer
 	public:
 		DataPacketHeader() : m_dataSize(0), m_ackFlags(e_flag_AckUnknown) {}
 		DataPacketHeader(int dataSize, AckFlags ackFlags) : m_dataSize(dataSize), m_ackFlags(ackFlags) { }
-		AckFlags GetAckFlags() { return (AckFlags)m_ackFlags;}
+		AckFlags GetAckFlags() { return static_cast<AckFlags>(m_ackFlags);}
 		int GetDataSize() { return m_dataSize; }
 	};
 
 #ifndef _CONTENT_PACKAGE
-	std::vector<__int64> m_ackStats;
+	std::vector<int64_t> m_ackStats;
 	int m_minAckTime;
 	int m_maxAckTime;
 	int m_totalAcks;
-	__int64 m_totalAckTime;
+	int64_t m_totalAckTime;
 	int m_averageAckTime;
 #endif
 
@@ -89,7 +89,7 @@ class SQRNetworkPlayer
 	{
 	public:
 		unsigned char				m_smallId;				// Id to uniquely and permanently identify this player between machines - assigned by the server
-		PlayerUID					m_UID;			
+		PlayerUID					m_UID;
 	};
 
 	SQRNetworkPlayer(SQRNetworkManager *manager, eSQRNetworkPlayerType playerType, bool onHost, SceNpMatching2RoomMemberId roomMemberId, int localPlayerIdx, int rudpCtx, PlayerUID *pUID);
@@ -114,7 +114,7 @@ class SQRNetworkPlayer
 	int							WriteDataPacket(const void* data, int dataSize, AckFlags ackFlags);
 	void						ReadAck();
 	void						WriteAck();
-	
+
 	int							GetOutstandingAckCount();
 	int							GetSendQueueSizeBytes();
 	int							GetSendQueueSizeMessages();
diff --git a/Minecraft.Client/Common/Network/Sony/SonyRemoteStorage.cpp b/Minecraft.Client/Common/Network/Sony/SonyRemoteStorage.cpp
index 4468d163..47beb63c 100644
--- a/Minecraft.Client/Common/Network/Sony/SonyRemoteStorage.cpp
+++ b/Minecraft.Client/Common/Network/Sony/SonyRemoteStorage.cpp
@@ -25,12 +25,12 @@ static SceRemoteStorageStatus statParams;
 // {
 // 	app.DebugPrintf("remoteStorageGetCallback err : 0x%08x\n");
 // }
-// 
+//
 // void remoteStorageCallback(LPVOID lpParam, SonyRemoteStorage::Status s, int error_code)
 // {
 // 	app.DebugPrintf("remoteStorageCallback err : 0x%08x\n");
 // 
-// 	app.getRemoteStorage()->getRemoteFileInfo(&statParams, remoteStorageGetInfoCallback, NULL);
+// 	app.getRemoteStorage()->getRemoteFileInfo(&statParams, remoteStorageGetInfoCallback, nullptr);
 // }
 
 
@@ -39,13 +39,13 @@ static SceRemoteStorageStatus statParams;
 void SonyRemoteStorage::SetRetrievedDescData()
 {
 	DescriptionData* pDescDataTest = (DescriptionData*)m_remoteFileInfo->fileDescription;
-	ESavePlatform testPlatform = (ESavePlatform)MAKE_FOURCC(pDescDataTest->m_platform[0], pDescDataTest->m_platform[1], pDescDataTest->m_platform[2], pDescDataTest->m_platform[3]);
+	ESavePlatform testPlatform = static_cast<ESavePlatform>(MAKE_FOURCC(pDescDataTest->m_platform[0], pDescDataTest->m_platform[1], pDescDataTest->m_platform[2], pDescDataTest->m_platform[3]));
 	if(testPlatform == SAVE_FILE_PLATFORM_NONE)
 	{
 		// new version of the descData
 		DescriptionData_V2* pDescData2 = (DescriptionData_V2*)m_remoteFileInfo->fileDescription;
 		m_retrievedDescData.m_descDataVersion = GetU32FromHexBytes(pDescData2->m_descDataVersion);
-		m_retrievedDescData.m_savePlatform = (ESavePlatform)MAKE_FOURCC(pDescData2->m_platform[0], pDescData2->m_platform[1], pDescData2->m_platform[2], pDescData2->m_platform[3]);
+		m_retrievedDescData.m_savePlatform = static_cast<ESavePlatform>(MAKE_FOURCC(pDescData2->m_platform[0], pDescData2->m_platform[1], pDescData2->m_platform[2], pDescData2->m_platform[3]));
 		m_retrievedDescData.m_seed = GetU64FromHexBytes(pDescData2->m_seed);
 		m_retrievedDescData.m_hostOptions = GetU32FromHexBytes(pDescData2->m_hostOptions);
 		m_retrievedDescData.m_texturePack = GetU32FromHexBytes(pDescData2->m_texturePack);
@@ -58,7 +58,7 @@ void SonyRemoteStorage::SetRetrievedDescData()
 		// old version,copy the data across to the new version
 		DescriptionData* pDescData = (DescriptionData*)m_remoteFileInfo->fileDescription;
 		m_retrievedDescData.m_descDataVersion = 1;
-		m_retrievedDescData.m_savePlatform = (ESavePlatform)MAKE_FOURCC(pDescData->m_platform[0], pDescData->m_platform[1], pDescData->m_platform[2], pDescData->m_platform[3]);
+		m_retrievedDescData.m_savePlatform = static_cast<ESavePlatform>(MAKE_FOURCC(pDescData->m_platform[0], pDescData->m_platform[1], pDescData->m_platform[2], pDescData->m_platform[3]));
 		m_retrievedDescData.m_seed = GetU64FromHexBytes(pDescData->m_seed);
 		m_retrievedDescData.m_hostOptions = GetU32FromHexBytes(pDescData->m_hostOptions);
 		m_retrievedDescData.m_texturePack = GetU32FromHexBytes(pDescData->m_texturePack);
@@ -73,7 +73,7 @@ void SonyRemoteStorage::SetRetrievedDescData()
 
 void getSaveInfoReturnCallback(LPVOID lpParam, SonyRemoteStorage::Status s, int error_code)
 {
-	SonyRemoteStorage* pRemoteStorage = (SonyRemoteStorage*)lpParam;
+	SonyRemoteStorage* pRemoteStorage = static_cast<SonyRemoteStorage *>(lpParam);
 	app.DebugPrintf("remoteStorageGetInfoCallback err : 0x%08x\n", error_code);
 	if(error_code == 0)
 	{
@@ -99,7 +99,7 @@ void getSaveInfoReturnCallback(LPVOID lpParam, SonyRemoteStorage::Status s, int
 
 static void getSaveInfoInitCallback(LPVOID lpParam, SonyRemoteStorage::Status s, int error_code)
 {
-	SonyRemoteStorage* pRemoteStorage = (SonyRemoteStorage*)lpParam;
+	SonyRemoteStorage* pRemoteStorage = static_cast<SonyRemoteStorage *>(lpParam);
 	if(error_code != 0)
 	{
 		app.DebugPrintf("getSaveInfoInitCallback err : 0x%08x\n", error_code);
@@ -143,7 +143,7 @@ bool SonyRemoteStorage::getSaveData( const char* localDirname, CallbackFunc cb,
 
 static void setSaveDataInitCallback(LPVOID lpParam, SonyRemoteStorage::Status s, int error_code)
 {
-	SonyRemoteStorage* pRemoteStorage = (SonyRemoteStorage*)lpParam;
+	SonyRemoteStorage* pRemoteStorage = static_cast<SonyRemoteStorage *>(lpParam);
 	if(error_code != 0)
 	{
 		app.DebugPrintf("setSaveDataInitCallback err : 0x%08x\n", error_code);
@@ -181,7 +181,7 @@ const char* SonyRemoteStorage::getLocalFilename()
 const char* SonyRemoteStorage::getSaveNameUTF8()
 {
 	if(m_getInfoStatus != e_infoFound)
-		return NULL;
+		return nullptr;
 	return m_retrievedDescData.m_saveNameUTF8;
 }
 
@@ -193,7 +193,7 @@ ESavePlatform SonyRemoteStorage::getSavePlatform()
 
 }
 
-__int64 SonyRemoteStorage::getSaveSeed()
+int64_t SonyRemoteStorage::getSaveSeed()
 {
 	if(m_getInfoStatus != e_infoFound)
 		return 0;
@@ -223,9 +223,9 @@ const char* SonyRemoteStorage::getRemoteSaveFilename()
 
 int SonyRemoteStorage::getSaveFilesize()
 {
-	if(m_getInfoStatus == e_infoFound) 
+	if(m_getInfoStatus == e_infoFound)
 	{
-		return m_remoteFileInfo->fileSize; 
+		return m_remoteFileInfo->fileSize;
 	}
 	return 0;
 }
@@ -244,7 +244,7 @@ bool SonyRemoteStorage::setData( PSAVE_INFO info, CallbackFunc cb, LPVOID lpPara
 
 int SonyRemoteStorage::LoadSaveDataThumbnailReturned(LPVOID lpParam,PBYTE pbThumbnail,DWORD dwThumbnailBytes)
 {
-	SonyRemoteStorage *pClass= (SonyRemoteStorage *)lpParam;
+	SonyRemoteStorage *pClass= static_cast<SonyRemoteStorage *>(lpParam);
 
 	if(pClass->m_bAborting)
 	{
@@ -261,12 +261,12 @@ int SonyRemoteStorage::LoadSaveDataThumbnailReturned(LPVOID lpParam,PBYTE pbThum
 	}
 	else
 	{
-		app.DebugPrintf("Thumbnail data is NULL, or has size 0\n");
-		pClass->m_thumbnailData = NULL;
+		app.DebugPrintf("Thumbnail data is nullptr, or has size 0\n");
+		pClass->m_thumbnailData = nullptr;
 		pClass->m_thumbnailDataSize = 0;
 	}
 
-	if(pClass->m_SetDataThread != NULL)
+	if(pClass->m_SetDataThread != nullptr)
 		delete pClass->m_SetDataThread;
 
 	pClass->m_SetDataThread = new C4JThread(setDataThread, pClass, "setDataThread");
@@ -277,7 +277,7 @@ int SonyRemoteStorage::LoadSaveDataThumbnailReturned(LPVOID lpParam,PBYTE pbThum
 
 int SonyRemoteStorage::setDataThread(void* lpParam)
 {
-	SonyRemoteStorage* pClass = (SonyRemoteStorage*)lpParam;
+	SonyRemoteStorage* pClass = static_cast<SonyRemoteStorage *>(lpParam);
 	pClass->m_startTime = System::currentTimeMillis();
 	pClass->setDataInternal();
 	return 0;
@@ -288,9 +288,9 @@ bool SonyRemoteStorage::saveIsAvailable()
 	if(m_getInfoStatus != e_infoFound)
 		return false;
 #ifdef __PS3__
-	return (getSavePlatform() == SAVE_FILE_PLATFORM_PSVITA); 
+	return (getSavePlatform() == SAVE_FILE_PLATFORM_PSVITA);
 #elif defined __PSVITA__
-	return (getSavePlatform() == SAVE_FILE_PLATFORM_PS3); 
+	return (getSavePlatform() == SAVE_FILE_PLATFORM_PS3);
 #else // __ORBIS__
 	return true;
 #endif
@@ -320,10 +320,10 @@ int SonyRemoteStorage::getDataProgress()
 	int nextChunk = ((sizeTransferred + chunkSize) * 100) / totalSize;
 
 
-	__int64 time = System::currentTimeMillis();
+	int64_t time = System::currentTimeMillis();
 	int elapsedSecs = (time - m_startTime) / 1000;
-	float estimatedTransfered = float(elapsedSecs * transferRatePerSec);
-	int progVal = m_dataProgress + (estimatedTransfered / float(totalSize)) * 100;
+	float estimatedTransfered = static_cast<float>(elapsedSecs * transferRatePerSec);
+	int progVal = m_dataProgress + (estimatedTransfered / static_cast<float>(totalSize)) * 100;
 	if(progVal > nextChunk)
 		return nextChunk;
 	if(progVal > 99)
@@ -341,15 +341,15 @@ bool SonyRemoteStorage::shutdown()
 	if(m_bInitialised)
 	{
 		int ret = sceRemoteStorageTerm();
-		if(ret >= 0) 
+		if(ret >= 0)
 		{
 			app.DebugPrintf("Term request done \n");
 			m_bInitialised = false;
 			free(m_memPoolBuffer);
-			m_memPoolBuffer = NULL;
+			m_memPoolBuffer = nullptr;
 			return true;
-		} 
-		else 
+		}
+		else
 		{
 			app.DebugPrintf("Error in Term request: 0x%x \n", ret);
 			return false;
@@ -406,10 +406,11 @@ void SonyRemoteStorage::GetDescriptionData( DescriptionData& descData)
 		unsigned int uiHostOptions;
 		bool bHostOptionsRead;
 		DWORD uiTexturePack;
-		char seed[22];
-		app.GetImageTextData(m_thumbnailData, m_thumbnailDataSize,(unsigned char *)seed, uiHostOptions, bHostOptionsRead, uiTexturePack);
+        char seed[22];
+        app.GetImageTextData(m_thumbnailData, m_thumbnailDataSize, reinterpret_cast<unsigned char*>(seed),
+                             uiHostOptions, bHostOptionsRead, uiTexturePack);
 
-		__int64 iSeed = strtoll(seed,NULL,10);
+        int64_t iSeed = strtoll(seed, nullptr,10);
 		SetU64HexBytes(descData.m_seed, iSeed);
 		// Save the host options that this world was last played with
 		SetU32HexBytes(descData.m_hostOptions, uiHostOptions);
@@ -433,7 +434,7 @@ void SonyRemoteStorage::GetDescriptionData( DescriptionData_V2& descData)
 	char descDataVersion[9];
 	sprintf(descDataVersion,"%08x",sc_CurrentDescDataVersion);
 	memcpy(descData.m_descDataVersion,descDataVersion,8); // Don't copy null
-	
+
 
 	descData.m_platform[0] = SAVE_FILE_PLATFORM_LOCAL & 0xff;
 	descData.m_platform[1] = (SAVE_FILE_PLATFORM_LOCAL >> 8) & 0xff;
@@ -448,7 +449,7 @@ void SonyRemoteStorage::GetDescriptionData( DescriptionData_V2& descData)
 		char seed[22];
 		app.GetImageTextData(m_thumbnailData, m_thumbnailDataSize,(unsigned char *)seed, uiHostOptions, bHostOptionsRead, uiTexturePack);
 
-		__int64 iSeed = strtoll(seed,NULL,10);
+		int64_t iSeed = strtoll(seed, nullptr,10);
 		SetU64HexBytes(descData.m_seed, iSeed);
 		// Save the host options that this world was last played with
 		SetU32HexBytes(descData.m_hostOptions, uiHostOptions);
@@ -468,7 +469,7 @@ void SonyRemoteStorage::GetDescriptionData( DescriptionData_V2& descData)
 uint32_t SonyRemoteStorage::GetU32FromHexBytes(char* hexBytes)
 {
 	char hexString[9];
-	ZeroMemory(hexString,9);	
+	ZeroMemory(hexString,9);
 	memcpy(hexString, hexBytes,8);
 
 	uint32_t u32Val = 0;
@@ -481,7 +482,7 @@ uint32_t SonyRemoteStorage::GetU32FromHexBytes(char* hexBytes)
 uint64_t SonyRemoteStorage::GetU64FromHexBytes(char* hexBytes)
 {
 	char hexString[17];
-	ZeroMemory(hexString,17);	
+	ZeroMemory(hexString,17);
 	memcpy(hexString, hexBytes,16);
 
 	uint64_t u64Val = 0;
diff --git a/Minecraft.Client/Common/Network/Sony/SonyRemoteStorage.h b/Minecraft.Client/Common/Network/Sony/SonyRemoteStorage.h
index d38a06e2..5740f78d 100644
--- a/Minecraft.Client/Common/Network/Sony/SonyRemoteStorage.h
+++ b/Minecraft.Client/Common/Network/Sony/SonyRemoteStorage.h
@@ -1,4 +1,4 @@
-#pragma once 
+#pragma once
 
 
 #include "..\..\Common\Network\Sony\sceRemoteStorage\header\sceRemoteStorage.h"
@@ -43,7 +43,7 @@ public:
 	char m_saveFileDesc[128];
 
 	class DescriptionData
-	{ 
+	{
 		// this stuff is read from a JSON query, so it all has to be text based, max 256 bytes
 	public:
 		char			m_platform[4];
@@ -54,7 +54,7 @@ public:
 	};
 
 	class DescriptionData_V2
-	{ 
+	{
 		// this stuff is read from a JSON query, so it all has to be text based, max 256 bytes
 	public:
 		char			m_platformNone[4];  // set to no platform, to indicate we're using the newer version of the data
@@ -73,7 +73,7 @@ public:
 	public:
 		int				m_descDataVersion;
 		ESavePlatform	m_savePlatform;
-		__int64			m_seed;
+		int64_t			m_seed;
 		uint32_t		m_hostOptions;
 		uint32_t		m_texturePack;
 		uint32_t		m_saveVersion;
@@ -115,7 +115,7 @@ public:
 	const char* getLocalFilename();
 	const char* getSaveNameUTF8();
 	ESavePlatform getSavePlatform();
-	__int64 getSaveSeed();
+	int64_t getSaveSeed();
 	unsigned int getSaveHostOptions();
 	unsigned int getSaveTexturePack();
 
@@ -140,7 +140,7 @@ public:
 	static int LoadSaveDataThumbnailReturned(LPVOID lpParam,PBYTE pbThumbnail,DWORD dwThumbnailBytes);
 	static int setDataThread(void* lpParam);
 
-	SonyRemoteStorage() : m_memPoolBuffer(NULL), m_bInitialised(false),m_getInfoStatus(e_noInfoFound) {} 
+	SonyRemoteStorage() : m_getInfoStatus(e_noInfoFound), m_bInitialised(false),m_memPoolBuffer(nullptr) {}
 
 protected:
 	const char* getRemoteSaveFilename();
@@ -154,7 +154,7 @@ protected:
 	unsigned int m_thumbnailDataSize;
 	C4JThread* m_SetDataThread;
 	PSAVE_INFO m_setDataSaveInfo;
-	__int64 m_startTime;
+	int64_t m_startTime;
 
 	bool m_bAborting;
 	bool m_bTransferStarted;