Fixes for PR #96 (#170)

* Implement basic multiplayer functionality

* Update README.md

---------

Co-authored-by: Slenderman <ssimulpong@outlook.com>

Minecraft.Client/ClientConnection.cpp

@@ -757,7 +757,7 @@ void ClientConnection::handleAddPlayer(shared_ptr<AddPlayerPacket> packet)
 			return;
 		}
 	}
-#ifdef _WINDOWS64
+/*#ifdef _WINDOWS64
 	// On Windows64 all XUIDs are INVALID_XUID so the XUID check above never fires.
 	// packet->m_playerIndex is the server-assigned sequential index (set via LoginPacket),
 	// NOT the controller slot — so we must scan all local player slots and match by
@@ -771,7 +771,7 @@ void ClientConnection::handleAddPlayer(shared_ptr<AddPlayerPacket> packet)
 			return;
 		}
 	}
-#endif
+#endif*/
 
 	double x = packet->x / 32.0;
 	double y = packet->y / 32.0;

Minecraft.Client/Common/Consoles_App.cpp

@@ -3402,7 +3402,7 @@ void CMinecraftApp::HandleXuiActions(void)
 								bool gameStarted = false;
 								for(int j = 0; j < pMinecraft->levels.length; j++)
 								{
-									if (pMinecraft->levels.data[i] != NULL)
+									if (pMinecraft->levels.data[i] != nullptr)
 									{
 										gameStarted = true;
 										break;

Minecraft.Client/Common/Network/GameNetworkManager.cpp

@@ -167,6 +167,11 @@ bool CGameNetworkManager::_RunNetworkGame(LPVOID lpParameter)
 			return true;
 		}
 	}
+	else
+	{
+		// Client needs QNET_STATE_GAME_PLAY so that IsInGameplay() returns true
+		s_pPlatformNetworkManager->SetGamePlayState();
+	}
 	
 	if( g_NetworkManager.IsLeavingGame() ) return false;
 
@@ -1479,7 +1484,10 @@ void CGameNetworkManager::CreateSocket( INetworkPlayer *pNetworkPlayer, bool loc
 	Minecraft *pMinecraft = Minecraft::GetInstance();
 
 	Socket *socket = NULL;
-	shared_ptr<MultiplayerLocalPlayer> mpPlayer = pMinecraft->localplayers[pNetworkPlayer->GetUserIndex()];
+	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 we already have a MultiplayerLocalPlayer here then we are doing a session type change

Minecraft.Client/Common/Network/PlatformNetworkManagerInterface.h

@@ -84,6 +84,7 @@ public:
 	virtual void HandleSignInChange() = 0;
 
 	virtual bool _RunNetworkGame() = 0;
+	virtual void SetGamePlayState() {}
 
 private:
 	virtual bool _LeaveGame(bool bMigrateHost, bool bLeaveRoom) = 0;

Minecraft.Client/Common/Network/PlatformNetworkManagerStub.cpp

@@ -2,7 +2,12 @@
 #include "..\..\..\Minecraft.World\Socket.h"
 #include "..\..\..\Minecraft.World\StringHelpers.h"
 #include "PlatformNetworkManagerStub.h"
-#include "..\..\Xbox\Network\NetworkPlayerXbox.h"		// TODO - stub version of this?
+#include "..\..\Xbox\Network\NetworkPlayerXbox.h"
+#ifdef _WINDOWS64
+#include "..\..\Windows64\Network\WinsockNetLayer.h"
+#include "..\..\Minecraft.h"
+#include "..\..\User.h"
+#endif
 
 CPlatformNetworkManagerStub *g_pPlatformNetworkManager;
 
@@ -114,10 +119,43 @@ void CPlatformNetworkManagerStub::NotifyPlayerJoined(IQNetPlayer *pQNetPlayer	)
 	}
 }
 
+void CPlatformNetworkManagerStub::NotifyPlayerLeaving(IQNetPlayer* pQNetPlayer)
+{
+	app.DebugPrintf("Player 0x%p \"%ls\" leaving.\n", pQNetPlayer, pQNetPlayer->GetGamertag());
+
+	INetworkPlayer* networkPlayer = getNetworkPlayer(pQNetPlayer);
+	if (networkPlayer == NULL)
+		return;
+
+	Socket* socket = networkPlayer->GetSocket();
+	if (socket != NULL)
+	{
+		if (m_pIQNet->IsHost())
+			g_NetworkManager.CloseConnection(networkPlayer);
+	}
+
+	if (m_pIQNet->IsHost())
+	{
+		SystemFlagRemovePlayer(networkPlayer);
+	}
+
+	g_NetworkManager.PlayerLeaving(networkPlayer);
+
+	for (int idx = 0; idx < XUSER_MAX_COUNT; ++idx)
+	{
+		if (playerChangedCallback[idx] != NULL)
+			playerChangedCallback[idx](playerChangedCallbackParam[idx], networkPlayer, true);
+	}
+
+	removeNetworkPlayer(pQNetPlayer);
+}
+
+
 bool CPlatformNetworkManagerStub::Initialise(CGameNetworkManager *pGameNetworkManager, int flagIndexSize)
 {
 	m_pGameNetworkManager = pGameNetworkManager;
 	m_flagIndexSize = flagIndexSize;
+	m_pIQNet = new IQNet();
 	g_pPlatformNetworkManager = this;
 	for( int i = 0; i < XUSER_MAX_COUNT; i++ )
 	{
@@ -174,6 +212,37 @@ bool CPlatformNetworkManagerStub::isSystemPrimaryPlayer(IQNetPlayer *pQNetPlayer
 // We call this twice a frame, either side of the render call so is a good place to "tick" things
 void CPlatformNetworkManagerStub::DoWork()
 {
+#ifdef _WINDOWS64
+	extern QNET_STATE _iQNetStubState;
+	if (_iQNetStubState == QNET_STATE_SESSION_STARTING && app.GetGameStarted())
+	{
+		_iQNetStubState = QNET_STATE_GAME_PLAY;
+		if (m_pIQNet->IsHost())
+			WinsockNetLayer::UpdateAdvertiseJoinable(true);
+	}
+	if (_iQNetStubState == QNET_STATE_IDLE)
+		TickSearch();
+	if (_iQNetStubState == QNET_STATE_GAME_PLAY && m_pIQNet->IsHost())
+	{
+		BYTE disconnectedSmallId;
+		while (WinsockNetLayer::PopDisconnectedSmallId(&disconnectedSmallId))
+		{
+			IQNetPlayer* qnetPlayer = m_pIQNet->GetPlayerBySmallId(disconnectedSmallId);
+			if (qnetPlayer != NULL && qnetPlayer->m_smallId == disconnectedSmallId)
+			{
+				NotifyPlayerLeaving(qnetPlayer);
+				qnetPlayer->m_smallId = 0;
+				qnetPlayer->m_isRemote = false;
+				qnetPlayer->m_isHostPlayer = false;
+				qnetPlayer->m_gamertag[0] = 0;
+				qnetPlayer->SetCustomDataValue(0);
+				WinsockNetLayer::PushFreeSmallId(disconnectedSmallId);
+				if (IQNet::s_playerCount > 1)
+					IQNet::s_playerCount--;
+			}
+		}
+	}
+#endif
 }
 
 int CPlatformNetworkManagerStub::GetPlayerCount()
@@ -232,6 +301,10 @@ bool CPlatformNetworkManagerStub::LeaveGame(bool bMigrateHost)
 
 	m_bLeavingGame = true;
 
+#ifdef _WINDOWS64
+	WinsockNetLayer::StopAdvertising();
+#endif
+
 	// If we are the host wait for the game server to end
 	if(m_pIQNet->IsHost() && g_NetworkManager.ServerStoppedValid())
 	{
@@ -239,6 +312,22 @@ bool CPlatformNetworkManagerStub::LeaveGame(bool bMigrateHost)
 		g_NetworkManager.ServerStoppedWait();
 		g_NetworkManager.ServerStoppedDestroy();
 	}
+	else
+	{
+		m_pIQNet->EndGame();
+	}
+
+	for (AUTO_VAR(it, currentNetworkPlayers.begin()); it != currentNetworkPlayers.end(); it++)
+		delete* it;
+	currentNetworkPlayers.clear();
+	m_machineQNetPrimaryPlayers.clear();
+	SystemFlagReset();
+
+#ifdef _WINDOWS64
+	WinsockNetLayer::Shutdown();
+	WinsockNetLayer::Initialize();
+#endif
+
 	return true;
 }
 
@@ -262,7 +351,24 @@ void CPlatformNetworkManagerStub::HostGame(int localUsersMask, bool bOnlineGame,
 
 	m_pIQNet->HostGame();
 
+#ifdef _WINDOWS64
+	IQNet::m_player[0].m_smallId = 0;
+	IQNet::m_player[0].m_isRemote = false;
+	IQNet::m_player[0].m_isHostPlayer = true;
+	IQNet::s_playerCount = 1;
+#endif
+
 	_HostGame( localUsersMask, publicSlots, privateSlots );
+
+#ifdef _WINDOWS64
+	int port = WIN64_NET_DEFAULT_PORT;
+	if (!WinsockNetLayer::IsActive())
+		WinsockNetLayer::HostGame(port);
+
+	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);
+#endif
 //#endif
 }
 
@@ -275,9 +381,54 @@ bool CPlatformNetworkManagerStub::_StartGame()
 	return true;
 }
 
-int CPlatformNetworkManagerStub::JoinGame(FriendSessionInfo *searchResult, int localUsersMask, int primaryUserIndex)
+int CPlatformNetworkManagerStub::JoinGame(FriendSessionInfo* searchResult, int localUsersMask, int primaryUserIndex)
 {
+#ifdef _WINDOWS64
+	if (searchResult == NULL)
+		return CGameNetworkManager::JOINGAME_FAIL_GENERAL;
+
+	const char* hostIP = searchResult->data.hostIP;
+	int hostPort = searchResult->data.hostPort;
+
+	if (hostPort <= 0 || hostIP[0] == 0)
+		return CGameNetworkManager::JOINGAME_FAIL_GENERAL;
+
+	m_bLeavingGame = 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;
+	wcsncpy_s(IQNet::m_player[0].m_gamertag, 32, searchResult->data.hostName, _TRUNCATE);
+
+	WinsockNetLayer::StopDiscovery();
+
+	if (!WinsockNetLayer::JoinGame(hostIP, hostPort))
+	{
+		app.DebugPrintf("Win64 LAN: Failed to connect to %s:%d\n", hostIP, hostPort);
+		return CGameNetworkManager::JOINGAME_FAIL_GENERAL;
+	}
+
+	BYTE localSmallId = WinsockNetLayer::GetLocalSmallId();
+
+	IQNet::m_player[localSmallId].m_smallId = localSmallId;
+	IQNet::m_player[localSmallId].m_isRemote = false;
+	IQNet::m_player[localSmallId].m_isHostPlayer = false;
+
+	Minecraft* pMinecraft = Minecraft::GetInstance();
+	wcscpy_s(IQNet::m_player[localSmallId].m_gamertag, 32, pMinecraft->user->name.c_str());
+	IQNet::s_playerCount = localSmallId + 1;
+
+	NotifyPlayerJoined(&IQNet::m_player[0]);
+	NotifyPlayerJoined(&IQNet::m_player[localSmallId]);
+
+	m_pGameNetworkManager->StateChange_AnyToStarting();
+
 	return CGameNetworkManager::JOINGAME_SUCCESS;
+#else
+	return CGameNetworkManager::JOINGAME_SUCCESS;
+#endif
 }
 
 bool CPlatformNetworkManagerStub::SetLocalGame(bool isLocal)
@@ -315,6 +466,22 @@ void CPlatformNetworkManagerStub::HandleSignInChange()
 
 bool CPlatformNetworkManagerStub::_RunNetworkGame()
 {
+#ifdef _WINDOWS64
+	extern QNET_STATE _iQNetStubState;
+	_iQNetStubState = QNET_STATE_GAME_PLAY;
+
+	for (DWORD i = 0; i < IQNet::s_playerCount; i++)
+	{
+		if (IQNet::m_player[i].m_isRemote)
+		{
+			INetworkPlayer* pNetworkPlayer = getNetworkPlayer(&IQNet::m_player[i]);
+			if (pNetworkPlayer != NULL && pNetworkPlayer->GetSocket() != NULL)
+			{
+				Socket::addIncomingSocket(pNetworkPlayer->GetSocket());
+			}
+		}
+	}
+#endif
 	return true;
 }
 
@@ -503,10 +670,60 @@ wstring CPlatformNetworkManagerStub::GatherRTTStats()
 
 void CPlatformNetworkManagerStub::TickSearch()
 {
+#ifdef _WINDOWS64
+	if (m_SessionsUpdatedCallback == NULL)
+		return;
+
+	static DWORD lastSearchTime = 0;
+	DWORD now = GetTickCount();
+	if (now - lastSearchTime < 2000)
+		return;
+	lastSearchTime = now;
+
+	SearchForGames();
+#endif
 }
 
 void CPlatformNetworkManagerStub::SearchForGames()
 {
+#ifdef _WINDOWS64
+	std::vector<Win64LANSession> lanSessions = WinsockNetLayer::GetDiscoveredSessions();
+
+	for (size_t i = 0; i < friendsSessions[0].size(); i++)
+		delete friendsSessions[0][i];
+	friendsSessions[0].clear();
+
+	for (size_t i = 0; i < lanSessions.size(); i++)
+	{
+		FriendSessionInfo* info = new FriendSessionInfo();
+		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->displayLabelViewableStartIndex = 0;
+
+		info->data.netVersion = lanSessions[i].netVersion;
+		info->data.m_uiGameHostSettings = lanSessions[i].gameHostSettings;
+		info->data.texturePackParentId = lanSessions[i].texturePackParentId;
+		info->data.subTexturePackId = lanSessions[i].subTexturePackId;
+		info->data.isReadyToJoin = lanSessions[i].isJoinable;
+		info->data.isJoinable = lanSessions[i].isJoinable;
+		strncpy_s(info->data.hostIP, sizeof(info->data.hostIP), lanSessions[i].hostIP, _TRUNCATE);
+		info->data.hostPort = lanSessions[i].hostPort;
+		wcsncpy_s(info->data.hostName, XUSER_NAME_SIZE, lanSessions[i].hostName, _TRUNCATE);
+		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));
+
+		friendsSessions[0].push_back(info);
+	}
+
+	m_searchResultsCount[0] = (int)friendsSessions[0].size();
+
+	if (m_SessionsUpdatedCallback != NULL)
+		m_SessionsUpdatedCallback(m_pSearchParam);
+#endif
 }
 
 int CPlatformNetworkManagerStub::SearchForGamesThreadProc( void* lpParameter )
@@ -522,7 +739,9 @@ void CPlatformNetworkManagerStub::SetSearchResultsReady(int resultCount)
 
 vector<FriendSessionInfo *> *CPlatformNetworkManagerStub::GetSessionList(int iPad, int localPlayers, bool partyOnly)
 {
-	vector<FriendSessionInfo *> *filteredList = new vector<FriendSessionInfo *>();;
+	vector<FriendSessionInfo*>* filteredList = new vector<FriendSessionInfo*>();
+	for (size_t i = 0; i < friendsSessions[0].size(); i++)
+		filteredList->push_back(friendsSessions[0][i]);
 	return filteredList;
 }
 

Minecraft.Client/Common/Network/PlatformNetworkManagerStub.h

@@ -161,8 +161,9 @@ public:
 	virtual void GetFullFriendSessionInfo( FriendSessionInfo *foundSession, void (* FriendSessionUpdatedFn)(bool success, void *pParam), void *pParam );
 	virtual void ForceFriendsSessionRefresh();
 
-private:
+public:
 	void NotifyPlayerJoined( IQNetPlayer *pQNetPlayer );
+	void NotifyPlayerLeaving(IQNetPlayer* pQNetPlayer);
 
 #ifndef _XBOX
 	void FakeLocalPlayerJoined() { NotifyPlayerJoined(m_pIQNet->GetLocalPlayerByUserIndex(0)); }

Minecraft.Client/Common/Network/SessionInfo.h

@@ -23,9 +23,9 @@ typedef struct _GameSessionData
 	_GameSessionData()
 	{
 		netVersion = 0;
-		memset(hostName,0,XUSER_NAME_SIZE);
+		memset(hostName, 0, XUSER_NAME_SIZE);
-		memset(players,0,MINECRAFT_NET_MAX_PLAYERS*sizeof(players[0]));
+		memset(players, 0, MINECRAFT_NET_MAX_PLAYERS * sizeof(players[0]));
-		memset(szPlayers,0,MINECRAFT_NET_MAX_PLAYERS*XUSER_NAME_SIZE);
+		memset(szPlayers, 0, MINECRAFT_NET_MAX_PLAYERS * XUSER_NAME_SIZE);
 		isJoinable = true;
 		m_uiGameHostSettings = 0;
 		texturePackParentId = 0;
@@ -50,7 +50,7 @@ typedef struct _GameSessionData
 	_GameSessionData()
 	{
 		netVersion = 0;
-		memset(players,0,MINECRAFT_NET_MAX_PLAYERS*sizeof(players[0]));
+		memset(players, 0, MINECRAFT_NET_MAX_PLAYERS * sizeof(players[0]));
 		isJoinable = true;
 		m_uiGameHostSettings = 0;
 		texturePackParentId = 0;
@@ -63,12 +63,19 @@ typedef struct _GameSessionData
 #else
 typedef struct _GameSessionData
 {
-	unsigned short netVersion;										//   2 bytes
+	unsigned short netVersion;
-	unsigned int m_uiGameHostSettings;								//   4 bytes
+	unsigned int m_uiGameHostSettings;
-	unsigned int texturePackParentId;								//   4 bytes
+	unsigned int texturePackParentId;
-	unsigned char subTexturePackId;									//   1 byte
+	unsigned char subTexturePackId;
 
-	bool isReadyToJoin;												//   1 byte
+	bool isReadyToJoin;
+	bool isJoinable;
+
+	char hostIP[64];
+	int hostPort;
+	wchar_t hostName[XUSER_NAME_SIZE];
+	unsigned char playerCount;
+	unsigned char maxPlayers;
 
 	_GameSessionData()
 	{
@@ -76,6 +83,13 @@ typedef struct _GameSessionData
 		m_uiGameHostSettings = 0;
 		texturePackParentId = 0;
 		subTexturePackId = 0;
+		isReadyToJoin = false;
+		isJoinable = true;
+		memset(hostIP, 0, sizeof(hostIP));
+		hostPort = 0;
+		memset(hostName, 0, sizeof(hostName));
+		playerCount = 0;
+		maxPlayers = MINECRAFT_NET_MAX_PLAYERS;
 	}
 } GameSessionData;
 #endif
@@ -91,7 +105,7 @@ public:
 #elif defined(_DURANGO)
 	DQRNetworkManager::SessionSearchResult searchResult;
 #endif
-	wchar_t *displayLabel;
+	wchar_t* displayLabel;
 	unsigned char displayLabelLength;
 	unsigned char displayLabelViewableStartIndex;
 	GameSessionData data;
@@ -107,7 +121,7 @@ public:
 
 	~FriendSessionInfo()
 	{
-		if(displayLabel!=NULL)
+		if (displayLabel != NULL)
 			delete displayLabel;
 	}
 };

Minecraft.Client/Common/UI/UIScene_LoadOrJoinMenu.cpp

@@ -284,13 +284,8 @@ UIScene_LoadOrJoinMenu::~UIScene_LoadOrJoinMenu()
     g_NetworkManager.SetSessionsUpdatedCallback( NULL, NULL );
     app.SetLiveLinkRequired( false );
 
-    if(m_currentSessions)
+    delete m_currentSessions;
-    {
+    m_currentSessions = NULL;
-        for(AUTO_VAR(it, m_currentSessions->begin()); it < m_currentSessions->end(); ++it)
-        {
-            delete (*it);
-        }
-    }
 
 #if TO_BE_IMPLEMENTED
     // Reset the background downloading, in case we changed it by attempting to download a texture pack

Minecraft.Client/Extrax64Stubs.cpp

@@ -20,6 +20,7 @@
 #include "StatsCounter.h"
 #include "Windows64\Social\SocialManager.h"
 #include "Windows64\Sentient\DynamicConfigurations.h"
+#include "Windows64\Network\WinsockNetLayer.h"
 #elif defined __PSVITA__
 #include "PSVita\Sentient\SentientManager.h"
 #include "StatsCounter.h"
@@ -46,63 +47,63 @@ CXuiStringTable StringTable;
 #ifndef _XBOX_ONE
 ATG::XMLParser::XMLParser() {}
 ATG::XMLParser::~XMLParser() {}
-HRESULT    ATG::XMLParser::ParseXMLBuffer( CONST CHAR* strBuffer, UINT uBufferSize ) { return S_OK; }   
+HRESULT    ATG::XMLParser::ParseXMLBuffer(CONST CHAR* strBuffer, UINT uBufferSize) { return S_OK; }
-VOID ATG::XMLParser::RegisterSAXCallbackInterface( ISAXCallback *pISAXCallback ) {}
+VOID ATG::XMLParser::RegisterSAXCallbackInterface(ISAXCallback* pISAXCallback) {}
 #endif
 
 bool	CSocialManager::IsTitleAllowedToPostAnything() { return false; }
 bool	CSocialManager::AreAllUsersAllowedToPostImages() { return false; }
 bool	CSocialManager::IsTitleAllowedToPostImages() { return false; }
 
-bool	CSocialManager::PostLinkToSocialNetwork( ESocialNetwork eSocialNetwork, DWORD dwUserIndex, bool bUsingKinect ) { return false; }
+bool	CSocialManager::PostLinkToSocialNetwork(ESocialNetwork eSocialNetwork, DWORD dwUserIndex, bool bUsingKinect) { return false; }
-bool	CSocialManager::PostImageToSocialNetwork( ESocialNetwork eSocialNetwork, DWORD dwUserIndex, bool bUsingKinect ) { return false; }
+bool	CSocialManager::PostImageToSocialNetwork(ESocialNetwork eSocialNetwork, DWORD dwUserIndex, bool bUsingKinect) { return false; }
-CSocialManager *CSocialManager::Instance() { return NULL; }
+CSocialManager* CSocialManager::Instance() { return NULL; }
 void CSocialManager::SetSocialPostText(LPCWSTR Title, LPCWSTR Caption, LPCWSTR Desc) {};
 
 DWORD XShowPartyUI(DWORD dwUserIndex) { return 0; }
 DWORD XShowFriendsUI(DWORD dwUserIndex) { return 0; }
-HRESULT XPartyGetUserList(XPARTY_USER_LIST *pUserList) { return S_OK; }
+HRESULT XPartyGetUserList(XPARTY_USER_LIST* pUserList) { return S_OK; }
-DWORD XContentGetThumbnail(DWORD dwUserIndex, const XCONTENT_DATA *pContentData,  PBYTE pbThumbnail,  PDWORD pcbThumbnail,  PXOVERLAPPED *pOverlapped) { return 0; }
+DWORD XContentGetThumbnail(DWORD dwUserIndex, const XCONTENT_DATA* pContentData, PBYTE pbThumbnail, PDWORD pcbThumbnail, PXOVERLAPPED* pOverlapped) { return 0; }
 void XShowAchievementsUI(int i) {}
 DWORD XBackgroundDownloadSetMode(XBACKGROUND_DOWNLOAD_MODE Mode) { return 0; }
 
 #ifndef _DURANGO
-void PIXAddNamedCounter(int a, char *b, ...) {}
+void PIXAddNamedCounter(int a, char* b, ...) {}
 //#define PS3_USE_PIX_EVENTS 
 //#define PS4_USE_PIX_EVENTS 
-void PIXBeginNamedEvent(int a, char *b, ...)
+void PIXBeginNamedEvent(int a, char* b, ...)
 {
 #ifdef PS4_USE_PIX_EVENTS
 	char buf[512];
-    va_list args;
+	va_list args;
-    va_start(args,b);
+	va_start(args, b);
-    vsprintf(buf,b,args);
+	vsprintf(buf, b, args);
 	sceRazorCpuPushMarker(buf, 0xffffffff, SCE_RAZOR_MARKER_ENABLE_HUD);
 
 #endif
 #ifdef PS3_USE_PIX_EVENTS
 	char buf[256];
 	wchar_t wbuf[256];
-    va_list args;
+	va_list args;
-    va_start(args,b);
+	va_start(args, b);
-    vsprintf(buf,b,args);
+	vsprintf(buf, b, args);
 	snPushMarker(buf);
 
-// 	mbstowcs(wbuf,buf,256);
+	// 	mbstowcs(wbuf,buf,256);
-// 	RenderManager.BeginEvent(wbuf);
+	// 	RenderManager.BeginEvent(wbuf);
-    va_end(args);
+	va_end(args);
 #endif
 }
 #if 0//__PSVITA__
-	if( PixDepth < 64 )
+if (PixDepth < 64)
-	{
+{
-		char buf[512];
+	char buf[512];
-		va_list args;
+	va_list args;
-		va_start(args,b);
+	va_start(args, b);
-		vsprintf(buf,b,args);
+	vsprintf(buf, b, args);
-		sceRazorCpuPushMarkerWithHud(buf, 0xffffffff, SCE_RAZOR_MARKER_ENABLE_HUD);
+	sceRazorCpuPushMarkerWithHud(buf, 0xffffffff, SCE_RAZOR_MARKER_ENABLE_HUD);
-	}
+}
-	PixDepth += 1;
+PixDepth += 1;
 #endif
 
 
@@ -113,17 +114,17 @@ void PIXEndNamedEvent()
 #endif
 #ifdef PS3_USE_PIX_EVENTS
 	snPopMarker();
-// 	RenderManager.EndEvent();
+	// 	RenderManager.EndEvent();
 #endif
 #if 0//__PSVITA__
-	if( PixDepth <= 64 )
+	if (PixDepth <= 64)
 	{
 		sceRazorCpuPopMarker();
 	}
 	PixDepth -= 1;
 #endif
 }
-void PIXSetMarkerDeprecated(int a, char *b, ...) {}
+void PIXSetMarkerDeprecated(int a, char* b, ...) {}
 #else
 // 4J Stu - Removed this implementation in favour of a macro that will convert our string format
 // conversion at compile time rather than at runtime
@@ -175,38 +176,33 @@ bool IsEqualXUID(PlayerUID a, PlayerUID b)
 #endif
 }
 
-void XMemCpy(void *a, const void *b, size_t s) { memcpy(a, b, s); }
+void XMemCpy(void* a, const void* b, size_t s) { memcpy(a, b, s); }
-void XMemSet(void *a, int t, size_t s) { memset(a, t, s); }
+void XMemSet(void* a, int t, size_t s) { memset(a, t, s); }
-void XMemSet128(void *a, int t, size_t s) { memset(a, t, s); }
+void XMemSet128(void* a, int t, size_t s) { memset(a, t, s); }
-void *XPhysicalAlloc(SIZE_T a, ULONG_PTR  b, ULONG_PTR c, DWORD d) { return malloc(a); }
+void* XPhysicalAlloc(SIZE_T a, ULONG_PTR  b, ULONG_PTR c, DWORD d) { return malloc(a); }
-void XPhysicalFree(void *a) { free(a); }
+void XPhysicalFree(void* a) { free(a); }
 
 D3DXVECTOR3::D3DXVECTOR3() {}
-D3DXVECTOR3::D3DXVECTOR3(float x,float y,float z) : x(x), y(y), z(z) {}
+D3DXVECTOR3::D3DXVECTOR3(float x, float y, float z) : x(x), y(y), z(z) {}
-D3DXVECTOR3& D3DXVECTOR3::operator += ( CONST D3DXVECTOR3& add ) { x += add.x; y += add.y; z += add.z; return *this; }
+D3DXVECTOR3& D3DXVECTOR3::operator += (CONST D3DXVECTOR3 & add) { x += add.x; y += add.y; z += add.z; return *this; }
 
-BYTE IQNetPlayer::GetSmallId() { return 0; }
+BYTE IQNetPlayer::GetSmallId() { return m_smallId; }
-void IQNetPlayer::SendData(IQNetPlayer *player, const void *pvData, DWORD dwDataSize, DWORD dwFlags)
+void IQNetPlayer::SendData(IQNetPlayer * player, const void* pvData, DWORD dwDataSize, DWORD dwFlags)
 {
-	app.DebugPrintf("Sending from 0x%x to 0x%x %d bytes\n",this,player,dwDataSize);
+	if (WinsockNetLayer::IsActive())
+	{
+		WinsockNetLayer::SendToSmallId(player->m_smallId, pvData, dwDataSize);
+	}
 }
-bool IQNetPlayer::IsSameSystem(IQNetPlayer *player) { return true; }
+bool IQNetPlayer::IsSameSystem(IQNetPlayer * player) { return (this == player) || (!m_isRemote && !player->m_isRemote); }
-DWORD IQNetPlayer::GetSendQueueSize( IQNetPlayer *player, DWORD dwFlags ) { return 0; }
+DWORD IQNetPlayer::GetSendQueueSize(IQNetPlayer * player, DWORD dwFlags) { return 0; }
 DWORD IQNetPlayer::GetCurrentRtt() { return 0; }
-bool IQNetPlayer::IsHost() { return this == &IQNet::m_player[0]; }
+bool IQNetPlayer::IsHost() { return m_isHostPlayer; }
 bool IQNetPlayer::IsGuest() { return false; }
-bool IQNetPlayer::IsLocal() { return true; }
+bool IQNetPlayer::IsLocal() { return !m_isRemote; }
-PlayerUID IQNetPlayer::GetXuid() { return INVALID_XUID; }
+PlayerUID IQNetPlayer::GetXuid() { return (PlayerUID)(0xe000d45248242f2e + m_smallId); }
-LPCWSTR IQNetPlayer::GetGamertag()
+LPCWSTR IQNetPlayer::GetGamertag() { return m_gamertag; }
-{
+int IQNetPlayer::GetSessionIndex() { return m_smallId; }
-	static wchar_t tags[4][16];
-	int idx = GetUserIndex();
-	if(idx < 0 || idx >= 4) idx = 0;
-	mbstowcs(tags[idx], ProfileManager.GetGamertag(idx), 15);
-	tags[idx][15] = L'\0';
-	return tags[idx];
-}
-int IQNetPlayer::GetSessionIndex() { return 0; }
 bool IQNetPlayer::IsTalking() { return false; }
 bool IQNetPlayer::IsMutedByLocalUser(DWORD dwUserIndex) { return false; }
 bool IQNetPlayer::HasVoice() { return false; }
@@ -219,22 +215,104 @@ ULONG_PTR IQNetPlayer::GetCustomDataValue() {
 	return m_customData;
 }
 
-IQNetPlayer IQNet::m_player[4];
+IQNetPlayer IQNet::m_player[MINECRAFT_NET_MAX_PLAYERS];
+DWORD IQNet::s_playerCount = 1;
+bool IQNet::s_isHosting = true;
 
-bool _bQNetStubGameRunning = false;
+QNET_STATE _iQNetStubState = QNET_STATE_IDLE;
 
-HRESULT IQNet::AddLocalPlayerByUserIndex(DWORD dwUserIndex){ return S_OK; }
+void Win64_SetupRemoteQNetPlayer(IQNetPlayer * player, BYTE smallId, bool isHost, bool isLocal)
-IQNetPlayer *IQNet::GetHostPlayer() { return &m_player[0]; }
+{
-IQNetPlayer *IQNet::GetLocalPlayerByUserIndex(DWORD dwUserIndex) { return &m_player[dwUserIndex]; } 
+	player->m_smallId = smallId;
-IQNetPlayer *IQNet::GetPlayerByIndex(DWORD dwPlayerIndex) { return &m_player[0]; }
+	player->m_isRemote = !isLocal;
-IQNetPlayer *IQNet::GetPlayerBySmallId(BYTE SmallId){ return &m_player[0]; }
+	player->m_isHostPlayer = isHost;
-IQNetPlayer *IQNet::GetPlayerByXuid(PlayerUID xuid){ return &m_player[0]; }
+	swprintf_s(player->m_gamertag, 32, L"Player%d", smallId);
-DWORD IQNet::GetPlayerCount() { return 1; }
+	if (smallId >= IQNet::s_playerCount)
-QNET_STATE IQNet::GetState() { return _bQNetStubGameRunning ? QNET_STATE_GAME_PLAY : QNET_STATE_IDLE; }
+		IQNet::s_playerCount = smallId + 1;
-bool IQNet::IsHost() { return true; }
+}
-HRESULT IQNet::JoinGameFromInviteInfo(DWORD dwUserIndex, DWORD dwUserMask, const INVITE_INFO *pInviteInfo) { return S_OK; }
+
-void IQNet::HostGame() { _bQNetStubGameRunning = true; }
+HRESULT IQNet::AddLocalPlayerByUserIndex(DWORD dwUserIndex) { return S_OK; }
-void IQNet::EndGame() { _bQNetStubGameRunning = false; }
+IQNetPlayer* IQNet::GetHostPlayer() { return &m_player[0]; }
+IQNetPlayer* IQNet::GetLocalPlayerByUserIndex(DWORD dwUserIndex)
+{
+	if (s_isHosting)
+	{
+		if (dwUserIndex < MINECRAFT_NET_MAX_PLAYERS && !m_player[dwUserIndex].m_isRemote)
+			return &m_player[dwUserIndex];
+		return NULL;
+	}
+	if (dwUserIndex != 0)
+		return NULL;
+	for (DWORD i = 0; i < s_playerCount; i++)
+	{
+		if (!m_player[i].m_isRemote)
+			return &m_player[i];
+	}
+	return NULL;
+}
+static bool Win64_IsActivePlayer(IQNetPlayer * p, DWORD index)
+{
+	if (index == 0) return true;
+	return (p->GetCustomDataValue() != 0);
+}
+
+IQNetPlayer* IQNet::GetPlayerByIndex(DWORD dwPlayerIndex)
+{
+	DWORD found = 0;
+	for (DWORD i = 0; i < s_playerCount; i++)
+	{
+		if (Win64_IsActivePlayer(&m_player[i], i))
+		{
+			if (found == dwPlayerIndex) return &m_player[i];
+			found++;
+		}
+	}
+	return &m_player[0];
+}
+IQNetPlayer* IQNet::GetPlayerBySmallId(BYTE SmallId)
+{
+	for (DWORD i = 0; i < s_playerCount; i++)
+	{
+		if (m_player[i].m_smallId == SmallId && Win64_IsActivePlayer(&m_player[i], i)) return &m_player[i];
+	}
+	return NULL;
+}
+IQNetPlayer* IQNet::GetPlayerByXuid(PlayerUID xuid)
+{
+	for (DWORD i = 0; i < s_playerCount; i++)
+	{
+		if (Win64_IsActivePlayer(&m_player[i], i) && m_player[i].GetXuid() == xuid) return &m_player[i];
+	}
+	return &m_player[0];
+}
+DWORD IQNet::GetPlayerCount()
+{
+	DWORD count = 0;
+	for (DWORD i = 0; i < s_playerCount; i++)
+	{
+		if (Win64_IsActivePlayer(&m_player[i], i)) count++;
+	}
+	return count;
+}
+QNET_STATE IQNet::GetState() { return _iQNetStubState; }
+bool IQNet::IsHost() { return s_isHosting; }
+HRESULT IQNet::JoinGameFromInviteInfo(DWORD dwUserIndex, DWORD dwUserMask, const INVITE_INFO * pInviteInfo) { return S_OK; }
+void IQNet::HostGame() { _iQNetStubState = QNET_STATE_SESSION_STARTING; s_isHosting = true; }
+void IQNet::ClientJoinGame() { _iQNetStubState = QNET_STATE_SESSION_STARTING; s_isHosting = false; }
+void IQNet::EndGame()
+{
+	_iQNetStubState = QNET_STATE_IDLE;
+	s_isHosting = false;
+	s_playerCount = 1;
+	for (int i = 1; i < MINECRAFT_NET_MAX_PLAYERS; i++)
+	{
+		m_player[i].m_smallId = 0;
+		m_player[i].m_isRemote = false;
+		m_player[i].m_isHostPlayer = false;
+		m_player[i].m_gamertag[0] = 0;
+		m_player[i].SetCustomDataValue(0);
+	}
+}
 
 DWORD MinecraftDynamicConfigurations::GetTrialTime() { return DYNAMIC_CONFIG_DEFAULT_TRIAL_TIME; }
 
@@ -244,9 +322,9 @@ void XSetThreadProcessor(HANDLE a, int b) {}
 // #endif // __PS3__
 
 DWORD XUserGetSigninInfo(
-         DWORD dwUserIndex,
+	DWORD dwUserIndex,
-         DWORD dwFlags,
+	DWORD dwFlags,
-         PXUSER_SIGNIN_INFO pSigninInfo
+	PXUSER_SIGNIN_INFO pSigninInfo
 )
 {
 	return 0;
@@ -257,16 +335,16 @@ LPCWSTR CXuiStringTable::Lookup(UINT nIndex) { return L"String"; }
 void CXuiStringTable::Clear() {}
 HRESULT CXuiStringTable::Load(LPCWSTR szId) { return S_OK; }
 
-DWORD XUserAreUsersFriends( DWORD dwUserIndex, PPlayerUID pXuids, DWORD dwXuidCount, PBOOL pfResult, void *pOverlapped) { return 0; }
+DWORD XUserAreUsersFriends(DWORD dwUserIndex, PPlayerUID pXuids, DWORD dwXuidCount, PBOOL pfResult, void* pOverlapped) { return 0; }
 
 #if defined __ORBIS__ || defined __PS3__ || defined _XBOX_ONE
 #else
 HRESULT XMemDecompress(
-         XMEMDECOMPRESSION_CONTEXT Context,
+	XMEMDECOMPRESSION_CONTEXT Context,
-         VOID *pDestination,
+	VOID * pDestination,
-         SIZE_T *pDestSize,
+	SIZE_T * pDestSize,
-         CONST VOID *pSource,
+	CONST VOID * pSource,
-         SIZE_T SrcSize
+	SIZE_T SrcSize
 )
 {
 	memcpy(pDestination, pSource, SrcSize);
@@ -276,12 +354,12 @@ HRESULT XMemDecompress(
 	/*
 	DECOMPRESSOR_HANDLE Decompressor    = (DECOMPRESSOR_HANDLE)Context;
 	if( Decompress(
-        Decompressor,           //  Decompressor handle
+		Decompressor,           //  Decompressor handle
-        (void *)pSource,		//  Compressed data
+		(void *)pSource,		//  Compressed data
-        SrcSize,				//  Compressed data size
+		SrcSize,				//  Compressed data size
-        pDestination,			//  Decompressed buffer
+		pDestination,			//  Decompressed buffer
-        *pDestSize,				//  Decompressed buffer size
+		*pDestSize,				//  Decompressed buffer size
-        pDestSize) )				//  Decompressed data size
+		pDestSize) )				//  Decompressed data size
 	{
 		return S_OK;
 	}
@@ -293,11 +371,11 @@ HRESULT XMemDecompress(
 }
 
 HRESULT XMemCompress(
-         XMEMCOMPRESSION_CONTEXT Context,
+	XMEMCOMPRESSION_CONTEXT Context,
-         VOID *pDestination,
+	VOID * pDestination,
-         SIZE_T *pDestSize,
+	SIZE_T * pDestSize,
-         CONST VOID *pSource,
+	CONST VOID * pSource,
-         SIZE_T SrcSize
+	SIZE_T SrcSize
 )
 {
 	memcpy(pDestination, pSource, SrcSize);
@@ -324,10 +402,10 @@ HRESULT XMemCompress(
 }
 
 HRESULT XMemCreateCompressionContext(
-         XMEMCODEC_TYPE CodecType,
+	XMEMCODEC_TYPE CodecType,
-         CONST VOID *pCodecParams,
+	CONST VOID * pCodecParams,
-         DWORD Flags,
+	DWORD Flags,
-         XMEMCOMPRESSION_CONTEXT *pContext
+	XMEMCOMPRESSION_CONTEXT * pContext
 )
 {
 	/*
@@ -345,10 +423,10 @@ HRESULT XMemCreateCompressionContext(
 }
 
 HRESULT XMemCreateDecompressionContext(
-         XMEMCODEC_TYPE CodecType,
+	XMEMCODEC_TYPE CodecType,
-         CONST VOID *pCodecParams,
+	CONST VOID * pCodecParams,
-         DWORD Flags,
+	DWORD Flags,
-         XMEMDECOMPRESSION_CONTEXT *pContext
+	XMEMDECOMPRESSION_CONTEXT * pContext
 )
 {
 	/*
@@ -367,14 +445,14 @@ HRESULT XMemCreateDecompressionContext(
 
 void XMemDestroyCompressionContext(XMEMCOMPRESSION_CONTEXT Context)
 {
-//	COMPRESSOR_HANDLE Compressor    = (COMPRESSOR_HANDLE)Context;
+	//	COMPRESSOR_HANDLE Compressor    = (COMPRESSOR_HANDLE)Context;
-//	CloseCompressor(Compressor);
+	//	CloseCompressor(Compressor);
 }
 
 void XMemDestroyDecompressionContext(XMEMDECOMPRESSION_CONTEXT Context)
 {
-//	DECOMPRESSOR_HANDLE Decompressor    = (DECOMPRESSOR_HANDLE)Context;
+	//	DECOMPRESSOR_HANDLE Decompressor    = (DECOMPRESSOR_HANDLE)Context;
-//	CloseDecompressor(Decompressor);
+	//	CloseDecompressor(Decompressor);
 }
 #endif
 
@@ -389,62 +467,62 @@ DWORD XEnableGuestSignin(BOOL fEnable) { return 0; }
 
 /////////////////////////////////////////////// Profile library
 #ifdef _WINDOWS64
-static void *profileData[4];
+static void* profileData[4];
 static bool s_bProfileIsFullVersion;
-void				C_4JProfile::Initialise( DWORD dwTitleID,
+void				C_4JProfile::Initialise(DWORD dwTitleID,
-								DWORD dwOfferID,
+	DWORD dwOfferID,
-								unsigned short usProfileVersion,
+	unsigned short usProfileVersion,
-								UINT uiProfileValuesC,
+	UINT uiProfileValuesC,
-								UINT uiProfileSettingsC,
+	UINT uiProfileSettingsC,
-								DWORD *pdwProfileSettingsA, 
+	DWORD * pdwProfileSettingsA,
-								int iGameDefinedDataSizeX4,
+	int iGameDefinedDataSizeX4,
-								unsigned int *puiGameDefinedDataChangedBitmask)
+	unsigned int* puiGameDefinedDataChangedBitmask)
 {
-	for( int i = 0; i < 4; i++ )
+	for (int i = 0; i < 4; i++)
 	{
-		profileData[i] = new byte[iGameDefinedDataSizeX4/4];
+		profileData[i] = new byte[iGameDefinedDataSizeX4 / 4];
-		ZeroMemory(profileData[i],sizeof(byte)*iGameDefinedDataSizeX4/4);
+		ZeroMemory(profileData[i], sizeof(byte) * iGameDefinedDataSizeX4 / 4);
 
 		// Set some sane initial values!
-		GAME_SETTINGS *pGameSettings = (GAME_SETTINGS *)profileData[i];
+		GAME_SETTINGS* pGameSettings = (GAME_SETTINGS*)profileData[i];
-		pGameSettings->ucMenuSensitivity=100; //eGameSetting_Sensitivity_InMenu
+		pGameSettings->ucMenuSensitivity = 100; //eGameSetting_Sensitivity_InMenu
-		pGameSettings->ucInterfaceOpacity=80; //eGameSetting_Sensitivity_InMenu
+		pGameSettings->ucInterfaceOpacity = 80; //eGameSetting_Sensitivity_InMenu
-		pGameSettings->usBitmaskValues|=0x0200; //eGameSetting_DisplaySplitscreenGamertags - on
+		pGameSettings->usBitmaskValues |= 0x0200; //eGameSetting_DisplaySplitscreenGamertags - on
-		pGameSettings->usBitmaskValues|=0x0400; //eGameSetting_Hints - on
+		pGameSettings->usBitmaskValues |= 0x0400; //eGameSetting_Hints - on
-		pGameSettings->usBitmaskValues|=0x1000; //eGameSetting_Autosave - 2
+		pGameSettings->usBitmaskValues |= 0x1000; //eGameSetting_Autosave - 2
-		pGameSettings->usBitmaskValues|=0x8000; //eGameSetting_Tooltips - on
+		pGameSettings->usBitmaskValues |= 0x8000; //eGameSetting_Tooltips - on
-		pGameSettings->uiBitmaskValues=0L; // reset
+		pGameSettings->uiBitmaskValues = 0L; // reset
-		pGameSettings->uiBitmaskValues|=GAMESETTING_CLOUDS;					//eGameSetting_Clouds - on
+		pGameSettings->uiBitmaskValues |= GAMESETTING_CLOUDS;					//eGameSetting_Clouds - on
-		pGameSettings->uiBitmaskValues|=GAMESETTING_ONLINE;					//eGameSetting_GameSetting_Online - on
+		pGameSettings->uiBitmaskValues |= GAMESETTING_ONLINE;					//eGameSetting_GameSetting_Online - on
-		pGameSettings->uiBitmaskValues|=GAMESETTING_FRIENDSOFFRIENDS;		//eGameSetting_GameSetting_FriendsOfFriends - on
+		pGameSettings->uiBitmaskValues |= GAMESETTING_FRIENDSOFFRIENDS;		//eGameSetting_GameSetting_FriendsOfFriends - on
-		pGameSettings->uiBitmaskValues|=GAMESETTING_DISPLAYUPDATEMSG;		//eGameSetting_DisplayUpdateMessage (counter)
+		pGameSettings->uiBitmaskValues |= GAMESETTING_DISPLAYUPDATEMSG;		//eGameSetting_DisplayUpdateMessage (counter)
-		pGameSettings->uiBitmaskValues&=~GAMESETTING_BEDROCKFOG;			//eGameSetting_BedrockFog - off
+		pGameSettings->uiBitmaskValues &= ~GAMESETTING_BEDROCKFOG;			//eGameSetting_BedrockFog - off
-		pGameSettings->uiBitmaskValues|=GAMESETTING_DISPLAYHUD;				//eGameSetting_DisplayHUD - on
+		pGameSettings->uiBitmaskValues |= GAMESETTING_DISPLAYHUD;				//eGameSetting_DisplayHUD - on
-		pGameSettings->uiBitmaskValues|=GAMESETTING_DISPLAYHAND;			//eGameSetting_DisplayHand - on
+		pGameSettings->uiBitmaskValues |= GAMESETTING_DISPLAYHAND;			//eGameSetting_DisplayHand - on
-		pGameSettings->uiBitmaskValues|=GAMESETTING_CUSTOMSKINANIM;			//eGameSetting_CustomSkinAnim - on
+		pGameSettings->uiBitmaskValues |= GAMESETTING_CUSTOMSKINANIM;			//eGameSetting_CustomSkinAnim - on
-		pGameSettings->uiBitmaskValues|=GAMESETTING_DEATHMESSAGES;			//eGameSetting_DeathMessages - on
+		pGameSettings->uiBitmaskValues |= GAMESETTING_DEATHMESSAGES;			//eGameSetting_DeathMessages - on
-		pGameSettings->uiBitmaskValues|=(GAMESETTING_UISIZE&0x00000800);				// uisize 2
+		pGameSettings->uiBitmaskValues |= (GAMESETTING_UISIZE & 0x00000800);				// uisize 2
-		pGameSettings->uiBitmaskValues|=(GAMESETTING_UISIZE_SPLITSCREEN&0x00004000);	// splitscreen ui size 3
+		pGameSettings->uiBitmaskValues |= (GAMESETTING_UISIZE_SPLITSCREEN & 0x00004000);	// splitscreen ui size 3
-		pGameSettings->uiBitmaskValues|=GAMESETTING_ANIMATEDCHARACTER;		//eGameSetting_AnimatedCharacter - on
+		pGameSettings->uiBitmaskValues |= GAMESETTING_ANIMATEDCHARACTER;		//eGameSetting_AnimatedCharacter - on
 
 		// TU12
 		// favorite skins added, but only set in TU12 - set to FFs
-		for(int i=0;i<MAX_FAVORITE_SKINS;i++)
+		for (int i = 0; i < MAX_FAVORITE_SKINS; i++)
 		{
-			pGameSettings->uiFavoriteSkinA[i]=0xFFFFFFFF;
+			pGameSettings->uiFavoriteSkinA[i] = 0xFFFFFFFF;
 		}
-		pGameSettings->ucCurrentFavoriteSkinPos=0;
+		pGameSettings->ucCurrentFavoriteSkinPos = 0;
 		// Added a bitmask in TU13 to enable/disable display of the Mash-up pack worlds in the saves list
 		pGameSettings->uiMashUpPackWorldsDisplay = 0xFFFFFFFF;
 
 		// PS3DEC13
-		pGameSettings->uiBitmaskValues&=~GAMESETTING_PS3EULAREAD;		//eGameSetting_PS3_EULA_Read - off
+		pGameSettings->uiBitmaskValues &= ~GAMESETTING_PS3EULAREAD;		//eGameSetting_PS3_EULA_Read - off
 
 		// PS3 1.05 - added Greek
 		pGameSettings->ucLanguage = MINECRAFT_LANGUAGE_DEFAULT; // use the system language
 
 		// PS Vita - network mode added
-		pGameSettings->uiBitmaskValues&=~GAMESETTING_PSVITANETWORKMODEADHOC;		//eGameSetting_PSVita_NetworkModeAdhoc - off
+		pGameSettings->uiBitmaskValues &= ~GAMESETTING_PSVITANETWORKMODEADHOC;		//eGameSetting_PSVita_NetworkModeAdhoc - off
 
 
 		// Tutorials for most menus, and a few other things
@@ -453,90 +531,91 @@ void				C_4JProfile::Initialise( DWORD dwTitleID,
 		pGameSettings->ucTutorialCompletion[2] = 0xF;
 
 		// Has gone halfway through the tutorial
-		pGameSettings->ucTutorialCompletion[28] |= 1<<0;
+		pGameSettings->ucTutorialCompletion[28] |= 1 << 0;
 	}
 }
-void				C_4JProfile::SetTrialTextStringTable(CXuiStringTable *pStringTable,int iAccept,int iReject) {}
+void				C_4JProfile::SetTrialTextStringTable(CXuiStringTable * pStringTable, int iAccept, int iReject) {}
-void				C_4JProfile::SetTrialAwardText(eAwardType AwardType,int iTitle,int iText) {}
+void				C_4JProfile::SetTrialAwardText(eAwardType AwardType, int iTitle, int iText) {}
 int					C_4JProfile::GetLockedProfile() { return 0; }
 void				C_4JProfile::SetLockedProfile(int iProf) {}
-bool				C_4JProfile::IsSignedIn(int iQuadrant) { return ( iQuadrant == 0); }
+bool				C_4JProfile::IsSignedIn(int iQuadrant) { return (iQuadrant == 0); }
 bool				C_4JProfile::IsSignedInLive(int iProf) { return true; }
 bool				C_4JProfile::IsGuest(int iQuadrant) { return false; }
-UINT				C_4JProfile::RequestSignInUI(bool bFromInvite,bool bLocalGame,bool bNoGuestsAllowed,bool bMultiplayerSignIn,bool bAddUser, int( *Func)(LPVOID,const bool, const int iPad),LPVOID lpParam,int iQuadrant) { return 0; }
+UINT				C_4JProfile::RequestSignInUI(bool bFromInvite, bool bLocalGame, bool bNoGuestsAllowed, bool bMultiplayerSignIn, bool bAddUser, int(*Func)(LPVOID, const bool, const int iPad), LPVOID lpParam, int iQuadrant) { return 0; }
-UINT				C_4JProfile::DisplayOfflineProfile(int( *Func)(LPVOID,const bool, const int iPad),LPVOID lpParam,int iQuadrant)  { return 0; }
+UINT				C_4JProfile::DisplayOfflineProfile(int(*Func)(LPVOID, const bool, const int iPad), LPVOID lpParam, int iQuadrant) { return 0; }
-UINT				C_4JProfile::RequestConvertOfflineToGuestUI(int( *Func)(LPVOID,const bool, const int iPad),LPVOID lpParam,int iQuadrant) { return 0; }
+UINT				C_4JProfile::RequestConvertOfflineToGuestUI(int(*Func)(LPVOID, const bool, const int iPad), LPVOID lpParam, int iQuadrant) { return 0; }
 void				C_4JProfile::SetPrimaryPlayerChanged(bool bVal) {}
 bool				C_4JProfile::QuerySigninStatus(void) { return true; }
-void				C_4JProfile::GetXUID(int iPad, PlayerUID *pXuid,bool bOnlineXuid) {*pXuid = 0xe000d45248242f2e; }
+void				C_4JProfile::GetXUID(int iPad, PlayerUID * pXuid, bool bOnlineXuid)
-BOOL				C_4JProfile::AreXUIDSEqual(PlayerUID xuid1,PlayerUID xuid2) { return false; }
+{
+#ifdef _WINDOWS64
+	if (iPad != 0)
+	{
+		*pXuid = INVALID_XUID;
+		return;
+	}
+	if (IQNet::s_isHosting)
+		*pXuid = 0xe000d45248242f2e;
+	else
+		*pXuid = 0xe000d45248242f2e + WinsockNetLayer::GetLocalSmallId();
+#else
+	* pXuid = 0xe000d45248242f2e + iPad;
+#endif
+}
+BOOL				C_4JProfile::AreXUIDSEqual(PlayerUID xuid1, PlayerUID xuid2) { return xuid1 == xuid2; }
 BOOL				C_4JProfile::XUIDIsGuest(PlayerUID xuid) { return false; }
 bool				C_4JProfile::AllowedToPlayMultiplayer(int iProf) { return true; }
 
 #if defined(__ORBIS__)
-bool				C_4JProfile::GetChatAndContentRestrictions(int iPad, bool thisQuadrantOnly, bool *pbChatRestricted,bool *pbContentRestricted,int *piAge)
+bool				C_4JProfile::GetChatAndContentRestrictions(int iPad, bool thisQuadrantOnly, bool* pbChatRestricted, bool* pbContentRestricted, int* piAge)
 {
-	if(pbChatRestricted) *pbChatRestricted = false;
+	if (pbChatRestricted) *pbChatRestricted = false;
-	if(pbContentRestricted) *pbContentRestricted = false;
+	if (pbContentRestricted) *pbContentRestricted = false;
-	if(piAge) *piAge = 100;
+	if (piAge) *piAge = 100;
 	return true;
 }
 #endif
 
 void				C_4JProfile::StartTrialGame() {}
-void				C_4JProfile::AllowedPlayerCreatedContent(int iPad, bool thisQuadrantOnly, BOOL *allAllowed, BOOL *friendsAllowed) {}
+void				C_4JProfile::AllowedPlayerCreatedContent(int iPad, bool thisQuadrantOnly, BOOL * allAllowed, BOOL * friendsAllowed) {}
-BOOL				C_4JProfile::CanViewPlayerCreatedContent(int iPad, bool thisQuadrantOnly, PPlayerUID pXuids, DWORD dwXuidCount ) { return true; }
+BOOL				C_4JProfile::CanViewPlayerCreatedContent(int iPad, bool thisQuadrantOnly, PPlayerUID pXuids, DWORD dwXuidCount) { return true; }
-bool				C_4JProfile::GetProfileAvatar(int iPad,int( *Func)(LPVOID lpParam,PBYTE pbThumbnail,DWORD dwThumbnailBytes), LPVOID lpParam) { return false; }
+bool				C_4JProfile::GetProfileAvatar(int iPad, int(*Func)(LPVOID lpParam, PBYTE pbThumbnail, DWORD dwThumbnailBytes), LPVOID lpParam) { return false; }
 void				C_4JProfile::CancelProfileAvatarRequest() {}
 int					C_4JProfile::GetPrimaryPad() { return 0; }
 void				C_4JProfile::SetPrimaryPad(int iPad) {}
 #ifdef _DURANGO
 char fakeGamerTag[32] = "PlayerName";
-void				SetFakeGamertag(char *name){ strcpy_s(fakeGamerTag, name); }
+void				SetFakeGamertag(char* name) { strcpy_s(fakeGamerTag, name); }
-char*				C_4JProfile::GetGamertag(int iPad){ return fakeGamerTag; }
+char* C_4JProfile::GetGamertag(int iPad) { return fakeGamerTag; }
 #else
-char*				C_4JProfile::GetGamertag(int iPad)
+char* C_4JProfile::GetGamertag(int iPad) { extern char g_Win64Username[17]; return g_Win64Username; }
-{
+wstring				C_4JProfile::GetDisplayName(int iPad) { extern wchar_t g_Win64UsernameW[17]; return g_Win64UsernameW; }
-	static char tags[4][16] = { "Player 1", "Player 2", "Player 3", "Player 4" };
-	if(iPad >= 0 && iPad < 4) return tags[iPad];
-	return tags[0];
-}
-wstring				C_4JProfile::GetDisplayName(int iPad)
-{
-	switch(iPad)
-	{
-	case 1:  return L"Player 2";
-	case 2:  return L"Player 3";
-	case 3:  return L"Player 4";
-	default: return L"Player 1";
-	}
-}
 #endif
 bool				C_4JProfile::IsFullVersion() { return s_bProfileIsFullVersion; }
-void				C_4JProfile::SetSignInChangeCallback(void ( *Func)(LPVOID, bool, unsigned int),LPVOID lpParam) {}
+void				C_4JProfile::SetSignInChangeCallback(void (*Func)(LPVOID, bool, unsigned int), LPVOID lpParam) {}
-void				C_4JProfile::SetNotificationsCallback(void ( *Func)(LPVOID, DWORD, unsigned int),LPVOID lpParam) {}
+void				C_4JProfile::SetNotificationsCallback(void (*Func)(LPVOID, DWORD, unsigned int), LPVOID lpParam) {}
 bool				C_4JProfile::RegionIsNorthAmerica(void) { return false; }
 bool				C_4JProfile::LocaleIsUSorCanada(void) { return false; }
 HRESULT				C_4JProfile::GetLiveConnectionStatus() { return S_OK; }
 bool				C_4JProfile::IsSystemUIDisplayed() { return false; }
-void				C_4JProfile::SetProfileReadErrorCallback(void ( *Func)(LPVOID), LPVOID lpParam) {}
+void				C_4JProfile::SetProfileReadErrorCallback(void (*Func)(LPVOID), LPVOID lpParam) {}
-int( *defaultOptionsCallback)(LPVOID,C_4JProfile::PROFILESETTINGS *, const int iPad) = NULL;
+int(*defaultOptionsCallback)(LPVOID, C_4JProfile::PROFILESETTINGS*, const int iPad) = NULL;
 LPVOID lpProfileParam = NULL;
-int					C_4JProfile::SetDefaultOptionsCallback(int( *Func)(LPVOID,PROFILESETTINGS *, const int iPad),LPVOID lpParam)
+int					C_4JProfile::SetDefaultOptionsCallback(int(*Func)(LPVOID, PROFILESETTINGS*, const int iPad), LPVOID lpParam)
 {
 	defaultOptionsCallback = Func;
 	lpProfileParam = lpParam;
 	return 0;
 }
-int					C_4JProfile::SetOldProfileVersionCallback(int( *Func)(LPVOID,unsigned char *, const unsigned short,const int),LPVOID lpParam) { return 0; }
+int					C_4JProfile::SetOldProfileVersionCallback(int(*Func)(LPVOID, unsigned char*, const unsigned short, const int), LPVOID lpParam) { return 0; }
 
 // To store the dashboard preferences for controller flipped, etc.
 C_4JProfile::PROFILESETTINGS ProfileSettingsA[XUSER_MAX_COUNT];
 
-C_4JProfile::PROFILESETTINGS *	C_4JProfile::GetDashboardProfileSettings(int iPad) { return &ProfileSettingsA[iPad]; }
+C_4JProfile::PROFILESETTINGS* C_4JProfile::GetDashboardProfileSettings(int iPad) { return &ProfileSettingsA[iPad]; }
 void				C_4JProfile::WriteToProfile(int iQuadrant, bool bGameDefinedDataChanged, bool bOverride5MinuteLimitOnProfileWrites) {}
 void				C_4JProfile::ForceQueuedProfileWrites(int iPad) {}
-void				*C_4JProfile::GetGameDefinedProfileData(int iQuadrant)
+void* C_4JProfile::GetGameDefinedProfileData(int iQuadrant)
 {
 	// 4J Stu - Don't reset the options when we call this!!
 	//defaultOptionsCallback(lpProfileParam, (C_4JProfile::PROFILESETTINGS *)profileData[iQuadrant], iQuadrant);
@@ -545,9 +624,10 @@ void				*C_4JProfile::GetGameDefinedProfileData(int iQuadrant)
 	return profileData[iQuadrant];
 }
 void				C_4JProfile::ResetProfileProcessState() {}
-void				C_4JProfile::Tick( void ) {}
+void				C_4JProfile::Tick(void) {}
-void				C_4JProfile::RegisterAward(int iAwardNumber,int iGamerconfigID, eAwardType eType, bool bLeaderboardAffected, 
+void				C_4JProfile::RegisterAward(int iAwardNumber, int iGamerconfigID, eAwardType eType, bool bLeaderboardAffected,
-	CXuiStringTable*pStringTable, int iTitleStr, int iTextStr, int iAcceptStr, char *pszThemeName, unsigned int ulThemeSize) {}
+	CXuiStringTable * pStringTable, int iTitleStr, int iTextStr, int iAcceptStr, char* pszThemeName, unsigned int ulThemeSize) {
+}
 int					C_4JProfile::GetAwardId(int iAwardNumber) { return 0; }
 eAwardType			C_4JProfile::GetAwardType(int iAwardNumber) { return eAwardType_Achievement; }
 bool				C_4JProfile::CanBeAwarded(int iQuadrant, int iAwardNumber) { return false; }
@@ -555,11 +635,11 @@ void				C_4JProfile::Award(int iQuadrant, int iAwardNumber, bool bForce) {}
 bool				C_4JProfile::IsAwardsFlagSet(int iQuadrant, int iAward) { return false; }
 void				C_4JProfile::RichPresenceInit(int iPresenceCount, int iContextCount) {}
 void				C_4JProfile::RegisterRichPresenceContext(int iGameConfigContextID) {}
-void				C_4JProfile::SetRichPresenceContextValue(int iPad,int iContextID, int iVal) {}
+void				C_4JProfile::SetRichPresenceContextValue(int iPad, int iContextID, int iVal) {}
-void				C_4JProfile::SetCurrentGameActivity(int iPad,int iNewPresence, bool bSetOthersToIdle) {}
+void				C_4JProfile::SetCurrentGameActivity(int iPad, int iNewPresence, bool bSetOthersToIdle) {}
 void				C_4JProfile::DisplayFullVersionPurchase(bool bRequired, int iQuadrant, int iUpsellParam) {}
-void				C_4JProfile::SetUpsellCallback(void ( *Func)(LPVOID lpParam, eUpsellType type, eUpsellResponse response, int iUserData),LPVOID lpParam) {}
+void				C_4JProfile::SetUpsellCallback(void (*Func)(LPVOID lpParam, eUpsellType type, eUpsellResponse response, int iUserData), LPVOID lpParam) {}
-void				C_4JProfile::SetDebugFullOverride(bool bVal) {s_bProfileIsFullVersion = bVal;}
+void				C_4JProfile::SetDebugFullOverride(bool bVal) { s_bProfileIsFullVersion = bVal; }
 void				C_4JProfile::ShowProfileCard(int iPad, PlayerUID targetUid) {}
 
 /////////////////////////////////////////////// Storage library
@@ -567,60 +647,60 @@ void				C_4JProfile::ShowProfileCard(int iPad, PlayerUID targetUid) {}
 #if 0
 C4JStorage::C4JStorage() {}
 void								C4JStorage::Tick() {}
-C4JStorage::EMessageResult			C4JStorage::RequestMessageBox(UINT uiTitle, UINT uiText, UINT *uiOptionA,UINT uiOptionC, DWORD dwPad, int( *Func)(LPVOID,int,const C4JStorage::EMessageResult),LPVOID lpParam, C4JStringTable *pStringTable, WCHAR *pwchFormatString,DWORD dwFocusButton) { return C4JStorage::EMessage_Undefined; }
+C4JStorage::EMessageResult			C4JStorage::RequestMessageBox(UINT uiTitle, UINT uiText, UINT * uiOptionA, UINT uiOptionC, DWORD dwPad, int(*Func)(LPVOID, int, const C4JStorage::EMessageResult), LPVOID lpParam, C4JStringTable * pStringTable, WCHAR * pwchFormatString, DWORD dwFocusButton) { return C4JStorage::EMessage_Undefined; }
-C4JStorage::EMessageResult			C4JStorage::GetMessageBoxResult()  { return C4JStorage::EMessage_Undefined; }
+C4JStorage::EMessageResult			C4JStorage::GetMessageBoxResult() { return C4JStorage::EMessage_Undefined; }
-bool								C4JStorage::SetSaveDevice(int( *Func)(LPVOID,const bool),LPVOID lpParam, bool bForceResetOfSaveDevice) { return true; }
+bool								C4JStorage::SetSaveDevice(int(*Func)(LPVOID, const bool), LPVOID lpParam, bool bForceResetOfSaveDevice) { return true; }
-void								C4JStorage::Init(LPCWSTR pwchDefaultSaveName,char *pszSavePackName,int iMinimumSaveSize, int( *Func)(LPVOID, const ESavingMessage, int),LPVOID lpParam) {}
+void								C4JStorage::Init(LPCWSTR pwchDefaultSaveName, char* pszSavePackName, int iMinimumSaveSize, int(*Func)(LPVOID, const ESavingMessage, int), LPVOID lpParam) {}
 void								C4JStorage::ResetSaveData() {}
 void								C4JStorage::SetDefaultSaveNameForKeyboardDisplay(LPCWSTR pwchDefaultSaveName) {}
 void								C4JStorage::SetSaveTitle(LPCWSTR pwchDefaultSaveName) {}
 LPCWSTR								C4JStorage::GetSaveTitle() { return L""; }
-bool								C4JStorage::GetSaveUniqueNumber(INT *piVal) { return true; }
+bool								C4JStorage::GetSaveUniqueNumber(INT * piVal) { return true; }
-bool								C4JStorage::GetSaveUniqueFilename(char *pszName) { return true; }
+bool								C4JStorage::GetSaveUniqueFilename(char* pszName) { return true; }
-void								C4JStorage::SetSaveUniqueFilename(char *szFilename) { }
+void								C4JStorage::SetSaveUniqueFilename(char* szFilename) {}
-void								C4JStorage::SetState(ESaveGameControlState eControlState,int( *Func)(LPVOID,const bool),LPVOID lpParam) {}
+void								C4JStorage::SetState(ESaveGameControlState eControlState, int(*Func)(LPVOID, const bool), LPVOID lpParam) {}
 void								C4JStorage::SetSaveDisabled(bool bDisable) {}
 bool								C4JStorage::GetSaveDisabled(void) { return false; }
 unsigned int						C4JStorage::GetSaveSize() { return 0; }
-void								C4JStorage::GetSaveData(void *pvData,unsigned int *pulBytes) {}
+void								C4JStorage::GetSaveData(void* pvData, unsigned int* pulBytes) {}
 PVOID								C4JStorage::AllocateSaveData(unsigned int ulBytes) { return new char[ulBytes]; }
-void								C4JStorage::SaveSaveData(unsigned int ulBytes,PBYTE pbThumbnail,DWORD cbThumbnail,PBYTE pbTextData, DWORD dwTextLen) {}
+void								C4JStorage::SaveSaveData(unsigned int ulBytes, PBYTE pbThumbnail, DWORD cbThumbnail, PBYTE pbTextData, DWORD dwTextLen) {}
-void								C4JStorage::CopySaveDataToNewSave(PBYTE pbThumbnail,DWORD cbThumbnail,WCHAR *wchNewName,int ( *Func)(LPVOID lpParam, bool), LPVOID lpParam) {}
+void								C4JStorage::CopySaveDataToNewSave(PBYTE pbThumbnail, DWORD cbThumbnail, WCHAR * wchNewName, int (*Func)(LPVOID lpParam, bool), LPVOID lpParam) {}
-void								C4JStorage::SetSaveDeviceSelected(unsigned int uiPad,bool bSelected) {}
+void								C4JStorage::SetSaveDeviceSelected(unsigned int uiPad, bool bSelected) {}
 bool								C4JStorage::GetSaveDeviceSelected(unsigned int iPad) { return true; }
-C4JStorage::ELoadGameStatus			C4JStorage::DoesSaveExist(bool *pbExists) { return C4JStorage::ELoadGame_Idle; }
+C4JStorage::ELoadGameStatus			C4JStorage::DoesSaveExist(bool* pbExists) { return C4JStorage::ELoadGame_Idle; }
 bool								C4JStorage::EnoughSpaceForAMinSaveGame() { return true; }
 void								C4JStorage::SetSaveMessageVPosition(float fY) {}
 //C4JStorage::ESGIStatus				C4JStorage::GetSavesInfo(int iPad,bool ( *Func)(LPVOID, int, CACHEINFOSTRUCT *, int, HRESULT),LPVOID lpParam,char *pszSavePackName) { return C4JStorage::ESGIStatus_Idle; }
-C4JStorage::ESaveGameState			C4JStorage::GetSavesInfo(int iPad,int ( *Func)(LPVOID lpParam,SAVE_DETAILS *pSaveDetails,const bool),LPVOID lpParam,char *pszSavePackName) { return C4JStorage::ESaveGame_Idle; }
+C4JStorage::ESaveGameState			C4JStorage::GetSavesInfo(int iPad, int (*Func)(LPVOID lpParam, SAVE_DETAILS * pSaveDetails, const bool), LPVOID lpParam, char* pszSavePackName) { return C4JStorage::ESaveGame_Idle; }
 
-void								C4JStorage::GetSaveCacheFileInfo(DWORD dwFile,XCONTENT_DATA &xContentData) {}
+void								C4JStorage::GetSaveCacheFileInfo(DWORD dwFile, XCONTENT_DATA & xContentData) {}
-void								C4JStorage::GetSaveCacheFileInfo(DWORD dwFile,	PBYTE *ppbImageData, DWORD *pdwImageBytes) {}
+void								C4JStorage::GetSaveCacheFileInfo(DWORD dwFile, PBYTE * ppbImageData, DWORD * pdwImageBytes) {}
-C4JStorage::ESaveGameState			C4JStorage::LoadSaveData(PSAVE_INFO pSaveInfo,int( *Func)(LPVOID lpParam,const bool, const bool), LPVOID lpParam) {return C4JStorage::ESaveGame_Idle;}
+C4JStorage::ESaveGameState			C4JStorage::LoadSaveData(PSAVE_INFO pSaveInfo, int(*Func)(LPVOID lpParam, const bool, const bool), LPVOID lpParam) { return C4JStorage::ESaveGame_Idle; }
-C4JStorage::EDeleteGameStatus		C4JStorage::DeleteSaveData(PSAVE_INFO pSaveInfo,int( *Func)(LPVOID lpParam,const bool), LPVOID lpParam) { return C4JStorage::EDeleteGame_Idle; }
+C4JStorage::EDeleteGameStatus		C4JStorage::DeleteSaveData(PSAVE_INFO pSaveInfo, int(*Func)(LPVOID lpParam, const bool), LPVOID lpParam) { return C4JStorage::EDeleteGame_Idle; }
-PSAVE_DETAILS						C4JStorage::ReturnSavesInfo() {return NULL;}
+PSAVE_DETAILS						C4JStorage::ReturnSavesInfo() { return NULL; }
 
-void								C4JStorage::RegisterMarketplaceCountsCallback(int ( *Func)(LPVOID lpParam, C4JStorage::DLC_TMS_DETAILS *, int), LPVOID lpParam ) {}
+void								C4JStorage::RegisterMarketplaceCountsCallback(int (*Func)(LPVOID lpParam, C4JStorage::DLC_TMS_DETAILS*, int), LPVOID lpParam) {}
-void								C4JStorage::SetDLCPackageRoot(char *pszDLCRoot) {}
+void								C4JStorage::SetDLCPackageRoot(char* pszDLCRoot) {}
-C4JStorage::EDLCStatus				C4JStorage::GetDLCOffers(int iPad,int( *Func)(LPVOID, int, DWORD, int),LPVOID lpParam, DWORD dwOfferTypesBitmaskT) { return C4JStorage::EDLC_Idle; }
+C4JStorage::EDLCStatus				C4JStorage::GetDLCOffers(int iPad, int(*Func)(LPVOID, int, DWORD, int), LPVOID lpParam, DWORD dwOfferTypesBitmaskT) { return C4JStorage::EDLC_Idle; }
 DWORD								C4JStorage::CancelGetDLCOffers() { return 0; }
 void								C4JStorage::ClearDLCOffers() {}
-XMARKETPLACE_CONTENTOFFER_INFO&		C4JStorage::GetOffer(DWORD dw) { static XMARKETPLACE_CONTENTOFFER_INFO retval = {0}; return retval; }
+XMARKETPLACE_CONTENTOFFER_INFO& C4JStorage::GetOffer(DWORD dw) { static XMARKETPLACE_CONTENTOFFER_INFO retval = { 0 }; return retval; }
 int									C4JStorage::GetOfferCount() { return 0; }
-DWORD								C4JStorage::InstallOffer(int iOfferIDC,ULONGLONG *ullOfferIDA,int( *Func)(LPVOID, int, int),LPVOID lpParam, bool bTrial) { return 0; }
+DWORD								C4JStorage::InstallOffer(int iOfferIDC, ULONGLONG * ullOfferIDA, int(*Func)(LPVOID, int, int), LPVOID lpParam, bool bTrial) { return 0; }
-DWORD								C4JStorage::GetAvailableDLCCount( int iPad) { return 0; }
+DWORD								C4JStorage::GetAvailableDLCCount(int iPad) { return 0; }
-XCONTENT_DATA&						C4JStorage::GetDLC(DWORD dw) { static XCONTENT_DATA retval = {0}; return retval; }
+XCONTENT_DATA& C4JStorage::GetDLC(DWORD dw) { static XCONTENT_DATA retval = { 0 }; return retval; }
-C4JStorage::EDLCStatus				C4JStorage::GetInstalledDLC(int iPad,int( *Func)(LPVOID, int, int),LPVOID lpParam) { return C4JStorage::EDLC_Idle; }
+C4JStorage::EDLCStatus				C4JStorage::GetInstalledDLC(int iPad, int(*Func)(LPVOID, int, int), LPVOID lpParam) { return C4JStorage::EDLC_Idle; }
-DWORD								C4JStorage::MountInstalledDLC(int iPad,DWORD dwDLC,int( *Func)(LPVOID, int, DWORD,DWORD),LPVOID lpParam,LPCSTR szMountDrive) { return 0; }
+DWORD								C4JStorage::MountInstalledDLC(int iPad, DWORD dwDLC, int(*Func)(LPVOID, int, DWORD, DWORD), LPVOID lpParam, LPCSTR szMountDrive) { return 0; }
 DWORD								C4JStorage::UnmountInstalledDLC(LPCSTR szMountDrive) { return 0; }
-C4JStorage::ETMSStatus				C4JStorage::ReadTMSFile(int iQuadrant,eGlobalStorage eStorageFacility,C4JStorage::eTMS_FileType eFileType, WCHAR *pwchFilename,BYTE **ppBuffer,DWORD *pdwBufferSize,int( *Func)(LPVOID, WCHAR *,int, bool, int),LPVOID lpParam, int iAction) { return C4JStorage::ETMSStatus_Idle; }
+C4JStorage::ETMSStatus				C4JStorage::ReadTMSFile(int iQuadrant, eGlobalStorage eStorageFacility, C4JStorage::eTMS_FileType eFileType, WCHAR * pwchFilename, BYTE * *ppBuffer, DWORD * pdwBufferSize, int(*Func)(LPVOID, WCHAR*, int, bool, int), LPVOID lpParam, int iAction) { return C4JStorage::ETMSStatus_Idle; }
-bool								C4JStorage::WriteTMSFile(int iQuadrant,eGlobalStorage eStorageFacility,WCHAR *pwchFilename,BYTE *pBuffer,DWORD dwBufferSize) { return true; }
+bool								C4JStorage::WriteTMSFile(int iQuadrant, eGlobalStorage eStorageFacility, WCHAR * pwchFilename, BYTE * pBuffer, DWORD dwBufferSize) { return true; }
-bool								C4JStorage::DeleteTMSFile(int iQuadrant,eGlobalStorage eStorageFacility,WCHAR *pwchFilename) { return true; }
+bool								C4JStorage::DeleteTMSFile(int iQuadrant, eGlobalStorage eStorageFacility, WCHAR * pwchFilename) { return true; }
-void								C4JStorage::StoreTMSPathName(WCHAR *pwchName) {}
+void								C4JStorage::StoreTMSPathName(WCHAR * pwchName) {}
-unsigned int						C4JStorage::CRC(unsigned char *buf, int len) { return 0; }
+unsigned int						C4JStorage::CRC(unsigned char* buf, int len) { return 0; }
 
 struct PTMSPP_FILEDATA;
-C4JStorage::ETMSStatus				C4JStorage::TMSPP_ReadFile(int iPad,C4JStorage::eGlobalStorage eStorageFacility,C4JStorage::eTMS_FILETYPEVAL eFileTypeVal,LPCSTR szFilename,int( *Func)(LPVOID,int,int,PTMSPP_FILEDATA, LPCSTR)/*=NULL*/,LPVOID lpParam/*=NULL*/, int iUserData/*=0*/) {return C4JStorage::ETMSStatus_Idle;}
+C4JStorage::ETMSStatus				C4JStorage::TMSPP_ReadFile(int iPad, C4JStorage::eGlobalStorage eStorageFacility, C4JStorage::eTMS_FILETYPEVAL eFileTypeVal, LPCSTR szFilename, int(*Func)(LPVOID, int, int, PTMSPP_FILEDATA, LPCSTR)/*=NULL*/, LPVOID lpParam/*=NULL*/, int iUserData/*=0*/) { return C4JStorage::ETMSStatus_Idle; }
 #endif // _WINDOWS64
 
 #endif // __PS3__
@@ -636,8 +716,8 @@ BOOL CSentientManager::RecordHeartBeat(DWORD dwUserId) { return true; }
 BOOL CSentientManager::RecordLevelStart(DWORD dwUserId, ESen_FriendOrMatch friendsOrMatch, ESen_CompeteOrCoop competeOrCoop, int difficulty, DWORD numberOfLocalPlayers, DWORD numberOfOnlinePlayers) { return true; }
 BOOL CSentientManager::RecordLevelExit(DWORD dwUserId, ESen_LevelExitStatus levelExitStatus) { return true; }
 BOOL CSentientManager::RecordLevelSaveOrCheckpoint(DWORD dwUserId, INT saveOrCheckPointID, INT saveSizeInBytes) { return true; }
-BOOL CSentientManager::RecordLevelResume(DWORD dwUserId, ESen_FriendOrMatch friendsOrMatch, ESen_CompeteOrCoop competeOrCoop, int difficulty, DWORD numberOfLocalPlayers, DWORD numberOfOnlinePlayers, INT saveOrCheckPointID)  { return true; }
+BOOL CSentientManager::RecordLevelResume(DWORD dwUserId, ESen_FriendOrMatch friendsOrMatch, ESen_CompeteOrCoop competeOrCoop, int difficulty, DWORD numberOfLocalPlayers, DWORD numberOfOnlinePlayers, INT saveOrCheckPointID) { return true; }
-BOOL CSentientManager::RecordPauseOrInactive(DWORD dwUserId)  { return true; }
+BOOL CSentientManager::RecordPauseOrInactive(DWORD dwUserId) { return true; }
 BOOL CSentientManager::RecordUnpauseOrActive(DWORD dwUserId) { return true; }
 BOOL CSentientManager::RecordMenuShown(DWORD dwUserId, INT menuID, INT optionalMenuSubID) { return true; }
 BOOL CSentientManager::RecordAchievementUnlocked(DWORD dwUserId, INT achievementID, INT achievementGamerscore) { return true; }

Minecraft.Client/Minecraft.Client.vcxproj

@@ -21547,6 +21547,7 @@ xcopy /q /y /i /s /e $(ProjectDir)Durango\CU  $(LayoutDir)Image\Loose\CU</Comman
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|ORBIS'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage_Vita|ORBIS'">true</ExcludedFromBuild>
     </ClInclude>
+    <ClInclude Include="Windows64\Network\WinsockNetLayer.h" />
     <ClInclude Include="Windows64\Resource.h">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage|Durango'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='CONTENTPACKAGE_SYMBOLS|Durango'">true</ExcludedFromBuild>
@@ -38310,6 +38311,7 @@ xcopy /q /y /i /s /e $(ProjectDir)Durango\CU  $(LayoutDir)Image\Loose\CU</Comman
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='CONTENTPACKAGE_SYMBOLS|Durango'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Durango'">true</ExcludedFromBuild>
     </ClCompile>
+    <ClCompile Include="Windows64\Network\WinsockNetLayer.cpp" />
     <ClCompile Include="Windows64\Windows64_App.cpp">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage|Durango'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='CONTENTPACKAGE_SYMBOLS|Durango'">true</ExcludedFromBuild>

Minecraft.Client/Minecraft.Client.vcxproj.filters

@@ -723,9 +723,13 @@
     <Filter Include="PSVita\Miles Sound System\lib">
       <UniqueIdentifier>{0061db22-43de-4b54-a161-c43958cdcd7e}</UniqueIdentifier>
     </Filter>
-    <Filter Include="net\minecraft\client\resources">
+      <Filter Include="net\minecraft\client\resources">
       <UniqueIdentifier>{889a84db-3009-4a7c-8234-4bf93d412690}</UniqueIdentifier>
     </Filter>
+      <Filter Include="Windows64\Source Files\Network">
+      <UniqueIdentifier>{e5d7fb24-25b8-413c-84ec-974bf0d4a3d1}</UniqueIdentifier>
+    </Filter>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <None Include="ReadMe.txt" />
@@ -3613,7 +3617,7 @@
     <ClInclude Include="Common\UI\UIScene_Keyboard.h">
       <Filter>Common\Source Files\UI\Scenes</Filter>
     </ClInclude>
-    <ClInclude Include="Common\Leaderboards\SonyLeaderboardManager.h">
+<ClInclude Include="Common\Leaderboards\SonyLeaderboardManager.h">
       <Filter>Common\Source Files\Leaderboards</Filter>
     </ClInclude>
     <ClInclude Include="Common\Leaderboards\base64.h">
@@ -3769,6 +3773,9 @@
     <ClInclude Include="Common\Leaderboards\LeaderboardInterface.h">
       <Filter>Common\Source Files\Leaderboards</Filter>
     </ClInclude>
+    <ClInclude Include="Windows64\Network\WinsockNetLayer.h">
+      <Filter>Windows64\Source Files\Network</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="stdafx.cpp">
@@ -5916,6 +5923,9 @@
     <ClCompile Include="compat_shims.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Windows64\Network\WinsockNetLayer.cpp">
+      <Filter>Windows64\Source Files\Network</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <Library Include="Xbox\4JLibs\libs\4J_Render_d.lib">

Minecraft.Client/MultiPlayerGameMode.cpp

@@ -6,6 +6,7 @@
 #include "Minecraft.h"
 #include "ClientConnection.h"
 #include "LevelRenderer.h"
+#include "Common\Network\GameNetworkManager.h"
 #include "..\Minecraft.World\net.minecraft.world.level.h"
 #include "..\Minecraft.World\net.minecraft.world.item.h"
 #include "..\Minecraft.World\net.minecraft.world.entity.player.h"
@@ -85,6 +86,14 @@ bool MultiPlayerGameMode::destroyBlock(int x, int y, int z, int face)
 
 	if (oldTile == NULL) return false;
 
+#ifdef _WINDOWS64
+	if (g_NetworkManager.IsHost())
+	{
+		level->levelEvent(LevelEvent::PARTICLES_DESTROY_BLOCK, x, y, z, oldTile->id + (level->getData(x, y, z) << Tile::TILE_NUM_SHIFT));
+		return true;
+	}
+#endif
+
 	level->levelEvent(LevelEvent::PARTICLES_DESTROY_BLOCK, x, y, z, oldTile->id + (level->getData(x, y, z) << Tile::TILE_NUM_SHIFT));
 
 	int data = level->getData(x, y, z);

Minecraft.Client/PendingConnection.cpp

@@ -20,6 +20,10 @@
 
 Random *PendingConnection::random = new Random();
 
+#ifdef _WINDOWS64
+bool g_bRejectDuplicateNames = true;
+#endif
+
 PendingConnection::PendingConnection(MinecraftServer *server, Socket *socket, const wstring& id)
 {
 	// 4J - added initialisers
@@ -166,6 +170,30 @@ void PendingConnection::handleLogin(shared_ptr<LoginPacket> packet)
 	{
 		disconnect(DisconnectPacket::eDisconnect_Banned);
 	}
+#ifdef _WINDOWS64
+	else if (g_bRejectDuplicateNames)
+	{
+		bool nameTaken = false;
+		vector<shared_ptr<ServerPlayer> >& pl = server->getPlayers()->players;
+		for (unsigned int i = 0; i < pl.size(); i++)
+		{
+			if (pl[i] != NULL && pl[i]->name == name)
+			{
+				nameTaken = true;
+				break;
+			}
+		}
+		if (nameTaken)
+		{
+			app.DebugPrintf("Rejecting duplicate name: %ls\n", name.c_str());
+			disconnect(DisconnectPacket::eDisconnect_Banned);
+		}
+		else
+		{
+			handleAcceptedLogin(packet);
+		}
+	}
+#endif
 	else
 	{
 		handleAcceptedLogin(packet);

Minecraft.Client/PlayerList.cpp

@@ -25,7 +25,7 @@
 #include "..\Minecraft.World\net.minecraft.world.level.saveddata.h"
 #include "..\Minecraft.World\JavaMath.h"
 #include "..\Minecraft.World\EntityIO.h"
-#ifdef _XBOX
+#if defined(_XBOX) || defined(_WINDOWS64)
 #include "Xbox\Network\NetworkPlayerXbox.h"
 #elif defined(__PS3__) || defined(__ORBIS__)
 #include "Common\Network\Sony\NetworkPlayerSony.h"
@@ -56,6 +56,11 @@ PlayerList::PlayerList(MinecraftServer *server)
 	maxPlayers = server->settings->getInt(L"max-players", 20);
 	doWhiteList = false;
 
+#ifdef _WINDOWS64
+	maxPlayers = MINECRAFT_NET_MAX_PLAYERS;
+#else
+	maxPlayers = server->settings->getInt(L"max-players", 20);
+#endif
 	InitializeCriticalSection(&m_kickPlayersCS);
 	InitializeCriticalSection(&m_closePlayersCS);
 }
@@ -100,7 +105,14 @@ void PlayerList::placeNewPlayer(Connection *connection, shared_ptr<ServerPlayer>
 		}
 	}
 #endif
-
+#ifdef _WINDOWS64
+	if (networkPlayer != NULL && !networkPlayer->IsLocal())
+	{
+		NetworkPlayerXbox* nxp = (NetworkPlayerXbox*)networkPlayer;
+		IQNetPlayer* qnp = nxp->GetQNetPlayer();
+		wcsncpy_s(qnp->m_gamertag, 32, player->name.c_str(), _TRUNCATE);
+	}
+#endif
 	// 4J Stu - TU-1 hotfix
 	// Fix for #13150 - When a player loads/joins a game after saving/leaving in the nether, sometimes they are spawned on top of the nether and cannot mine down
 	validatePlayerSpawnPosition(player);
@@ -227,7 +239,7 @@ void PlayerList::placeNewPlayer(Connection *connection, shared_ptr<ServerPlayer>
 	sendLevelInfo(player, level);
 
 	// 4J-PB - removed, since it needs to be localised in the language the client is in
-	//server->players->broadcastAll( shared_ptr<ChatPacket>( new ChatPacket(L"<22>e" + playerEntity->name + L" joined the game.") ) );
+	//server->players->broadcastAll( shared_ptr<ChatPacket>( new ChatPacket(L"<22>e" + playerEntity->name + L" joined the game.") ) );
 	broadcastAll( shared_ptr<ChatPacket>( new ChatPacket(player->name, ChatPacket::e_ChatPlayerJoinedGame) ) );
 
 	MemSect(14);
@@ -428,7 +440,7 @@ void PlayerList::add(shared_ptr<ServerPlayer> player)
 	// Some code from here has been moved to the above validatePlayerSpawnPosition function
 
 	// 4J Stu - Swapped these lines about so that we get the chunk visiblity packet way ahead of all the add tracked entity packets
-	// Fix for #9169 - ART : Sign text is replaced with the words <20>Awaiting approval<61>.
+	// Fix for #9169 - ART : Sign text is replaced with the words <20>Awaiting approval<61>.
 	changeDimension(player, NULL);
 	level->addEntity(player);
 
@@ -469,14 +481,12 @@ void PlayerList::remove(shared_ptr<ServerPlayer> player)
 	//4J Stu - We don't want to save the map data for guests, so when we are sure that the player is gone delete the map
 	if(player->isGuest()) playerIo->deleteMapFilesForPlayer(player);
 	ServerLevel *level = player->getLevel();
-	if (player->riding != NULL)
+if (player->riding != NULL)
 	{
-		// remove mount first because the player unmounts when being
-		// removed, also remove mount because it's saved in the player's
-		// save tag
 		level->removeEntityImmediately(player->riding);
 		app.DebugPrintf("removing player mount");
 	}
+	level->getTracker()->removeEntity(player);
 	level->removeEntity(player);
 	level->getChunkMap()->remove(player);
 	AUTO_VAR(it, find(players.begin(),players.end(),player));
@@ -497,17 +507,30 @@ void PlayerList::remove(shared_ptr<ServerPlayer> player)
 
 shared_ptr<ServerPlayer> PlayerList::getPlayerForLogin(PendingConnection *pendingConnection, const wstring& userName, PlayerUID xuid, PlayerUID onlineXuid)
 {
-	if (players.size() >= maxPlayers)
+#ifdef _WINDOWS64
+	if (players.size() >= (unsigned int)MINECRAFT_NET_MAX_PLAYERS)
+#else
+	if (players.size() >= (unsigned int)maxPlayers)
+#endif
 	{
 		pendingConnection->disconnect(DisconnectPacket::eDisconnect_ServerFull);
 		return shared_ptr<ServerPlayer>();
 	}
-
 	shared_ptr<ServerPlayer> player = shared_ptr<ServerPlayer>(new ServerPlayer(server, server->getLevel(0), userName, new ServerPlayerGameMode(server->getLevel(0)) ));
 	player->gameMode->player = player; // 4J added as had to remove this assignment from ServerPlayer ctor
 	player->setXuid( xuid ); // 4J Added
 	player->setOnlineXuid( onlineXuid ); // 4J Added
-
+#ifdef _WINDOWS64
+	{
+		INetworkPlayer* np = pendingConnection->connection->getSocket()->getPlayer();
+		if (np != NULL)
+		{
+			PlayerUID realXuid = np->GetUID();
+			player->setXuid(realXuid);
+			player->setOnlineXuid(realXuid);
+		}
+	}
+#endif
 	// Work out the base server player settings
 	INetworkPlayer *networkPlayer = pendingConnection->connection->getSocket()->getPlayer();
 	if(networkPlayer != NULL && !networkPlayer->IsHost())

Minecraft.Client/Windows64/Network/WinsockNetLayer.cpp

@@ -0,0 +1,844 @@
+#include "stdafx.h"
+
+#ifdef _WINDOWS64
+
+#include "WinsockNetLayer.h"
+#include "..\..\Common\Network\PlatformNetworkManagerStub.h"
+#include "..\..\..\Minecraft.World\Socket.h"
+
+SOCKET WinsockNetLayer::s_listenSocket = INVALID_SOCKET;
+SOCKET WinsockNetLayer::s_hostConnectionSocket = INVALID_SOCKET;
+HANDLE WinsockNetLayer::s_acceptThread = NULL;
+HANDLE WinsockNetLayer::s_clientRecvThread = NULL;
+
+bool WinsockNetLayer::s_isHost = false;
+bool WinsockNetLayer::s_connected = false;
+bool WinsockNetLayer::s_active = false;
+bool WinsockNetLayer::s_initialized = false;
+
+BYTE WinsockNetLayer::s_localSmallId = 0;
+BYTE WinsockNetLayer::s_hostSmallId = 0;
+BYTE WinsockNetLayer::s_nextSmallId = 1;
+
+CRITICAL_SECTION WinsockNetLayer::s_sendLock;
+CRITICAL_SECTION WinsockNetLayer::s_connectionsLock;
+
+std::vector<Win64RemoteConnection> WinsockNetLayer::s_connections;
+
+SOCKET WinsockNetLayer::s_advertiseSock = INVALID_SOCKET;
+HANDLE WinsockNetLayer::s_advertiseThread = NULL;
+volatile bool WinsockNetLayer::s_advertising = false;
+Win64LANBroadcast WinsockNetLayer::s_advertiseData = {};
+CRITICAL_SECTION WinsockNetLayer::s_advertiseLock;
+int WinsockNetLayer::s_hostGamePort = WIN64_NET_DEFAULT_PORT;
+
+SOCKET WinsockNetLayer::s_discoverySock = INVALID_SOCKET;
+HANDLE WinsockNetLayer::s_discoveryThread = NULL;
+volatile bool WinsockNetLayer::s_discovering = false;
+CRITICAL_SECTION WinsockNetLayer::s_discoveryLock;
+std::vector<Win64LANSession> WinsockNetLayer::s_discoveredSessions;
+
+CRITICAL_SECTION WinsockNetLayer::s_disconnectLock;
+std::vector<BYTE> WinsockNetLayer::s_disconnectedSmallIds;
+
+CRITICAL_SECTION WinsockNetLayer::s_freeSmallIdLock;
+std::vector<BYTE> WinsockNetLayer::s_freeSmallIds;
+
+bool g_Win64MultiplayerHost = false;
+bool g_Win64MultiplayerJoin = false;
+int g_Win64MultiplayerPort = WIN64_NET_DEFAULT_PORT;
+char g_Win64MultiplayerIP[256] = "127.0.0.1";
+
+bool WinsockNetLayer::Initialize()
+{
+	if (s_initialized) return true;
+
+	WSADATA wsaData;
+	int result = WSAStartup(MAKEWORD(2, 2), &wsaData);
+	if (result != 0)
+	{
+		app.DebugPrintf("WSAStartup failed: %d\n", result);
+		return false;
+	}
+
+	InitializeCriticalSection(&s_sendLock);
+	InitializeCriticalSection(&s_connectionsLock);
+	InitializeCriticalSection(&s_advertiseLock);
+	InitializeCriticalSection(&s_discoveryLock);
+	InitializeCriticalSection(&s_disconnectLock);
+	InitializeCriticalSection(&s_freeSmallIdLock);
+
+	s_initialized = true;
+
+	StartDiscovery();
+
+	return true;
+}
+
+void WinsockNetLayer::Shutdown()
+{
+	StopAdvertising();
+	StopDiscovery();
+
+	s_active = false;
+	s_connected = false;
+
+	if (s_listenSocket != INVALID_SOCKET)
+	{
+		closesocket(s_listenSocket);
+		s_listenSocket = INVALID_SOCKET;
+	}
+
+	if (s_hostConnectionSocket != INVALID_SOCKET)
+	{
+		closesocket(s_hostConnectionSocket);
+		s_hostConnectionSocket = INVALID_SOCKET;
+	}
+
+	EnterCriticalSection(&s_connectionsLock);
+	for (size_t i = 0; i < s_connections.size(); i++)
+	{
+		s_connections[i].active = false;
+		if (s_connections[i].tcpSocket != INVALID_SOCKET)
+		{
+			closesocket(s_connections[i].tcpSocket);
+		}
+	}
+	s_connections.clear();
+	LeaveCriticalSection(&s_connectionsLock);
+
+	if (s_acceptThread != NULL)
+	{
+		WaitForSingleObject(s_acceptThread, 2000);
+		CloseHandle(s_acceptThread);
+		s_acceptThread = NULL;
+	}
+
+	if (s_clientRecvThread != NULL)
+	{
+		WaitForSingleObject(s_clientRecvThread, 2000);
+		CloseHandle(s_clientRecvThread);
+		s_clientRecvThread = NULL;
+	}
+
+	if (s_initialized)
+	{
+		DeleteCriticalSection(&s_sendLock);
+		DeleteCriticalSection(&s_connectionsLock);
+		DeleteCriticalSection(&s_advertiseLock);
+		DeleteCriticalSection(&s_discoveryLock);
+		DeleteCriticalSection(&s_disconnectLock);
+		s_disconnectedSmallIds.clear();
+		DeleteCriticalSection(&s_freeSmallIdLock);
+		s_freeSmallIds.clear();
+		WSACleanup();
+		s_initialized = false;
+	}
+}
+
+bool WinsockNetLayer::HostGame(int port)
+{
+	if (!s_initialized && !Initialize()) return false;
+
+	s_isHost = true;
+	s_localSmallId = 0;
+	s_hostSmallId = 0;
+	s_nextSmallId = 1;
+	s_hostGamePort = port;
+
+	EnterCriticalSection(&s_freeSmallIdLock);
+	s_freeSmallIds.clear();
+	LeaveCriticalSection(&s_freeSmallIdLock);
+
+	struct addrinfo hints = {};
+	struct addrinfo *result = NULL;
+
+	hints.ai_family = AF_INET;
+	hints.ai_socktype = SOCK_STREAM;
+	hints.ai_protocol = IPPROTO_TCP;
+	hints.ai_flags = AI_PASSIVE;
+
+	char portStr[16];
+	sprintf_s(portStr, "%d", port);
+
+	int iResult = getaddrinfo(NULL, portStr, &hints, &result);
+	if (iResult != 0)
+	{
+		app.DebugPrintf("getaddrinfo failed: %d\n", iResult);
+		return false;
+	}
+
+	s_listenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
+	if (s_listenSocket == INVALID_SOCKET)
+	{
+		app.DebugPrintf("socket() failed: %d\n", WSAGetLastError());
+		freeaddrinfo(result);
+		return false;
+	}
+
+	int opt = 1;
+	setsockopt(s_listenSocket, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof(opt));
+
+	iResult = ::bind(s_listenSocket, result->ai_addr, (int)result->ai_addrlen);
+	freeaddrinfo(result);
+	if (iResult == SOCKET_ERROR)
+	{
+		app.DebugPrintf("bind() failed: %d\n", WSAGetLastError());
+		closesocket(s_listenSocket);
+		s_listenSocket = INVALID_SOCKET;
+		return false;
+	}
+
+	iResult = listen(s_listenSocket, SOMAXCONN);
+	if (iResult == SOCKET_ERROR)
+	{
+		app.DebugPrintf("listen() failed: %d\n", WSAGetLastError());
+		closesocket(s_listenSocket);
+		s_listenSocket = INVALID_SOCKET;
+		return false;
+	}
+
+	s_active = true;
+	s_connected = true;
+
+	s_acceptThread = CreateThread(NULL, 0, AcceptThreadProc, NULL, 0, NULL);
+
+	app.DebugPrintf("Win64 LAN: Hosting on port %d\n", port);
+	return true;
+}
+
+bool WinsockNetLayer::JoinGame(const char *ip, int port)
+{
+	if (!s_initialized && !Initialize()) return false;
+
+	s_isHost = false;
+	s_hostSmallId = 0;
+
+	struct addrinfo hints = {};
+	struct addrinfo *result = NULL;
+
+	hints.ai_family = AF_INET;
+	hints.ai_socktype = SOCK_STREAM;
+	hints.ai_protocol = IPPROTO_TCP;
+
+	char portStr[16];
+	sprintf_s(portStr, "%d", port);
+
+	int iResult = getaddrinfo(ip, portStr, &hints, &result);
+	if (iResult != 0)
+	{
+		app.DebugPrintf("getaddrinfo failed for %s:%d - %d\n", ip, port, iResult);
+		return false;
+	}
+
+	s_hostConnectionSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
+	if (s_hostConnectionSocket == INVALID_SOCKET)
+	{
+		app.DebugPrintf("socket() failed: %d\n", WSAGetLastError());
+		freeaddrinfo(result);
+		return false;
+	}
+
+	int noDelay = 1;
+	setsockopt(s_hostConnectionSocket, IPPROTO_TCP, TCP_NODELAY, (const char *)&noDelay, sizeof(noDelay));
+
+	iResult = connect(s_hostConnectionSocket, result->ai_addr, (int)result->ai_addrlen);
+	freeaddrinfo(result);
+	if (iResult == SOCKET_ERROR)
+	{
+		app.DebugPrintf("connect() to %s:%d failed: %d\n", ip, port, WSAGetLastError());
+		closesocket(s_hostConnectionSocket);
+		s_hostConnectionSocket = INVALID_SOCKET;
+		return false;
+	}
+
+	BYTE assignBuf[1];
+	int bytesRecv = recv(s_hostConnectionSocket, (char *)assignBuf, 1, 0);
+	if (bytesRecv != 1)
+	{
+		app.DebugPrintf("Failed to receive small ID assignment from host\n");
+		closesocket(s_hostConnectionSocket);
+		s_hostConnectionSocket = INVALID_SOCKET;
+		return false;
+	}
+	s_localSmallId = assignBuf[0];
+
+	app.DebugPrintf("Win64 LAN: Connected to %s:%d, assigned smallId=%d\n", ip, port, s_localSmallId);
+
+	s_active = true;
+	s_connected = true;
+
+	s_clientRecvThread = CreateThread(NULL, 0, ClientRecvThreadProc, NULL, 0, NULL);
+
+	return true;
+}
+
+bool WinsockNetLayer::SendOnSocket(SOCKET sock, const void *data, int dataSize)
+{
+	if (sock == INVALID_SOCKET || dataSize <= 0) return false;
+
+	EnterCriticalSection(&s_sendLock);
+
+	BYTE header[4];
+	header[0] = (BYTE)((dataSize >> 24) & 0xFF);
+	header[1] = (BYTE)((dataSize >> 16) & 0xFF);
+	header[2] = (BYTE)((dataSize >> 8) & 0xFF);
+	header[3] = (BYTE)(dataSize & 0xFF);
+
+	int totalSent = 0;
+	int toSend = 4;
+	while (totalSent < toSend)
+	{
+		int sent = send(sock, (const char *)header + totalSent, toSend - totalSent, 0);
+		if (sent == SOCKET_ERROR || sent == 0)
+		{
+			LeaveCriticalSection(&s_sendLock);
+			return false;
+		}
+		totalSent += sent;
+	}
+
+	totalSent = 0;
+	while (totalSent < dataSize)
+	{
+		int sent = send(sock, (const char *)data + totalSent, dataSize - totalSent, 0);
+		if (sent == SOCKET_ERROR || sent == 0)
+		{
+			LeaveCriticalSection(&s_sendLock);
+			return false;
+		}
+		totalSent += sent;
+	}
+
+	LeaveCriticalSection(&s_sendLock);
+	return true;
+}
+
+bool WinsockNetLayer::SendToSmallId(BYTE targetSmallId, const void *data, int dataSize)
+{
+	if (!s_active) return false;
+
+	if (s_isHost)
+	{
+		SOCKET sock = GetSocketForSmallId(targetSmallId);
+		if (sock == INVALID_SOCKET) return false;
+		return SendOnSocket(sock, data, dataSize);
+	}
+	else
+	{
+		return SendOnSocket(s_hostConnectionSocket, data, dataSize);
+	}
+}
+
+SOCKET WinsockNetLayer::GetSocketForSmallId(BYTE smallId)
+{
+	EnterCriticalSection(&s_connectionsLock);
+	for (size_t i = 0; i < s_connections.size(); i++)
+	{
+		if (s_connections[i].smallId == smallId && s_connections[i].active)
+		{
+			SOCKET sock = s_connections[i].tcpSocket;
+			LeaveCriticalSection(&s_connectionsLock);
+			return sock;
+		}
+	}
+	LeaveCriticalSection(&s_connectionsLock);
+	return INVALID_SOCKET;
+}
+
+static bool RecvExact(SOCKET sock, BYTE *buf, int len)
+{
+	int totalRecv = 0;
+	while (totalRecv < len)
+	{
+		int r = recv(sock, (char *)buf + totalRecv, len - totalRecv, 0);
+		if (r <= 0) return false;
+		totalRecv += r;
+	}
+	return true;
+}
+
+void WinsockNetLayer::HandleDataReceived(BYTE fromSmallId, BYTE toSmallId, unsigned char *data, unsigned int dataSize)
+{
+	INetworkPlayer *pPlayerFrom = g_NetworkManager.GetPlayerBySmallId(fromSmallId);
+	INetworkPlayer *pPlayerTo = g_NetworkManager.GetPlayerBySmallId(toSmallId);
+
+	if (pPlayerFrom == NULL || pPlayerTo == NULL) return;
+
+	if (s_isHost)
+	{
+		::Socket *pSocket = pPlayerFrom->GetSocket();
+		if (pSocket != NULL)
+			pSocket->pushDataToQueue(data, dataSize, false);
+	}
+	else
+	{
+		::Socket *pSocket = pPlayerTo->GetSocket();
+		if (pSocket != NULL)
+			pSocket->pushDataToQueue(data, dataSize, true);
+	}
+}
+
+DWORD WINAPI WinsockNetLayer::AcceptThreadProc(LPVOID param)
+{
+	while (s_active)
+	{
+		SOCKET clientSocket = accept(s_listenSocket, NULL, NULL);
+		if (clientSocket == INVALID_SOCKET)
+		{
+			if (s_active)
+				app.DebugPrintf("accept() failed: %d\n", WSAGetLastError());
+			break;
+		}
+
+		int noDelay = 1;
+		setsockopt(clientSocket, IPPROTO_TCP, TCP_NODELAY, (const char *)&noDelay, sizeof(noDelay));
+
+		extern QNET_STATE _iQNetStubState;
+		if (_iQNetStubState != QNET_STATE_GAME_PLAY)
+		{
+			app.DebugPrintf("Win64 LAN: Rejecting connection, game not ready\n");
+			closesocket(clientSocket);
+			continue;
+		}
+
+		BYTE assignedSmallId;
+		EnterCriticalSection(&s_freeSmallIdLock);
+		if (!s_freeSmallIds.empty())
+		{
+			assignedSmallId = s_freeSmallIds.back();
+			s_freeSmallIds.pop_back();
+		}
+		else if (s_nextSmallId < MINECRAFT_NET_MAX_PLAYERS)
+		{
+			assignedSmallId = s_nextSmallId++;
+		}
+		else
+		{
+			LeaveCriticalSection(&s_freeSmallIdLock);
+			app.DebugPrintf("Win64 LAN: Server full, rejecting connection\n");
+			closesocket(clientSocket);
+			continue;
+		}
+		LeaveCriticalSection(&s_freeSmallIdLock);
+
+		BYTE assignBuf[1] = { assignedSmallId };
+		int sent = send(clientSocket, (const char *)assignBuf, 1, 0);
+		if (sent != 1)
+		{
+			app.DebugPrintf("Failed to send small ID to client\n");
+			closesocket(clientSocket);
+			continue;
+		}
+
+		Win64RemoteConnection conn;
+		conn.tcpSocket = clientSocket;
+		conn.smallId = assignedSmallId;
+		conn.active = true;
+		conn.recvThread = NULL;
+
+		EnterCriticalSection(&s_connectionsLock);
+		s_connections.push_back(conn);
+		int connIdx = (int)s_connections.size() - 1;
+		LeaveCriticalSection(&s_connectionsLock);
+
+		app.DebugPrintf("Win64 LAN: Client connected, assigned smallId=%d\n", assignedSmallId);
+
+		IQNetPlayer *qnetPlayer = &IQNet::m_player[assignedSmallId];
+
+		extern void Win64_SetupRemoteQNetPlayer(IQNetPlayer *player, BYTE smallId, bool isHost, bool isLocal);
+		Win64_SetupRemoteQNetPlayer(qnetPlayer, assignedSmallId, false, false);
+
+		extern CPlatformNetworkManagerStub *g_pPlatformNetworkManager;
+		g_pPlatformNetworkManager->NotifyPlayerJoined(qnetPlayer);
+
+		DWORD *threadParam = new DWORD;
+		*threadParam = connIdx;
+		HANDLE hThread = CreateThread(NULL, 0, RecvThreadProc, threadParam, 0, NULL);
+
+		EnterCriticalSection(&s_connectionsLock);
+		if (connIdx < (int)s_connections.size())
+			s_connections[connIdx].recvThread = hThread;
+		LeaveCriticalSection(&s_connectionsLock);
+	}
+	return 0;
+}
+
+DWORD WINAPI WinsockNetLayer::RecvThreadProc(LPVOID param)
+{
+	DWORD connIdx = *(DWORD *)param;
+	delete (DWORD *)param;
+
+	EnterCriticalSection(&s_connectionsLock);
+	if (connIdx >= (DWORD)s_connections.size())
+	{
+		LeaveCriticalSection(&s_connectionsLock);
+		return 0;
+	}
+	SOCKET sock = s_connections[connIdx].tcpSocket;
+	BYTE clientSmallId = s_connections[connIdx].smallId;
+	LeaveCriticalSection(&s_connectionsLock);
+
+	BYTE *recvBuf = new BYTE[WIN64_NET_RECV_BUFFER_SIZE];
+
+	while (s_active)
+	{
+		BYTE header[4];
+		if (!RecvExact(sock, header, 4))
+		{
+			app.DebugPrintf("Win64 LAN: Client smallId=%d disconnected (header)\n", clientSmallId);
+			break;
+		}
+
+		int packetSize = (header[0] << 24) | (header[1] << 16) | (header[2] << 8) | header[3];
+
+		if (packetSize <= 0 || packetSize > WIN64_NET_RECV_BUFFER_SIZE)
+		{
+			app.DebugPrintf("Win64 LAN: Invalid packet size %d from client smallId=%d\n", packetSize, clientSmallId);
+			break;
+		}
+
+		if (!RecvExact(sock, recvBuf, packetSize))
+		{
+			app.DebugPrintf("Win64 LAN: Client smallId=%d disconnected (body)\n", clientSmallId);
+			break;
+		}
+
+		HandleDataReceived(clientSmallId, s_hostSmallId, recvBuf, packetSize);
+	}
+
+	delete[] recvBuf;
+
+	EnterCriticalSection(&s_connectionsLock);
+	for (size_t i = 0; i < s_connections.size(); i++)
+	{
+		if (s_connections[i].smallId == clientSmallId)
+		{
+			s_connections[i].active = false;
+			closesocket(s_connections[i].tcpSocket);
+			s_connections[i].tcpSocket = INVALID_SOCKET;
+			break;
+		}
+	}
+	LeaveCriticalSection(&s_connectionsLock);
+
+	EnterCriticalSection(&s_disconnectLock);
+	s_disconnectedSmallIds.push_back(clientSmallId);
+	LeaveCriticalSection(&s_disconnectLock);
+
+	return 0;
+}
+
+bool WinsockNetLayer::PopDisconnectedSmallId(BYTE *outSmallId)
+{
+	bool found = false;
+	EnterCriticalSection(&s_disconnectLock);
+	if (!s_disconnectedSmallIds.empty())
+	{
+		*outSmallId = s_disconnectedSmallIds.back();
+		s_disconnectedSmallIds.pop_back();
+		found = true;
+	}
+	LeaveCriticalSection(&s_disconnectLock);
+	return found;
+}
+
+void WinsockNetLayer::PushFreeSmallId(BYTE smallId)
+{
+	EnterCriticalSection(&s_freeSmallIdLock);
+	s_freeSmallIds.push_back(smallId);
+	LeaveCriticalSection(&s_freeSmallIdLock);
+}
+
+DWORD WINAPI WinsockNetLayer::ClientRecvThreadProc(LPVOID param)
+{
+	BYTE *recvBuf = new BYTE[WIN64_NET_RECV_BUFFER_SIZE];
+
+	while (s_active && s_hostConnectionSocket != INVALID_SOCKET)
+	{
+		BYTE header[4];
+		if (!RecvExact(s_hostConnectionSocket, header, 4))
+		{
+			app.DebugPrintf("Win64 LAN: Disconnected from host (header)\n");
+			break;
+		}
+
+		int packetSize = (header[0] << 24) | (header[1] << 16) | (header[2] << 8) | header[3];
+
+		if (packetSize <= 0 || packetSize > WIN64_NET_RECV_BUFFER_SIZE)
+		{
+			app.DebugPrintf("Win64 LAN: Invalid packet size %d from host\n", packetSize);
+			break;
+		}
+
+		if (!RecvExact(s_hostConnectionSocket, recvBuf, packetSize))
+		{
+			app.DebugPrintf("Win64 LAN: Disconnected from host (body)\n");
+			break;
+		}
+
+		HandleDataReceived(s_hostSmallId, s_localSmallId, recvBuf, packetSize);
+	}
+
+	delete[] recvBuf;
+
+	s_connected = false;
+	return 0;
+}
+
+bool WinsockNetLayer::StartAdvertising(int gamePort, const wchar_t *hostName, unsigned int gameSettings, unsigned int texPackId, unsigned char subTexId, unsigned short netVer)
+{
+	if (s_advertising) return true;
+	if (!s_initialized) return false;
+
+	EnterCriticalSection(&s_advertiseLock);
+	memset(&s_advertiseData, 0, sizeof(s_advertiseData));
+	s_advertiseData.magic = WIN64_LAN_BROADCAST_MAGIC;
+	s_advertiseData.netVersion = netVer;
+	s_advertiseData.gamePort = (WORD)gamePort;
+	wcsncpy_s(s_advertiseData.hostName, 32, hostName, _TRUNCATE);
+	s_advertiseData.playerCount = 1;
+	s_advertiseData.maxPlayers = MINECRAFT_NET_MAX_PLAYERS;
+	s_advertiseData.gameHostSettings = gameSettings;
+	s_advertiseData.texturePackParentId = texPackId;
+	s_advertiseData.subTexturePackId = subTexId;
+	s_advertiseData.isJoinable = 0;
+	s_hostGamePort = gamePort;
+	LeaveCriticalSection(&s_advertiseLock);
+
+	s_advertiseSock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+	if (s_advertiseSock == INVALID_SOCKET)
+	{
+		app.DebugPrintf("Win64 LAN: Failed to create advertise socket: %d\n", WSAGetLastError());
+		return false;
+	}
+
+	BOOL broadcast = TRUE;
+	setsockopt(s_advertiseSock, SOL_SOCKET, SO_BROADCAST, (const char *)&broadcast, sizeof(broadcast));
+
+	s_advertising = true;
+	s_advertiseThread = CreateThread(NULL, 0, AdvertiseThreadProc, NULL, 0, NULL);
+
+	app.DebugPrintf("Win64 LAN: Started advertising on UDP port %d\n", WIN64_LAN_DISCOVERY_PORT);
+	return true;
+}
+
+void WinsockNetLayer::StopAdvertising()
+{
+	s_advertising = false;
+
+	if (s_advertiseSock != INVALID_SOCKET)
+	{
+		closesocket(s_advertiseSock);
+		s_advertiseSock = INVALID_SOCKET;
+	}
+
+	if (s_advertiseThread != NULL)
+	{
+		WaitForSingleObject(s_advertiseThread, 2000);
+		CloseHandle(s_advertiseThread);
+		s_advertiseThread = NULL;
+	}
+}
+
+void WinsockNetLayer::UpdateAdvertisePlayerCount(BYTE count)
+{
+	EnterCriticalSection(&s_advertiseLock);
+	s_advertiseData.playerCount = count;
+	LeaveCriticalSection(&s_advertiseLock);
+}
+
+void WinsockNetLayer::UpdateAdvertiseJoinable(bool joinable)
+{
+	EnterCriticalSection(&s_advertiseLock);
+	s_advertiseData.isJoinable = joinable ? 1 : 0;
+	LeaveCriticalSection(&s_advertiseLock);
+}
+
+DWORD WINAPI WinsockNetLayer::AdvertiseThreadProc(LPVOID param)
+{
+	struct sockaddr_in broadcastAddr;
+	memset(&broadcastAddr, 0, sizeof(broadcastAddr));
+	broadcastAddr.sin_family = AF_INET;
+	broadcastAddr.sin_port = htons(WIN64_LAN_DISCOVERY_PORT);
+	broadcastAddr.sin_addr.s_addr = INADDR_BROADCAST;
+
+	while (s_advertising)
+	{
+		EnterCriticalSection(&s_advertiseLock);
+		Win64LANBroadcast data = s_advertiseData;
+		LeaveCriticalSection(&s_advertiseLock);
+
+		int sent = sendto(s_advertiseSock, (const char *)&data, sizeof(data), 0,
+			(struct sockaddr *)&broadcastAddr, sizeof(broadcastAddr));
+
+		if (sent == SOCKET_ERROR && s_advertising)
+		{
+			app.DebugPrintf("Win64 LAN: Broadcast sendto failed: %d\n", WSAGetLastError());
+		}
+
+		Sleep(1000);
+	}
+
+	return 0;
+}
+
+bool WinsockNetLayer::StartDiscovery()
+{
+	if (s_discovering) return true;
+	if (!s_initialized) return false;
+
+	s_discoverySock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+	if (s_discoverySock == INVALID_SOCKET)
+	{
+		app.DebugPrintf("Win64 LAN: Failed to create discovery socket: %d\n", WSAGetLastError());
+		return false;
+	}
+
+	BOOL reuseAddr = TRUE;
+	setsockopt(s_discoverySock, SOL_SOCKET, SO_REUSEADDR, (const char *)&reuseAddr, sizeof(reuseAddr));
+
+	struct sockaddr_in bindAddr;
+	memset(&bindAddr, 0, sizeof(bindAddr));
+	bindAddr.sin_family = AF_INET;
+	bindAddr.sin_port = htons(WIN64_LAN_DISCOVERY_PORT);
+	bindAddr.sin_addr.s_addr = INADDR_ANY;
+
+	if (::bind(s_discoverySock, (struct sockaddr *)&bindAddr, sizeof(bindAddr)) == SOCKET_ERROR)
+	{
+		app.DebugPrintf("Win64 LAN: Discovery bind failed: %d\n", WSAGetLastError());
+		closesocket(s_discoverySock);
+		s_discoverySock = INVALID_SOCKET;
+		return false;
+	}
+
+	DWORD timeout = 500;
+	setsockopt(s_discoverySock, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(timeout));
+
+	s_discovering = true;
+	s_discoveryThread = CreateThread(NULL, 0, DiscoveryThreadProc, NULL, 0, NULL);
+
+	app.DebugPrintf("Win64 LAN: Listening for LAN games on UDP port %d\n", WIN64_LAN_DISCOVERY_PORT);
+	return true;
+}
+
+void WinsockNetLayer::StopDiscovery()
+{
+	s_discovering = false;
+
+	if (s_discoverySock != INVALID_SOCKET)
+	{
+		closesocket(s_discoverySock);
+		s_discoverySock = INVALID_SOCKET;
+	}
+
+	if (s_discoveryThread != NULL)
+	{
+		WaitForSingleObject(s_discoveryThread, 2000);
+		CloseHandle(s_discoveryThread);
+		s_discoveryThread = NULL;
+	}
+
+	EnterCriticalSection(&s_discoveryLock);
+	s_discoveredSessions.clear();
+	LeaveCriticalSection(&s_discoveryLock);
+}
+
+std::vector<Win64LANSession> WinsockNetLayer::GetDiscoveredSessions()
+{
+	std::vector<Win64LANSession> result;
+	EnterCriticalSection(&s_discoveryLock);
+	result = s_discoveredSessions;
+	LeaveCriticalSection(&s_discoveryLock);
+	return result;
+}
+
+DWORD WINAPI WinsockNetLayer::DiscoveryThreadProc(LPVOID param)
+{
+	char recvBuf[512];
+
+	while (s_discovering)
+	{
+		struct sockaddr_in senderAddr;
+		int senderLen = sizeof(senderAddr);
+
+		int recvLen = recvfrom(s_discoverySock, recvBuf, sizeof(recvBuf), 0,
+			(struct sockaddr *)&senderAddr, &senderLen);
+
+		if (recvLen == SOCKET_ERROR)
+		{
+			continue;
+		}
+
+		if (recvLen < (int)sizeof(Win64LANBroadcast))
+			continue;
+
+		Win64LANBroadcast *broadcast = (Win64LANBroadcast *)recvBuf;
+		if (broadcast->magic != WIN64_LAN_BROADCAST_MAGIC)
+			continue;
+
+		char senderIP[64];
+		inet_ntop(AF_INET, &senderAddr.sin_addr, senderIP, sizeof(senderIP));
+
+		DWORD now = GetTickCount();
+
+		EnterCriticalSection(&s_discoveryLock);
+
+		bool found = false;
+		for (size_t i = 0; i < s_discoveredSessions.size(); i++)
+		{
+			if (strcmp(s_discoveredSessions[i].hostIP, senderIP) == 0 &&
+				s_discoveredSessions[i].hostPort == (int)broadcast->gamePort)
+			{
+				s_discoveredSessions[i].netVersion = broadcast->netVersion;
+				wcsncpy_s(s_discoveredSessions[i].hostName, 32, broadcast->hostName, _TRUNCATE);
+				s_discoveredSessions[i].playerCount = broadcast->playerCount;
+				s_discoveredSessions[i].maxPlayers = broadcast->maxPlayers;
+				s_discoveredSessions[i].gameHostSettings = broadcast->gameHostSettings;
+				s_discoveredSessions[i].texturePackParentId = broadcast->texturePackParentId;
+				s_discoveredSessions[i].subTexturePackId = broadcast->subTexturePackId;
+				s_discoveredSessions[i].isJoinable = (broadcast->isJoinable != 0);
+				s_discoveredSessions[i].lastSeenTick = now;
+				found = true;
+				break;
+			}
+		}
+
+		if (!found)
+		{
+			Win64LANSession session;
+			memset(&session, 0, sizeof(session));
+			strncpy_s(session.hostIP, sizeof(session.hostIP), senderIP, _TRUNCATE);
+			session.hostPort = (int)broadcast->gamePort;
+			session.netVersion = broadcast->netVersion;
+			wcsncpy_s(session.hostName, 32, broadcast->hostName, _TRUNCATE);
+			session.playerCount = broadcast->playerCount;
+			session.maxPlayers = broadcast->maxPlayers;
+			session.gameHostSettings = broadcast->gameHostSettings;
+			session.texturePackParentId = broadcast->texturePackParentId;
+			session.subTexturePackId = broadcast->subTexturePackId;
+			session.isJoinable = (broadcast->isJoinable != 0);
+			session.lastSeenTick = now;
+			s_discoveredSessions.push_back(session);
+
+			app.DebugPrintf("Win64 LAN: Discovered game \"%ls\" at %s:%d\n",
+				session.hostName, session.hostIP, session.hostPort);
+		}
+
+		for (size_t i = s_discoveredSessions.size(); i > 0; i--)
+		{
+			if (now - s_discoveredSessions[i - 1].lastSeenTick > 5000)
+			{
+				app.DebugPrintf("Win64 LAN: Session \"%ls\" at %s timed out\n",
+					s_discoveredSessions[i - 1].hostName, s_discoveredSessions[i - 1].hostIP);
+				s_discoveredSessions.erase(s_discoveredSessions.begin() + (i - 1));
+			}
+		}
+
+		LeaveCriticalSection(&s_discoveryLock);
+	}
+
+	return 0;
+}
+
+#endif

Minecraft.Client/Windows64/Network/WinsockNetLayer.h

@@ -0,0 +1,147 @@
+#pragma once
+
+#ifdef _WINDOWS64
+
+#include <WinSock2.h>
+#include <WS2tcpip.h>
+#include <vector>
+#include "..\..\Common\Network\NetworkPlayerInterface.h"
+
+#pragma comment(lib, "Ws2_32.lib")
+
+#define WIN64_NET_DEFAULT_PORT 25565
+#define WIN64_NET_MAX_CLIENTS 7
+#define WIN64_NET_RECV_BUFFER_SIZE 65536
+#define WIN64_LAN_DISCOVERY_PORT 25566
+#define WIN64_LAN_BROADCAST_MAGIC 0x4D434C4E
+
+class Socket;
+
+#pragma pack(push, 1)
+struct Win64LANBroadcast
+{
+	DWORD magic;
+	WORD netVersion;
+	WORD gamePort;
+	wchar_t hostName[32];
+	BYTE playerCount;
+	BYTE maxPlayers;
+	DWORD gameHostSettings;
+	DWORD texturePackParentId;
+	BYTE subTexturePackId;
+	BYTE isJoinable;
+};
+#pragma pack(pop)
+
+struct Win64LANSession
+{
+	char hostIP[64];
+	int hostPort;
+	wchar_t hostName[32];
+	unsigned short netVersion;
+	unsigned char playerCount;
+	unsigned char maxPlayers;
+	unsigned int gameHostSettings;
+	unsigned int texturePackParentId;
+	unsigned char subTexturePackId;
+	bool isJoinable;
+	DWORD lastSeenTick;
+};
+
+struct Win64RemoteConnection
+{
+	SOCKET tcpSocket;
+	BYTE smallId;
+	HANDLE recvThread;
+	volatile bool active;
+};
+
+class WinsockNetLayer
+{
+public:
+	static bool Initialize();
+	static void Shutdown();
+
+	static bool HostGame(int port);
+	static bool JoinGame(const char *ip, int port);
+
+	static bool SendToSmallId(BYTE targetSmallId, const void *data, int dataSize);
+	static bool SendOnSocket(SOCKET sock, const void *data, int dataSize);
+
+	static bool IsHosting() { return s_isHost; }
+	static bool IsConnected() { return s_connected; }
+	static bool IsActive() { return s_active; }
+
+	static BYTE GetLocalSmallId() { return s_localSmallId; }
+	static BYTE GetHostSmallId() { return s_hostSmallId; }
+
+	static SOCKET GetSocketForSmallId(BYTE smallId);
+
+	static void HandleDataReceived(BYTE fromSmallId, BYTE toSmallId, unsigned char *data, unsigned int dataSize);
+
+	static bool PopDisconnectedSmallId(BYTE *outSmallId);
+	static void PushFreeSmallId(BYTE smallId);
+
+	static bool StartAdvertising(int gamePort, const wchar_t *hostName, unsigned int gameSettings, unsigned int texPackId, unsigned char subTexId, unsigned short netVer);
+	static void StopAdvertising();
+	static void UpdateAdvertisePlayerCount(BYTE count);
+	static void UpdateAdvertiseJoinable(bool joinable);
+
+	static bool StartDiscovery();
+	static void StopDiscovery();
+	static std::vector<Win64LANSession> GetDiscoveredSessions();
+
+	static int GetHostPort() { return s_hostGamePort; }
+
+private:
+	static DWORD WINAPI AcceptThreadProc(LPVOID param);
+	static DWORD WINAPI RecvThreadProc(LPVOID param);
+	static DWORD WINAPI ClientRecvThreadProc(LPVOID param);
+	static DWORD WINAPI AdvertiseThreadProc(LPVOID param);
+	static DWORD WINAPI DiscoveryThreadProc(LPVOID param);
+
+	static SOCKET s_listenSocket;
+	static SOCKET s_hostConnectionSocket;
+	static HANDLE s_acceptThread;
+	static HANDLE s_clientRecvThread;
+
+	static bool s_isHost;
+	static bool s_connected;
+	static bool s_active;
+	static bool s_initialized;
+
+	static BYTE s_localSmallId;
+	static BYTE s_hostSmallId;
+	static BYTE s_nextSmallId;
+
+	static CRITICAL_SECTION s_sendLock;
+	static CRITICAL_SECTION s_connectionsLock;
+
+	static std::vector<Win64RemoteConnection> s_connections;
+
+	static SOCKET s_advertiseSock;
+	static HANDLE s_advertiseThread;
+	static volatile bool s_advertising;
+	static Win64LANBroadcast s_advertiseData;
+	static CRITICAL_SECTION s_advertiseLock;
+	static int s_hostGamePort;
+
+	static SOCKET s_discoverySock;
+	static HANDLE s_discoveryThread;
+	static volatile bool s_discovering;
+	static CRITICAL_SECTION s_discoveryLock;
+	static std::vector<Win64LANSession> s_discoveredSessions;
+
+	static CRITICAL_SECTION s_disconnectLock;
+	static std::vector<BYTE> s_disconnectedSmallIds;
+
+	static CRITICAL_SECTION s_freeSmallIdLock;
+	static std::vector<BYTE> s_freeSmallIds;
+};
+
+extern bool g_Win64MultiplayerHost;
+extern bool g_Win64MultiplayerJoin;
+extern int g_Win64MultiplayerPort;
+extern char g_Win64MultiplayerIP[256];
+
+#endif

Minecraft.Client/Windows64/Windows64_App.cpp

@@ -57,7 +57,8 @@ void CConsoleMinecraftApp::TemporaryCreateGameStart()
 	Minecraft *pMinecraft=Minecraft::GetInstance();
 	app.ReleaseSaveThumbnail();
 	ProfileManager.SetLockedProfile(0);
-	pMinecraft->user->name = L"Windows";
+	extern wchar_t g_Win64UsernameW[17];
+	pMinecraft->user->name = g_Win64UsernameW;
 	app.ApplyGameSettingsChanged(0);
 
 	////////////////////////////////////////////////////////////////////////////////////////////// From CScene_MultiGameJoinLoad::OnInit

Minecraft.Client/Windows64/Windows64_Minecraft.cpp

@@ -37,6 +37,7 @@
 #include "Resource.h"
 #include "..\..\Minecraft.World\compression.h"
 #include "..\..\Minecraft.World\OldChunkStorage.h"
+#include "Network\WinsockNetLayer.h"
 
 #include "Xbox/resource.h"
 
@@ -84,6 +85,8 @@ BOOL g_bWidescreen = TRUE;
 int g_iScreenWidth = 1920;
 int g_iScreenHeight = 1080;
 
+char g_Win64Username[17] = { 0 };
+wchar_t g_Win64UsernameW[17] = { 0 };
 UINT g_ScreenWidth = 1920;
 UINT g_ScreenHeight = 1080;
 
@@ -850,8 +853,41 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 			//g_iScreenWidth = 960;
 			//g_iScreenHeight = 544;
 		}
+
+		char cmdLineA[1024];
+		strncpy_s(cmdLineA, sizeof(cmdLineA), lpCmdLine, _TRUNCATE);
+
+		char* nameArg = strstr(cmdLineA, "-name ");
+		if (nameArg)
+		{
+			nameArg += 6;
+			while (*nameArg == ' ') nameArg++;
+			char nameBuf[17];
+			int n = 0;
+			while (nameArg[n] && nameArg[n] != ' ' && n < 16) { nameBuf[n] = nameArg[n]; n++; }
+			nameBuf[n] = 0;
+			strncpy_s(g_Win64Username, 17, nameBuf, _TRUNCATE);
+		}
 	}
 
+	if (g_Win64Username[0] == 0)
+	{
+		DWORD sz = 17;
+		static bool seeded = false;
+		if (!seeded)
+		{
+			seeded = true;
+			srand((unsigned int)time(NULL));
+		}
+
+		int r = rand() % 10000; // 0<>9999
+
+		snprintf(g_Win64Username, 17, "Player%04d", r);
+
+		g_Win64Username[16] = 0;
+	}
+
+	MultiByteToWideChar(CP_ACP, 0, g_Win64Username, -1, g_Win64UsernameW, 17);
 
 	// Initialize global strings
 	MyRegisterClass(hInstance);
@@ -1017,7 +1053,17 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 	// ProfileManager for XN_LIVE_INVITE_ACCEPTED for QNet.
 	g_NetworkManager.Initialise();
 
+	for (int i = 0; i < MINECRAFT_NET_MAX_PLAYERS; i++)
+	{
+		IQNet::m_player[i].m_smallId = (BYTE)i;
+		IQNet::m_player[i].m_isRemote = false;
+		IQNet::m_player[i].m_isHostPlayer = (i == 0);
+		swprintf_s(IQNet::m_player[i].m_gamertag, 32, L"Player%d", i);
+	}
+	extern wchar_t g_Win64UsernameW[17];
+	wcscpy_s(IQNet::m_player[0].m_gamertag, 32, g_Win64UsernameW);
 
+	WinsockNetLayer::Initialize();
 
 	// 4J-PB moved further down
 	//app.InitGameSettings();
@@ -1189,7 +1235,7 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 		PIXEndNamedEvent();
 
 		PIXBeginNamedEvent(0,"Network manager do work #1");
-		//		g_NetworkManager.DoWork();
+		g_NetworkManager.DoWork();
 		PIXEndNamedEvent();
 
 		//		LeaderboardManager::Instance()->Tick();

Minecraft.World/x64headers/extraX64.h

@@ -215,10 +215,17 @@ public:
 	int GetUserIndex();
 	void SetCustomDataValue(ULONG_PTR ulpCustomDataValue);
 	ULONG_PTR GetCustomDataValue();
+
+    BYTE m_smallId;
+    bool m_isRemote;
+    bool m_isHostPlayer;
+    wchar_t m_gamertag[32];
 private:
 	ULONG_PTR m_customData;
 };
 
+void Win64_SetupRemoteQNetPlayer(IQNetPlayer* player, BYTE smallId, bool isHost, bool isLocal);
+
 const int QNET_GETSENDQUEUESIZE_SECONDARY_TYPE = 0;
 const int QNET_GETSENDQUEUESIZE_MESSAGES = 0;
 const int QNET_GETSENDQUEUESIZE_BYTES = 0;
@@ -309,9 +316,12 @@ public:
 	bool IsHost();
 	HRESULT JoinGameFromInviteInfo(DWORD dwUserIndex, DWORD dwUserMask, const INVITE_INFO *pInviteInfo);
 	void HostGame();
-	void EndGame();
+    void ClientJoinGame();
+    void EndGame();
 
-	static IQNetPlayer m_player[4];
+    static IQNetPlayer m_player[MINECRAFT_NET_MAX_PLAYERS];
+    static DWORD s_playerCount;
+    static bool s_isHosting;
 };
 
 #ifdef _DURANGO

README.md

@@ -23,6 +23,7 @@ This project contains the source code of Minecraft Legacy Console Edition v1.6.0
 - Disabled V-Sync for better performance
 - Added a high-resolution timer path on Windows for smoother high-FPS gameplay timing
 - Device's screen resolution will be used as the game resolution instead of using a fixed resolution (1920x1080)
+- LAN Multiplayer & Discovery based on https://github.com/LCEMP/LCEMP/
 
 ## Controls (Keyboard & Mouse)