add lcemp networking + ps3 support

YES I KNOW ITS GARBAGE, THATS WHY ITS NOT ON MAIN

ILL FIX IT UP IN FUTURE COMMITS THEN MERGE TO MAIN

Minecraft.Client/Common/Network/GameNetworkManager.cpp

@@ -68,7 +68,7 @@ void CGameNetworkManager::Initialise()
 	int flagIndexSize = LevelRenderer::getGlobalChunkCount() / (Level::maxBuildHeight / 16);		// dividing here by number of renderer chunks in one column
 #ifdef _XBOX
 	s_pPlatformNetworkManager = new CPlatformNetworkManagerXbox();
-#elif defined __PS3__ || defined __ORBIS__ || defined __PSVITA__
+#elif !defined(DISABLE_PSN) && defined __PS3__ || defined __ORBIS__ || defined __PSVITA__
 	s_pPlatformNetworkManager = new CPlatformNetworkManagerSony();
 #elif defined _DURANGO
 	s_pPlatformNetworkManager = new CPlatformNetworkManagerDurango();
@@ -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;
 
@@ -336,10 +341,12 @@ bool	CGameNetworkManager::StartNetworkGame(Minecraft *minecraft, LPVOID lpParame
 
 	// 4J Stu - Wait a while to make sure that DLC is loaded. This is the last point before the network communication starts
 	// so the latest we can check this
+#ifndef DISABLE_PSN
 	while( !app.DLCInstallProcessCompleted() && app.DLCInstallPending() && !g_NetworkManager.IsLeavingGame() )
 	{
 		Sleep( 10 );
 	}
+#endif
 	if( g_NetworkManager.IsLeavingGame() )
 	{
 		MinecraftServer::HaltServer();
@@ -496,7 +503,7 @@ bool	CGameNetworkManager::StartNetworkGame(Minecraft *minecraft, LPVOID lpParame
 				// The connections should tick at 20 per second
 				Sleep(50);
 				app.DebugPrintf("<***> %d %d %d %d %d\n",IsInSession(), !connection->isStarted(),!connection->isClosed(),ProfileManager.IsSignedIn(idx),!g_NetworkManager.IsLeavingGame());
-#if defined _XBOX || __PS3__
+#if defined _XBOX || defined __PS3__ && !defined DISABLE_PSN
 			} while (IsInSession() && !connection->isStarted() && !connection->isClosed() && ProfileManager.IsSignedIn(idx) && !g_NetworkManager.IsLeavingGame() );
 #else
 				// TODO - This SHOULD be something just like the code above but temporarily changing here so that we don't have to depend on the profilemanager behaviour
@@ -794,7 +801,7 @@ int CGameNetworkManager::JoinFromInvite_SignInReturned(void *pParam,bool bContin
 
 			// Check if user-created content is allowed, as we cannot play multiplayer if it's not
 			bool noUGC = false;
-#if defined(__PS3__) || defined(__PSVITA__)
+#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__PSVITA__)
 			ProfileManager.GetChatAndContentRestrictions(iPad,false,&noUGC,NULL,NULL);
 #elif defined(__ORBIS__)
 			ProfileManager.GetChatAndContentRestrictions(iPad,false,NULL,&noUGC,NULL);
@@ -1007,6 +1014,9 @@ int	CGameNetworkManager::ExitAndJoinFromInviteThreadProc( void* lpParam )
 // The pair of methods MustSignInReturned_0 & PSNSignInReturned_0 handle this
 int	CGameNetworkManager::MustSignInReturned_0(void *pParam,int iPad,C4JStorage::EMessageResult result)
 {
+#ifdef DISABLE_PSN
+	return 0;
+#else
 	if(result==C4JStorage::EMessage_ResultAccept) 
 	{
 #ifdef __PS3__
@@ -1025,10 +1035,14 @@ int	CGameNetworkManager::MustSignInReturned_0(void *pParam,int iPad,C4JStorage::
 	}
 
 	return 0;
+#endif
 }
 
 int CGameNetworkManager::PSNSignInReturned_0(void* pParam, bool bContinue, int iPad)
 {
+#ifdef DISABLE_PSN
+	return 0;
+#else
 	JoinFromInviteData *inviteData = (JoinFromInviteData *)pParam;
 
 	// If the invite data isn't set up yet (indicated by it being all zeroes, easiest detected via the net version), then try and get it again... this can happen if we got
@@ -1061,12 +1075,16 @@ int CGameNetworkManager::PSNSignInReturned_0(void* pParam, bool bContinue, int i
 	}
 
 	return 0;
+#endif
 }
 
 // This case happens when we were in the main menus when we got an invite, and weren't signed in... now can proceed with the normal flow of code for this situation
 // The pair of methods MustSignInReturned_1 & PSNSignInReturned_1 handle this
 int	CGameNetworkManager::MustSignInReturned_1(void *pParam,int iPad,C4JStorage::EMessageResult result)
 {
+#ifdef DISABLE_PSN
+	return 0;
+#else
 	if(result==C4JStorage::EMessage_ResultAccept) 
 	{
 #ifdef __PS3__
@@ -1078,10 +1096,14 @@ int	CGameNetworkManager::MustSignInReturned_1(void *pParam,int iPad,C4JStorage::
 #endif
 	}
 	return 0;
+#endif
 }
 
 int CGameNetworkManager::PSNSignInReturned_1(void* pParam, bool bContinue, int iPad)
 {
+#ifdef DISABLE_PSN
+	return 0;
+#else
 	INVITE_INFO *inviteInfo = (INVITE_INFO *)pParam;
 
 	// If the invite data isn't set up yet (indicated by it being all zeroes, easiest detected via the net version), then try and get it again... this can happen if we got
@@ -1109,6 +1131,7 @@ int CGameNetworkManager::PSNSignInReturned_1(void* pParam, bool bContinue, int i
 	}
 
 	return 0;
+#endif
 }
 #endif
 
@@ -1446,7 +1469,7 @@ void CGameNetworkManager::StateChange_AnyToEnding(bool bStateWasPlaying)
 			if(pNetworkPlayer != NULL && ProfileManager.IsSignedIn( i ) )
 			{
 				app.DebugPrintf("Stats save for an offline game for the player at index %d\n", i );
-				Minecraft::GetInstance()->forceStatsSave(pNetworkPlayer->GetUserIndex());
+				//Minecraft::GetInstance()->forceStatsSave(pNetworkPlayer->GetUserIndex());
 			}
 		}
 	}
@@ -1789,7 +1812,7 @@ void CGameNetworkManager::GameInviteReceived( int userIndex, const INVITE_INFO *
 #endif
 		if( !g_NetworkManager.IsInSession() )
 		{	
-#if defined (__PS3__) || defined (__PSVITA__)
+#if !defined(DISABLE_PSN) && defined (__PS3__) || defined (__PSVITA__)
 			// PS3 is more complicated here - we need to make sure that the player is online. If they are then we can do the same as the xbox, if not we need to try and get them online and then, if they do sign in, go down the same path
 			
 			// Determine why they're not "signed in live"
@@ -1939,7 +1962,7 @@ void CGameNetworkManager::HandleDisconnect(bool bLostRoomOnly)
 	if((g_NetworkManager.GetLockedProfile()!=-1) && iPrimaryPlayer!=-1 && g_NetworkManager.IsInSession() )
 	{
 		m_bLastDisconnectWasLostRoomOnly = bLostRoomOnly;
-#if defined __PS3__ || defined __PSVITA__ || defined __ORBIS__
+#if !defined(DISABLE_PSN) && defined __PS3__ || defined __PSVITA__ || defined __ORBIS__
 		m_bSignedOutofPSN=bPSNSignout;
 #endif
 		app.SetAction(iPrimaryPlayer,eAppAction_EthernetDisconnected);

Minecraft.Client/Common/Network/GameNetworkManager.h

@@ -6,7 +6,7 @@ using namespace std;
 #include "NetworkPlayerInterface.h"
 #ifdef _XBOX
 #include "..\..\Xbox\Network\PlatformNetworkManagerXbox.h"
-#elif defined __PS3__ || defined __ORBIS__ || defined __PSVITA__
+#elif !defined DISABLE_PSN && defined __PS3__ || defined __ORBIS__ || defined __PSVITA__
 #include "..\..\Common\Network\Sony\PlatformNetworkManagerSony.h"
 #elif defined _DURANGO
 #include "..\..\Durango\Network\PlatformNetworkManagerDurango.h"
@@ -32,7 +32,7 @@ class CGameNetworkManager
 {
 #ifdef _XBOX
 	friend class CPlatformNetworkManagerXbox;
-#elif defined __PS3__ || defined __ORBIS__ || defined __PSVITA__
+#elif !defined DISABLE_PSN && defined __PS3__ || defined __ORBIS__ || defined __PSVITA__
 	friend class CPlatformNetworkManagerSony;
 #elif defined _DURANGO
 	friend class CPlatformNetworkManagerDurango;

Minecraft.Client/Common/Network/PlatformNetworkManagerInterface.h

@@ -84,7 +84,7 @@ public:
 	virtual void HandleSignInChange() = 0;
 
 	virtual bool _RunNetworkGame() = 0;
-
+	virtual void SetGamePlayState() {}
 private:
 	virtual bool _LeaveGame(bool bMigrateHost, bool bLeaveRoom) = 0;
 	virtual void _HostGame(int usersMask, unsigned char publicSlots = MINECRAFT_NET_MAX_PLAYERS, unsigned char privateSlots = 0) = 0;

Minecraft.Client/Common/Network/PlatformNetworkManagerStub.cpp

@@ -3,6 +3,11 @@
 #include "..\..\..\Minecraft.World\StringHelpers.h"
 #include "PlatformNetworkManagerStub.h"
 #include "..\..\Xbox\Network\NetworkPlayerXbox.h"		// TODO - stub version of this?
+#include "..\..\Minecraft.h"
+#include "..\..\User.h"
+#if defined _WINDOWS64 || defined __PS3__
+#include "..\..\Common\Network\WinsockNetLayer.h"
+#endif
 
 CPlatformNetworkManagerStub *g_pPlatformNetworkManager;
 
@@ -114,10 +119,42 @@ 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 +211,35 @@ 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()
 {
+	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--;
+			}
+		}
+	}
 }
 
 int CPlatformNetworkManagerStub::GetPlayerCount()
@@ -231,6 +297,7 @@ bool CPlatformNetworkManagerStub::LeaveGame(bool bMigrateHost)
 	if( m_bLeavingGame ) return true;
 
 	m_bLeavingGame = true;
+	WinsockNetLayer::StopAdvertising();
 
 	// If we are the host wait for the game server to end
 	if(m_pIQNet->IsHost() && g_NetworkManager.ServerStoppedValid())
@@ -239,6 +306,20 @@ 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();
+
+	WinsockNetLayer::Shutdown();
+	WinsockNetLayer::Initialize();
+
 	return true;
 }
 
@@ -262,7 +343,20 @@ void CPlatformNetworkManagerStub::HostGame(int localUsersMask, bool bOnlineGame,
 
 	m_pIQNet->HostGame();
 
+	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;
+
 	_HostGame( localUsersMask, publicSlots, privateSlots );
+
+	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
 }
 
@@ -277,6 +371,47 @@ bool CPlatformNetworkManagerStub::_StartGame()
 
 int CPlatformNetworkManagerStub::JoinGame(FriendSessionInfo *searchResult, int localUsersMask, int primaryUserIndex)
 {
+	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(IQNet::m_player[0].m_gamertag, searchResult->data.hostName, 31);
+
+	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();
+	wcsncpy(IQNet::m_player[localSmallId].m_gamertag, pMinecraft->user->name.c_str(), 32);
+	IQNet::s_playerCount = localSmallId + 1;
+
+	NotifyPlayerJoined(&IQNet::m_player[0]);
+	NotifyPlayerJoined(&IQNet::m_player[localSmallId]);
+
+	m_pGameNetworkManager->StateChange_AnyToStarting();
+
 	return CGameNetworkManager::JOINGAME_SUCCESS;
 }
 
@@ -315,6 +450,21 @@ void CPlatformNetworkManagerStub::HandleSignInChange()
 
 bool CPlatformNetworkManagerStub::_RunNetworkGame()
 {
+	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());
+			}
+		}
+	}
+
 	return true;
 }
 
@@ -503,10 +653,90 @@ wstring CPlatformNetworkManagerStub::GatherRTTStats()
 
 void CPlatformNetworkManagerStub::TickSearch()
 {
+	if (m_SessionsUpdatedCallback == NULL)
+		return;
+
+	static DWORD lastSearchTime = 0;
+	DWORD now = GetTickCount();
+	if (now - lastSearchTime < 2000)
+		return;
+	lastSearchTime = now;
+
+	SearchForGames();
 }
 
 void CPlatformNetworkManagerStub::SearchForGames()
 {
+	std::vector<Win64LANSession> lanSessions = WinsockNetLayer::GetDiscoveredSessions();
+
+	if (g_Win64MultiplayerJoin)
+	{
+		bool alreadyPresent = false;
+		for (size_t i = 0; i < lanSessions.size(); i++)
+		{
+			if (strcmp(lanSessions[i].hostIP, g_Win64MultiplayerIP) == 0 &&
+				lanSessions[i].hostPort == g_Win64MultiplayerPort)
+			{
+				alreadyPresent = true;
+				break;
+			}
+		}
+		if (!alreadyPresent)
+		{
+			Win64LANSession manual;
+			memset(&manual, 0, sizeof(manual));
+			strncpy(manual.hostIP, g_Win64MultiplayerIP, sizeof(manual.hostIP) - 1);
+			manual.hostIP[sizeof(manual.hostIP) - 1] = '\0';
+
+			manual.hostPort = g_Win64MultiplayerPort;
+
+			swprintf(manual.hostName, 32, L"%hs:%d", g_Win64MultiplayerIP, g_Win64MultiplayerPort);
+			manual.hostName[31] = L'\0';
+			manual.playerCount = 0;
+			manual.maxPlayers = MINECRAFT_NET_MAX_PLAYERS;
+			manual.isJoinable = true;
+			manual.lastSeenTick = GetTickCount();
+			lanSessions.push_back(manual);
+		}
+	}
+
+	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];
+		wcsncpy(info->displayLabel, lanSessions[i].hostName, nameLen);
+		info->displayLabel[nameLen] = L'\0';
+		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(info->data.hostIP, lanSessions[i].hostIP, sizeof(info->data.hostIP) - 1);
+		info->data.hostIP[sizeof(info->data.hostIP) - 1] = '\0';
+		info->data.hostPort = lanSessions[i].hostPort;
+		wcsncpy(info->data.hostName, lanSessions[i].hostName, XUSER_NAME_SIZE - 1);
+		info->data.hostName[XUSER_NAME_SIZE - 1] = L'\0';
+		info->data.playerCount = lanSessions[i].playerCount;
+		info->data.maxPlayers = lanSessions[i].maxPlayers;
+
+		info->sessionId = (ULONGLONG)((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);
 }
 
 int CPlatformNetworkManagerStub::SearchForGamesThreadProc( void* lpParameter )
@@ -522,7 +752,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

@@ -23,7 +23,11 @@ public:
 	virtual bool RemoveLocalPlayerByUserIndex( int userIndex );
 	virtual INetworkPlayer *GetLocalPlayerByUserIndex( int userIndex );
 	virtual INetworkPlayer *GetPlayerByIndex(int playerIndex);
+#ifdef __PS3
+	virtual INetworkPlayer * GetPlayerByXuid(PlayerUID* xuid)
+#else
 	virtual INetworkPlayer * GetPlayerByXuid(PlayerUID xuid);
+#endif
 	virtual INetworkPlayer * GetPlayerBySmallId(unsigned char smallId);
 	virtual bool ShouldMessageForFullSession();
 
@@ -161,8 +165,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

@@ -32,7 +32,7 @@ typedef struct _GameSessionData
 		subTexturePackId = 0;
 	}
 } GameSessionData;
-#elif defined __PS3__ || defined __ORBIS__ || defined(__PSVITA__)
+#elif (defined __PS3__ && !defined DISABLE_PSN) || defined __ORBIS__ || defined(__PSVITA__)
 typedef struct _GameSessionData
 {
 	unsigned short netVersion;										//   2 bytes
@@ -47,6 +47,11 @@ typedef struct _GameSessionData
 	unsigned char playerCount;										//   1 byte
 	bool isReadyToJoin;												//   1 byte
 
+	char hostIP[64];												//	 64 bytes
+	int hostPort;													//	 4 bytes
+	wchar_t hostName[XUSER_NAME_SIZE];								//	 64 bytes ( 32*2 )
+	unsigned char maxPlayers;										//	 1 byte
+
 	_GameSessionData()
 	{
 		netVersion = 0;
@@ -57,7 +62,11 @@ typedef struct _GameSessionData
 		subTexturePackId = 0;
 		playerCount = 0;
 		isReadyToJoin = false;
-
+		memset(hostIP, 0, sizeof(hostIP));
+		hostPort = 0;
+		memset(hostName, 0, sizeof(hostName));
+		playerCount = 0;
+		maxPlayers = MINECRAFT_NET_MAX_PLAYERS;
 	}
 } GameSessionData;
 #else
@@ -69,6 +78,13 @@ typedef struct _GameSessionData
 	unsigned char subTexturePackId;									//   1 byte
 
 	bool isReadyToJoin;												//   1 byte
+	bool isJoinable;												//	 1 byte
+
+	char hostIP[64];												//	 64 bytes
+	int hostPort;													//	 4 bytes
+	wchar_t hostName[XUSER_NAME_SIZE];								//	 64 bytes ( 32*2 )
+	unsigned char playerCount;										//	 1 byte
+	unsigned char maxPlayers;										//	 1 byte
 
 	_GameSessionData()
 	{
@@ -76,6 +92,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
@@ -86,7 +109,7 @@ public:
 	SessionID sessionId;
 #ifdef _XBOX
 	XSESSION_SEARCHRESULT searchResult;
-#elif defined(__PS3__) || defined(__ORBIS__) || defined (__PSVITA__)
+#elif (defined __PS3__ && !defined DISABLE_PSN) || defined(__ORBIS__) || defined (__PSVITA__)
 	SQRNetworkManager::SessionSearchResult searchResult;
 #elif defined(_DURANGO)
 	DQRNetworkManager::SessionSearchResult searchResult;

Minecraft.Client/Common/Network/Sony/NetworkPlayerSony.cpp

@@ -1,5 +1,6 @@
 #include "stdafx.h"
 #include "NetworkPlayerSony.h"
+#ifndef DISABLE_PSN
 
 NetworkPlayerSony::NetworkPlayerSony(SQRNetworkPlayer *qnetPlayer)
 {
@@ -135,3 +136,4 @@ int NetworkPlayerSony::GetTimeSinceLastChunkPacket_ms()
 	__int64 currentTime = System::currentTimeMillis();
 	return (int)( currentTime - m_lastChunkPacketTime );
 }
+#endif

Minecraft.Client/Common/Network/Sony/NetworkPlayerSony.h

@@ -1,5 +1,5 @@
 #pragma once
-
+#ifndef _DISABLE_PSN
 #include "..\..\Common\Network\NetworkPlayerInterface.h"
 #include "SQRNetworkPlayer.h"
 
@@ -41,3 +41,4 @@ private:
 	Socket *m_pSocket;
 	__int64 m_lastChunkPacketTime;
 };
+#endif

Minecraft.Client/Common/Network/Sony/SQRNetworkManager.cpp

@@ -1,5 +1,5 @@
 #include "stdafx.h"
-
+#ifndef DISABLE_PSN
 #include "SQRNetworkManager.h"
 
 bool SQRNetworkManager::s_safeToRespondToGameBootInvite = false;
@@ -80,4 +80,5 @@ void SQRNetworkManager::TickWriteAcks()
 		}
 	}
 	LeaveCriticalSection(&m_csAckQueue);
-}
+}
+#endif

Minecraft.Client/Common/Network/Sony/SQRNetworkPlayer.cpp

@@ -1,4 +1,5 @@
 #include "stdafx.h"
+#ifndef DISABLE_PSN
 #include "SQRNetworkPlayer.h"
 
 #ifdef __PS3__
@@ -609,3 +610,4 @@ bool SQRNetworkPlayer::IsMutedByLocalUser(int userIndex)
 	return SonyVoiceChat::isMutedPlayer(pMan->m_roomSyncData.players[userIndex].m_roomMemberId);
 #endif
 }
+#endif

Minecraft.Client/Common/Network/WinsockNetLayer.h

@@ -0,0 +1,162 @@
+#pragma once
+
+#if defined _WINDOWS64
+#include <WinSock2.h>
+#include <WS2tcpip.h>
+#elif defined __PS3__
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netex/net.h>
+#include <netex/errno.h>
+#include <netinet/tcp.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#endif
+
+#include <vector>
+#include "..\..\Common\Network\NetworkPlayerInterface.h"
+
+#ifdef _WINDOWS64
+#pragma comment(lib, "Ws2_32.lib")
+#endif
+
+#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
+
+#ifdef __PS3__
+typedef int SOCKET;
+#define INVALID_SOCKET -1
+#endif
+
+class Socket;
+
+#pragma pack(push, 1)
+struct Win64LANBroadcast
+{
+	DWORD magic;
+	WORD netVersion;
+	WORD gamePort;
+	char 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;
+	C4JThread* 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 vector<Win64LANSession> GetDiscoveredSessions();
+
+	static int GetHostPort() { return s_hostGamePort; }
+
+private:
+	static int AcceptThreadProc(void* param);
+	static int RecvThreadProc(void* param);
+	static int ClientRecvThreadProc(void* param);
+	static int AdvertiseThreadProc(void* param);
+	static int DiscoveryThreadProc(void* param);
+
+	static SOCKET s_listenSocket;
+	static SOCKET s_hostConnectionSocket;
+	static C4JThread* s_acceptThread;
+	static C4JThread* 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 C4JThread* 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 C4JThread* 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];