Update username logic and implement latest LCEMP changes (#311)

* Update username logic and implement latest LCEMP changes

* Update old reference

* Fix tutorial world crash

* Restore deleted comment

8 files changed, 287 insertions, 147 deletions

diff --git a/Minecraft.Client/ClientConnection.cpp b/Minecraft.Client/ClientConnection.cpp
index f3510d33..8123a2f0 100644
--- a/Minecraft.Client/ClientConnection.cpp
+++ b/Minecraft.Client/ClientConnection.cpp
@@ -55,6 +55,12 @@
 #endif
 #include "DLCTexturePack.h"
 
+#ifdef _WINDOWS64
+#include "Xbox\Network\NetworkPlayerXbox.h"
+#include "Common\Network\PlatformNetworkManagerStub.h"
+#endif
+
+
 #ifdef _DURANGO
 #include "..\Minecraft.World\DurangoStats.h"
 #include "..\Minecraft.World\GenericStats.h"
@@ -421,7 +427,6 @@ void ClientConnection::handleAddEntity(shared_ptr<AddEntityPacket> packet)
 	{
 	case AddEntityPacket::MINECART:
 		e = Minecart::createMinecart(level, x, y, z, packet->data);
-		break;
 	case AddEntityPacket::FISH_HOOK:
 		{
 			// 4J Stu - Brought forward from 1.4 to be able to drop XP from fishing
@@ -444,7 +449,7 @@ void ClientConnection::handleAddEntity(shared_ptr<AddEntityPacket> packet)
 				}
 			}
 			
-			if (owner->instanceof(eTYPE_PLAYER))
+			if (owner != NULL && owner->instanceof(eTYPE_PLAYER))
 			{
 				shared_ptr<Player> player = dynamic_pointer_cast<Player>(owner);
 				shared_ptr<FishingHook> hook = shared_ptr<FishingHook>( new FishingHook(level, x, y, z, player) );
@@ -793,7 +798,28 @@ void ClientConnection::handleAddPlayer(shared_ptr<AddPlayerPacket> packet)
 	if (networkPlayer != NULL) player->m_displayName = networkPlayer->GetDisplayName();
 #else
 	// On all other platforms display name is just gamertag so don't check with the network manager
-	player->m_displayName = player->name;
+	player->m_displayName = player->getName();
+#endif
+
+#ifdef _WINDOWS64
+	{
+		PlayerUID pktXuid = player->getXuid();
+		const PlayerUID WIN64_XUID_BASE = (PlayerUID)0xe000d45248242f2e;
+		if (pktXuid >= WIN64_XUID_BASE && pktXuid < WIN64_XUID_BASE + MINECRAFT_NET_MAX_PLAYERS)
+		{
+			BYTE smallId = (BYTE)(pktXuid - WIN64_XUID_BASE);
+			INetworkPlayer* np = g_NetworkManager.GetPlayerBySmallId(smallId);
+			if (np != NULL)
+			{
+				NetworkPlayerXbox* npx = (NetworkPlayerXbox*)np;
+				IQNetPlayer* qp = npx->GetQNetPlayer();
+				if (qp != NULL && qp->m_gamertag[0] == 0)
+				{
+					wcsncpy_s(qp->m_gamertag, 32, packet->name.c_str(), _TRUNCATE);
+				}
+			}
+		}
+	}
 #endif
 
 	//	printf("\t\t\t\t%d: Add player\n",packet->id,packet->yRot);
@@ -938,6 +964,39 @@ void ClientConnection::handleMoveEntitySmall(shared_ptr<MoveEntityPacketSmall> p
 
 void ClientConnection::handleRemoveEntity(shared_ptr<RemoveEntitiesPacket> packet)
 {
+#ifdef _WINDOWS64
+	if (!g_NetworkManager.IsHost())
+	{
+		for (int i = 0; i < packet->ids.length; i++)
+		{
+			shared_ptr<Entity> entity = getEntity(packet->ids[i]);
+			if (entity != NULL && entity->GetType() == eTYPE_PLAYER)
+			{
+				shared_ptr<Player> player = dynamic_pointer_cast<Player>(entity);
+				if (player != NULL)
+				{
+					PlayerUID xuid = player->getXuid();
+					INetworkPlayer* np = g_NetworkManager.GetPlayerByXuid(xuid);
+					if (np != NULL)
+					{
+						NetworkPlayerXbox* npx = (NetworkPlayerXbox*)np;
+						IQNetPlayer* qp = npx->GetQNetPlayer();
+						if (qp != NULL)
+						{
+							extern CPlatformNetworkManagerStub* g_pPlatformNetworkManager;
+							g_pPlatformNetworkManager->NotifyPlayerLeaving(qp);
+							qp->m_smallId = 0;
+							qp->m_isRemote = false;
+							qp->m_isHostPlayer = false;
+							qp->m_gamertag[0] = 0;
+							qp->SetCustomDataValue(0);
+						}
+					}
+				}
+			}
+		}
+	}
+#endif
 	for (int i = 0; i < packet->ids.length; i++)
 	{
 		level->removeEntity(packet->ids[i]);
diff --git a/Minecraft.Client/Extrax64Stubs.cpp b/Minecraft.Client/Extrax64Stubs.cpp
index 22ad578f..5a3c5279 100644
--- a/Minecraft.Client/Extrax64Stubs.cpp
+++ b/Minecraft.Client/Extrax64Stubs.cpp
@@ -199,11 +199,10 @@ DWORD IQNetPlayer::GetSendQueueSize(IQNetPlayer * player, DWORD dwFlags) { retur
 DWORD IQNetPlayer::GetCurrentRtt() { return 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 (PlayerUID)(0xe000d45248242f2e + m_smallId); } // todo: restore to INVALID_XUID once saves support this
-extern wstring g_playerName;
-LPCWSTR IQNetPlayer::GetGamertag() { return g_playerName.empty() ? L"Windows" : g_playerName.c_str(); }
-int IQNetPlayer::GetSessionIndex() { return 0; }
+LPCWSTR IQNetPlayer::GetGamertag() { return m_gamertag; }
+int IQNetPlayer::GetSessionIndex() { return m_smallId; }
 bool IQNetPlayer::IsTalking() { return false; }
 bool IQNetPlayer::IsMutedByLocalUser(DWORD dwUserIndex) { return false; }
 bool IQNetPlayer::HasVoice() { return false; }
@@ -232,13 +231,17 @@ void Win64_SetupRemoteQNetPlayer(IQNetPlayer * player, BYTE smallId, bool isHost
 		IQNet::s_playerCount = smallId + 1;
 }
 
+static bool Win64_IsActivePlayer(IQNetPlayer* p, DWORD index);
+
 HRESULT IQNet::AddLocalPlayerByUserIndex(DWORD dwUserIndex) { return S_OK; }
 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)
+		if (dwUserIndex < MINECRAFT_NET_MAX_PLAYERS &&
+			!m_player[dwUserIndex].m_isRemote &&
+			Win64_IsActivePlayer(&m_player[dwUserIndex], dwUserIndex))
 			return &m_player[dwUserIndex];
 		return NULL;
 	}
@@ -246,7 +249,7 @@ IQNetPlayer* IQNet::GetLocalPlayerByUserIndex(DWORD dwUserIndex)
 		return NULL;
 	for (DWORD i = 0; i < s_playerCount; i++)
 	{
-		if (!m_player[i].m_isRemote)
+		if (!m_player[i].m_isRemote && Win64_IsActivePlayer(&m_player[i], i))
 			return &m_player[i];
 	}
 	return NULL;
@@ -299,15 +302,28 @@ 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::ClientJoinGame()
+{
+	_iQNetStubState = QNET_STATE_SESSION_STARTING;
+	s_isHosting = false;
+
+	for (int i = 0; i < MINECRAFT_NET_MAX_PLAYERS; i++)
+	{
+		m_player[i].m_smallId = (BYTE)i;
+		m_player[i].m_isRemote = true;
+		m_player[i].m_isHostPlayer = false;
+		m_player[i].m_gamertag[0] = 0;
+		m_player[i].SetCustomDataValue(0);
+	}
+}
 void IQNet::EndGame()
 {
 	_iQNetStubState = QNET_STATE_IDLE;
 	s_isHosting = false;
 	s_playerCount = 1;
-	for (int i = 1; i < MINECRAFT_NET_MAX_PLAYERS; i++)
+	for (int i = 0; i < MINECRAFT_NET_MAX_PLAYERS; i++)
 	{
-		m_player[i].m_smallId = 0;
+		m_player[i].m_smallId = (BYTE)i;
 		m_player[i].m_isRemote = false;
 		m_player[i].m_isHostPlayer = false;
 		m_player[i].m_gamertag[0] = 0;
@@ -587,23 +603,9 @@ void				C_4JProfile::SetPrimaryPad(int iPad) {}
 #ifdef _DURANGO
 char fakeGamerTag[32] = "PlayerName";
 void				SetFakeGamertag(char* name) { strcpy_s(fakeGamerTag, name); }
-char* C_4JProfile::GetGamertag(int iPad) { return fakeGamerTag; }
 #else
-#include <windows.h>
-
-const char* C_4JProfile::GetGamertag(int iPad)
-{
-	static std::string narrowName;
-	const wchar_t* wideName = g_playerName.c_str();
-
-	int sizeNeeded = WideCharToMultiByte(CP_UTF8, 0, wideName, -1, nullptr, 0, nullptr, nullptr);
-
-	narrowName.resize(sizeNeeded);
-	WideCharToMultiByte(CP_UTF8, 0, wideName, -1, &narrowName[0], sizeNeeded, nullptr, nullptr);
-
-	return narrowName.c_str();
-}
-wstring				C_4JProfile::GetDisplayName(int iPad) { return g_playerName; }
+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; }
 #endif
 bool				C_4JProfile::IsFullVersion() { return s_bProfileIsFullVersion; }
 void				C_4JProfile::SetSignInChangeCallback(void (*Func)(LPVOID, bool, unsigned int), LPVOID lpParam) {}
diff --git a/Minecraft.Client/Windows64/4JLibs/inc/4J_Profile.h b/Minecraft.Client/Windows64/4JLibs/inc/4J_Profile.h
index f7718a83..f1bd85bb 100644
--- a/Minecraft.Client/Windows64/4JLibs/inc/4J_Profile.h
+++ b/Minecraft.Client/Windows64/4JLibs/inc/4J_Profile.h
@@ -75,7 +75,7 @@ public:
 	// SYS
 	int					GetPrimaryPad();
 	void				SetPrimaryPad(int iPad);
-	const char*			GetGamertag(int iPad);
+	char*				GetGamertag(int iPad);
 	wstring				GetDisplayName(int iPad);
 	bool				IsFullVersion();
 	void				SetSignInChangeCallback(void ( *Func)(LPVOID, bool, unsigned int),LPVOID lpParam);
diff --git a/Minecraft.Client/Windows64/Network/WinsockNetLayer.cpp b/Minecraft.Client/Windows64/Network/WinsockNetLayer.cpp
index 19fc2598..d3ea1c3a 100644
--- a/Minecraft.Client/Windows64/Network/WinsockNetLayer.cpp
+++ b/Minecraft.Client/Windows64/Network/WinsockNetLayer.cpp
@@ -1,3 +1,6 @@
+// Code implemented by LCEMP, credit if used on other repos
+// https://github.com/LCEMP/LCEMP
+
 #include "stdafx.h"
 
 #ifdef _WINDOWS64
@@ -151,7 +154,7 @@ bool WinsockNetLayer::HostGame(int port)
 	LeaveCriticalSection(&s_freeSmallIdLock);
 
 	struct addrinfo hints = {};
-	struct addrinfo *result = NULL;
+	struct addrinfo* result = NULL;
 
 	hints.ai_family = AF_INET;
 	hints.ai_socktype = SOCK_STREAM;
@@ -177,7 +180,7 @@ bool WinsockNetLayer::HostGame(int port)
 	}
 
 	int opt = 1;
-	setsockopt(s_listenSocket, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof(opt));
+	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);
@@ -207,15 +210,23 @@ bool WinsockNetLayer::HostGame(int port)
 	return true;
 }
 
-bool WinsockNetLayer::JoinGame(const char *ip, int port)
+bool WinsockNetLayer::JoinGame(const char* ip, int port)
 {
 	if (!s_initialized && !Initialize()) return false;
 
 	s_isHost = false;
 	s_hostSmallId = 0;
+	s_connected = false;
+	s_active = false;
+
+	if (s_hostConnectionSocket != INVALID_SOCKET)
+	{
+		closesocket(s_hostConnectionSocket);
+		s_hostConnectionSocket = INVALID_SOCKET;
+	}
 
 	struct addrinfo hints = {};
-	struct addrinfo *result = NULL;
+	struct addrinfo* result = NULL;
 
 	hints.ai_family = AF_INET;
 	hints.ai_socktype = SOCK_STREAM;
@@ -231,37 +242,55 @@ bool WinsockNetLayer::JoinGame(const char *ip, int port)
 		return false;
 	}
 
-	s_hostConnectionSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
-	if (s_hostConnectionSocket == INVALID_SOCKET)
+	bool connected = false;
+	BYTE assignedSmallId = 0;
+	const int maxAttempts = 12;
+
+	for (int attempt = 0; attempt < maxAttempts; ++attempt)
 	{
-		app.DebugPrintf("socket() failed: %d\n", WSAGetLastError());
-		freeaddrinfo(result);
-		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());
+			break;
+		}
 
-	int noDelay = 1;
-	setsockopt(s_hostConnectionSocket, IPPROTO_TCP, TCP_NODELAY, (const char *)&noDelay, sizeof(noDelay));
+		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;
+		iResult = connect(s_hostConnectionSocket, result->ai_addr, (int)result->ai_addrlen);
+		if (iResult == SOCKET_ERROR)
+		{
+			int err = WSAGetLastError();
+			app.DebugPrintf("connect() to %s:%d failed (attempt %d/%d): %d\n", ip, port, attempt + 1, maxAttempts, err);
+			closesocket(s_hostConnectionSocket);
+			s_hostConnectionSocket = INVALID_SOCKET;
+			Sleep(200);
+			continue;
+		}
+
+		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 (attempt %d/%d)\n", attempt + 1, maxAttempts);
+			closesocket(s_hostConnectionSocket);
+			s_hostConnectionSocket = INVALID_SOCKET;
+			Sleep(200);
+			continue;
+		}
+
+		assignedSmallId = assignBuf[0];
+		connected = true;
+		break;
 	}
+	freeaddrinfo(result);
 
-	BYTE assignBuf[1];
-	int bytesRecv = recv(s_hostConnectionSocket, (char *)assignBuf, 1, 0);
-	if (bytesRecv != 1)
+	if (!connected)
 	{
-		app.DebugPrintf("Failed to receive small ID assignment from host\n");
-		closesocket(s_hostConnectionSocket);
-		s_hostConnectionSocket = INVALID_SOCKET;
 		return false;
 	}
-	s_localSmallId = assignBuf[0];
+	s_localSmallId = assignedSmallId;
 
 	app.DebugPrintf("Win64 LAN: Connected to %s:%d, assigned smallId=%d\n", ip, port, s_localSmallId);
 
@@ -273,7 +302,7 @@ bool WinsockNetLayer::JoinGame(const char *ip, int port)
 	return true;
 }
 
-bool WinsockNetLayer::SendOnSocket(SOCKET sock, const void *data, int dataSize)
+bool WinsockNetLayer::SendOnSocket(SOCKET sock, const void* data, int dataSize)
 {
 	if (sock == INVALID_SOCKET || dataSize <= 0) return false;
 
@@ -289,7 +318,7 @@ bool WinsockNetLayer::SendOnSocket(SOCKET sock, const void *data, int dataSize)
 	int toSend = 4;
 	while (totalSent < toSend)
 	{
-		int sent = send(sock, (const char *)header + totalSent, toSend - totalSent, 0);
+		int sent = send(sock, (const char*)header + totalSent, toSend - totalSent, 0);
 		if (sent == SOCKET_ERROR || sent == 0)
 		{
 			LeaveCriticalSection(&s_sendLock);
@@ -301,7 +330,7 @@ bool WinsockNetLayer::SendOnSocket(SOCKET sock, const void *data, int dataSize)
 	totalSent = 0;
 	while (totalSent < dataSize)
 	{
-		int sent = send(sock, (const char *)data + totalSent, dataSize - totalSent, 0);
+		int sent = send(sock, (const char*)data + totalSent, dataSize - totalSent, 0);
 		if (sent == SOCKET_ERROR || sent == 0)
 		{
 			LeaveCriticalSection(&s_sendLock);
@@ -314,7 +343,7 @@ bool WinsockNetLayer::SendOnSocket(SOCKET sock, const void *data, int dataSize)
 	return true;
 }
 
-bool WinsockNetLayer::SendToSmallId(BYTE targetSmallId, const void *data, int dataSize)
+bool WinsockNetLayer::SendToSmallId(BYTE targetSmallId, const void* data, int dataSize)
 {
 	if (!s_active) return false;
 
@@ -346,34 +375,34 @@ SOCKET WinsockNetLayer::GetSocketForSmallId(BYTE smallId)
 	return INVALID_SOCKET;
 }
 
-static bool RecvExact(SOCKET sock, BYTE *buf, int len)
+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);
+		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)
+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);
+	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();
+		::Socket* pSocket = pPlayerFrom->GetSocket();
 		if (pSocket != NULL)
 			pSocket->pushDataToQueue(data, dataSize, false);
 	}
 	else
 	{
-		::Socket *pSocket = pPlayerTo->GetSocket();
+		::Socket* pSocket = pPlayerTo->GetSocket();
 		if (pSocket != NULL)
 			pSocket->pushDataToQueue(data, dataSize, true);
 	}
@@ -392,7 +421,7 @@ DWORD WINAPI WinsockNetLayer::AcceptThreadProc(LPVOID param)
 		}
 
 		int noDelay = 1;
-		setsockopt(clientSocket, IPPROTO_TCP, TCP_NODELAY, (const char *)&noDelay, sizeof(noDelay));
+		setsockopt(clientSocket, IPPROTO_TCP, TCP_NODELAY, (const char*)&noDelay, sizeof(noDelay));
 
 		extern QNET_STATE _iQNetStubState;
 		if (_iQNetStubState != QNET_STATE_GAME_PLAY)
@@ -423,7 +452,7 @@ DWORD WINAPI WinsockNetLayer::AcceptThreadProc(LPVOID param)
 		LeaveCriticalSection(&s_freeSmallIdLock);
 
 		BYTE assignBuf[1] = { assignedSmallId };
-		int sent = send(clientSocket, (const char *)assignBuf, 1, 0);
+		int sent = send(clientSocket, (const char*)assignBuf, 1, 0);
 		if (sent != 1)
 		{
 			app.DebugPrintf("Failed to send small ID to client\n");
@@ -444,15 +473,15 @@ DWORD WINAPI WinsockNetLayer::AcceptThreadProc(LPVOID param)
 
 		app.DebugPrintf("Win64 LAN: Client connected, assigned smallId=%d\n", assignedSmallId);
 
-		IQNetPlayer *qnetPlayer = &IQNet::m_player[assignedSmallId];
+		IQNetPlayer* qnetPlayer = &IQNet::m_player[assignedSmallId];
 
-		extern void Win64_SetupRemoteQNetPlayer(IQNetPlayer *player, BYTE smallId, bool isHost, bool isLocal);
+		extern void Win64_SetupRemoteQNetPlayer(IQNetPlayer * player, BYTE smallId, bool isHost, bool isLocal);
 		Win64_SetupRemoteQNetPlayer(qnetPlayer, assignedSmallId, false, false);
 
-		extern CPlatformNetworkManagerStub *g_pPlatformNetworkManager;
+		extern CPlatformNetworkManagerStub* g_pPlatformNetworkManager;
 		g_pPlatformNetworkManager->NotifyPlayerJoined(qnetPlayer);
 
-		DWORD *threadParam = new DWORD;
+		DWORD* threadParam = new DWORD;
 		*threadParam = connIdx;
 		HANDLE hThread = CreateThread(NULL, 0, RecvThreadProc, threadParam, 0, NULL);
 
@@ -466,8 +495,8 @@ DWORD WINAPI WinsockNetLayer::AcceptThreadProc(LPVOID param)
 
 DWORD WINAPI WinsockNetLayer::RecvThreadProc(LPVOID param)
 {
-	DWORD connIdx = *(DWORD *)param;
-	delete (DWORD *)param;
+	DWORD connIdx = *(DWORD*)param;
+	delete (DWORD*)param;
 
 	EnterCriticalSection(&s_connectionsLock);
 	if (connIdx >= (DWORD)s_connections.size())
@@ -479,7 +508,8 @@ DWORD WINAPI WinsockNetLayer::RecvThreadProc(LPVOID param)
 	BYTE clientSmallId = s_connections[connIdx].smallId;
 	LeaveCriticalSection(&s_connectionsLock);
 
-	BYTE *recvBuf = new BYTE[WIN64_NET_RECV_BUFFER_SIZE];
+	std::vector<BYTE> recvBuf;
+	recvBuf.resize(WIN64_NET_RECV_BUFFER_SIZE);
 
 	while (s_active)
 	{
@@ -490,33 +520,47 @@ DWORD WINAPI WinsockNetLayer::RecvThreadProc(LPVOID param)
 			break;
 		}
 
-		int packetSize = (header[0] << 24) | (header[1] << 16) | (header[2] << 8) | header[3];
+		int packetSize =
+			((uint32_t)header[0] << 24) |
+			((uint32_t)header[1] << 16) |
+			((uint32_t)header[2] << 8) |
+			((uint32_t)header[3]);
 
-		if (packetSize <= 0 || packetSize > WIN64_NET_RECV_BUFFER_SIZE)
+		if (packetSize <= 0 || packetSize > WIN64_NET_MAX_PACKET_SIZE)
 		{
-			app.DebugPrintf("Win64 LAN: Invalid packet size %d from client smallId=%d\n", packetSize, clientSmallId);
+			app.DebugPrintf("Win64 LAN: Invalid packet size %d from client smallId=%d (max=%d)\n",
+				packetSize,
+				clientSmallId,
+				(int)WIN64_NET_MAX_PACKET_SIZE);
 			break;
 		}
 
-		if (!RecvExact(sock, recvBuf, packetSize))
+		if ((int)recvBuf.size() < packetSize)
+		{
+			recvBuf.resize(packetSize);
+			app.DebugPrintf("Win64 LAN: Resized host recv buffer to %d bytes for client smallId=%d\n", packetSize, clientSmallId);
+		}
+
+		if (!RecvExact(sock, &recvBuf[0], packetSize))
 		{
 			app.DebugPrintf("Win64 LAN: Client smallId=%d disconnected (body)\n", clientSmallId);
 			break;
 		}
 
-		HandleDataReceived(clientSmallId, s_hostSmallId, recvBuf, packetSize);
+		HandleDataReceived(clientSmallId, s_hostSmallId, &recvBuf[0], 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;
+			if (s_connections[i].tcpSocket != INVALID_SOCKET)
+			{
+				closesocket(s_connections[i].tcpSocket);
+				s_connections[i].tcpSocket = INVALID_SOCKET;
+			}
 			break;
 		}
 	}
@@ -529,7 +573,7 @@ DWORD WINAPI WinsockNetLayer::RecvThreadProc(LPVOID param)
 	return 0;
 }
 
-bool WinsockNetLayer::PopDisconnectedSmallId(BYTE *outSmallId)
+bool WinsockNetLayer::PopDisconnectedSmallId(BYTE* outSmallId)
 {
 	bool found = false;
 	EnterCriticalSection(&s_disconnectLock);
@@ -550,9 +594,26 @@ void WinsockNetLayer::PushFreeSmallId(BYTE smallId)
 	LeaveCriticalSection(&s_freeSmallIdLock);
 }
 
+void WinsockNetLayer::CloseConnectionBySmallId(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 && s_connections[i].tcpSocket != INVALID_SOCKET)
+		{
+			closesocket(s_connections[i].tcpSocket);
+			s_connections[i].tcpSocket = INVALID_SOCKET;
+			app.DebugPrintf("Win64 LAN: Force-closed TCP connection for smallId=%d\n", smallId);
+			break;
+		}
+	}
+	LeaveCriticalSection(&s_connectionsLock);
+}
+
 DWORD WINAPI WinsockNetLayer::ClientRecvThreadProc(LPVOID param)
 {
-	BYTE *recvBuf = new BYTE[WIN64_NET_RECV_BUFFER_SIZE];
+	std::vector<BYTE> recvBuf;
+	recvBuf.resize(WIN64_NET_RECV_BUFFER_SIZE);
 
 	while (s_active && s_hostConnectionSocket != INVALID_SOCKET)
 	{
@@ -565,28 +626,34 @@ DWORD WINAPI WinsockNetLayer::ClientRecvThreadProc(LPVOID param)
 
 		int packetSize = (header[0] << 24) | (header[1] << 16) | (header[2] << 8) | header[3];
 
-		if (packetSize <= 0 || packetSize > WIN64_NET_RECV_BUFFER_SIZE)
+		if (packetSize <= 0 || packetSize > WIN64_NET_MAX_PACKET_SIZE)
 		{
-			app.DebugPrintf("Win64 LAN: Invalid packet size %d from host\n", packetSize);
+			app.DebugPrintf("Win64 LAN: Invalid packet size %d from host (max=%d)\n",
+				packetSize,
+				(int)WIN64_NET_MAX_PACKET_SIZE);
 			break;
 		}
 
-		if (!RecvExact(s_hostConnectionSocket, recvBuf, packetSize))
+		if ((int)recvBuf.size() < packetSize)
+		{
+			recvBuf.resize(packetSize);
+			app.DebugPrintf("Win64 LAN: Resized client recv buffer to %d bytes\n", packetSize);
+		}
+
+		if (!RecvExact(s_hostConnectionSocket, &recvBuf[0], packetSize))
 		{
 			app.DebugPrintf("Win64 LAN: Disconnected from host (body)\n");
 			break;
 		}
 
-		HandleDataReceived(s_hostSmallId, s_localSmallId, recvBuf, packetSize);
+		HandleDataReceived(s_hostSmallId, s_localSmallId, &recvBuf[0], 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)
+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;
@@ -614,7 +681,7 @@ bool WinsockNetLayer::StartAdvertising(int gamePort, const wchar_t *hostName, un
 	}
 
 	BOOL broadcast = TRUE;
-	setsockopt(s_advertiseSock, SOL_SOCKET, SO_BROADCAST, (const char *)&broadcast, sizeof(broadcast));
+	setsockopt(s_advertiseSock, SOL_SOCKET, SO_BROADCAST, (const char*)&broadcast, sizeof(broadcast));
 
 	s_advertising = true;
 	s_advertiseThread = CreateThread(NULL, 0, AdvertiseThreadProc, NULL, 0, NULL);
@@ -669,8 +736,8 @@ DWORD WINAPI WinsockNetLayer::AdvertiseThreadProc(LPVOID param)
 		Win64LANBroadcast data = s_advertiseData;
 		LeaveCriticalSection(&s_advertiseLock);
 
-		int sent = sendto(s_advertiseSock, (const char *)&data, sizeof(data), 0,
-			(struct sockaddr *)&broadcastAddr, sizeof(broadcastAddr));
+		int sent = sendto(s_advertiseSock, (const char*)&data, sizeof(data), 0,
+			(struct sockaddr*)&broadcastAddr, sizeof(broadcastAddr));
 
 		if (sent == SOCKET_ERROR && s_advertising)
 		{
@@ -696,7 +763,7 @@ bool WinsockNetLayer::StartDiscovery()
 	}
 
 	BOOL reuseAddr = TRUE;
-	setsockopt(s_discoverySock, SOL_SOCKET, SO_REUSEADDR, (const char *)&reuseAddr, sizeof(reuseAddr));
+	setsockopt(s_discoverySock, SOL_SOCKET, SO_REUSEADDR, (const char*)&reuseAddr, sizeof(reuseAddr));
 
 	struct sockaddr_in bindAddr;
 	memset(&bindAddr, 0, sizeof(bindAddr));
@@ -704,7 +771,7 @@ bool WinsockNetLayer::StartDiscovery()
 	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)
+	if (::bind(s_discoverySock, (struct sockaddr*)&bindAddr, sizeof(bindAddr)) == SOCKET_ERROR)
 	{
 		app.DebugPrintf("Win64 LAN: Discovery bind failed: %d\n", WSAGetLastError());
 		closesocket(s_discoverySock);
@@ -713,7 +780,7 @@ bool WinsockNetLayer::StartDiscovery()
 	}
 
 	DWORD timeout = 500;
-	setsockopt(s_discoverySock, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(timeout));
+	setsockopt(s_discoverySock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof(timeout));
 
 	s_discovering = true;
 	s_discoveryThread = CreateThread(NULL, 0, DiscoveryThreadProc, NULL, 0, NULL);
@@ -763,7 +830,7 @@ DWORD WINAPI WinsockNetLayer::DiscoveryThreadProc(LPVOID param)
 		int senderLen = sizeof(senderAddr);
 
 		int recvLen = recvfrom(s_discoverySock, recvBuf, sizeof(recvBuf), 0,
-			(struct sockaddr *)&senderAddr, &senderLen);
+			(struct sockaddr*)&senderAddr, &senderLen);
 
 		if (recvLen == SOCKET_ERROR)
 		{
@@ -773,7 +840,7 @@ DWORD WINAPI WinsockNetLayer::DiscoveryThreadProc(LPVOID param)
 		if (recvLen < (int)sizeof(Win64LANBroadcast))
 			continue;
 
-		Win64LANBroadcast *broadcast = (Win64LANBroadcast *)recvBuf;
+		Win64LANBroadcast* broadcast = (Win64LANBroadcast*)recvBuf;
 		if (broadcast->magic != WIN64_LAN_BROADCAST_MAGIC)
 			continue;
 
@@ -841,4 +908,4 @@ DWORD WINAPI WinsockNetLayer::DiscoveryThreadProc(LPVOID param)
 	return 0;
 }
 
-#endif
+#endif
\ No newline at end of file
diff --git a/Minecraft.Client/Windows64/Network/WinsockNetLayer.h b/Minecraft.Client/Windows64/Network/WinsockNetLayer.h
index 96b03c9b..029dd0a7 100644
--- a/Minecraft.Client/Windows64/Network/WinsockNetLayer.h
+++ b/Minecraft.Client/Windows64/Network/WinsockNetLayer.h
@@ -1,3 +1,5 @@
+// Code implemented by LCEMP, credit if used on other repos
+// https://github.com/LCEMP/LCEMP
 #pragma once
 
 #ifdef _WINDOWS64
@@ -12,6 +14,7 @@
 #define WIN64_NET_DEFAULT_PORT 25565
 #define WIN64_NET_MAX_CLIENTS 7
 #define WIN64_NET_RECV_BUFFER_SIZE 65536
+#define WIN64_NET_MAX_PACKET_SIZE (4 * 1024 * 1024)
 #define WIN64_LAN_DISCOVERY_PORT 25566
 #define WIN64_LAN_BROADCAST_MAGIC 0x4D434C4E
 
@@ -63,10 +66,10 @@ public:
 	static void Shutdown();
 
 	static bool HostGame(int port);
-	static bool JoinGame(const char *ip, 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 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; }
@@ -77,12 +80,13 @@ public:
 
 	static SOCKET GetSocketForSmallId(BYTE smallId);
 
-	static void HandleDataReceived(BYTE fromSmallId, BYTE toSmallId, unsigned char *data, unsigned int dataSize);
+	static void HandleDataReceived(BYTE fromSmallId, BYTE toSmallId, unsigned char* data, unsigned int dataSize);
 
-	static bool PopDisconnectedSmallId(BYTE *outSmallId);
+	static bool PopDisconnectedSmallId(BYTE* outSmallId);
 	static void PushFreeSmallId(BYTE smallId);
+	static void CloseConnectionBySmallId(BYTE smallId);
 
-	static bool StartAdvertising(int gamePort, const wchar_t *hostName, unsigned int gameSettings, unsigned int texPackId, unsigned char subTexId, unsigned short netVer);
+	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);
diff --git a/Minecraft.Client/Windows64/Windows64_App.cpp b/Minecraft.Client/Windows64/Windows64_App.cpp
index 461e8c34..ad9e1f24 100644
--- a/Minecraft.Client/Windows64/Windows64_App.cpp
+++ b/Minecraft.Client/Windows64/Windows64_App.cpp
@@ -10,46 +10,11 @@
 #include "..\..\Minecraft.World\BiomeSource.h"
 #include "..\..\Minecraft.World\LevelType.h"
 
-wstring g_playerName;
-
 CConsoleMinecraftApp app;
 
-static void LoadPlayerName()
-{
-	if (!g_playerName.empty()) return;
-	g_playerName = L"Windows";
-
-	char exePath[MAX_PATH] = {};
-	GetModuleFileNameA(NULL, exePath, MAX_PATH);
-	char *lastSlash = strrchr(exePath, '\\');
-	if (lastSlash) *(lastSlash + 1) = '\0';
-	char filePath[MAX_PATH] = {};
-	_snprintf_s(filePath, sizeof(filePath), _TRUNCATE, "%susername.txt", exePath);
-
-	FILE *f = NULL;
-	if (fopen_s(&f, filePath, "r") == 0 && f)
-	{
-		char buf[128] = {};
-		if (fgets(buf, sizeof(buf), f))
-		{
-			int len = (int)strlen(buf);
-			while (len > 0 && (buf[len-1] == '\n' || buf[len-1] == '\r' || buf[len-1] == ' '))
-				buf[--len] = '\0';
-			if (len > 0)
-			{
-				wchar_t wbuf[128] = {};
-				mbstowcs(wbuf, buf, 127);
-				g_playerName = wbuf;
-			}
-		}
-		fclose(f);
-	}
-}
-
 CConsoleMinecraftApp::CConsoleMinecraftApp() : CMinecraftApp()
 {
 	m_bShutdown = false;
-	LoadPlayerName();
 }
 
 void CConsoleMinecraftApp::SetRichPresenceContext(int iPad, int contextId)
@@ -110,8 +75,8 @@ void CConsoleMinecraftApp::TemporaryCreateGameStart()
 	Minecraft *pMinecraft=Minecraft::GetInstance();
 	app.ReleaseSaveThumbnail();
 	ProfileManager.SetLockedProfile(0);
-	LoadPlayerName();
-	pMinecraft->user->name = g_playerName;
+	extern wchar_t g_Win64UsernameW[17];
+	pMinecraft->user->name = g_Win64UsernameW;
 	app.ApplyGameSettingsChanged(0);
 
 	////////////////////////////////////////////////////////////////////////////////////////////// From CScene_MultiGameJoinLoad::OnInit
diff --git a/Minecraft.Client/Windows64/Windows64_App.h b/Minecraft.Client/Windows64/Windows64_App.h
index 32d204ad..bff916ec 100644
--- a/Minecraft.Client/Windows64/Windows64_App.h
+++ b/Minecraft.Client/Windows64/Windows64_App.h
@@ -33,7 +33,6 @@ public:
 	virtual void TemporaryCreateGameStart();
 
 	bool m_bShutdown;
-	wstring g_playerName;
 };
 
 extern CConsoleMinecraftApp app;
diff --git a/Minecraft.Client/Windows64/Windows64_Minecraft.cpp b/Minecraft.Client/Windows64/Windows64_Minecraft.cpp
index 78ab76fe..4a3d835c 100644
--- a/Minecraft.Client/Windows64/Windows64_Minecraft.cpp
+++ b/Minecraft.Client/Windows64/Windows64_Minecraft.cpp
@@ -88,6 +88,9 @@ int g_iScreenHeight = 1080;
 UINT g_ScreenWidth = 1920;
 UINT g_ScreenHeight = 1080;
 
+char g_Win64Username[17] = { 0 };
+wchar_t g_Win64UsernameW[17] = { 0 };
+
 // Fullscreen toggle state
 static bool g_isFullscreen = false;
 static WINDOWPLACEMENT g_wpPrev = { sizeof(g_wpPrev) };
@@ -762,8 +765,47 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 			//g_iScreenWidth = 960;
 			//g_iScreenHeight = 544;
 		}
+
+		// Default username will be "Windows"
+		strncpy_s(g_Win64Username, sizeof(g_Win64Username), "Windows", _TRUNCATE);
+
+		char exePath[MAX_PATH] = {};
+		GetModuleFileNameA(NULL, exePath, MAX_PATH);
+		char* lastSlash = strrchr(exePath, '\\');
+		if (lastSlash) *(lastSlash + 1) = '\0';
+
+		char filePath[MAX_PATH] = {};
+		_snprintf_s(filePath, sizeof(filePath), _TRUNCATE, "%susername.txt", exePath);
+
+		FILE* f = nullptr;
+		if (fopen_s(&f, filePath, "r") == 0 && f)
+		{
+			char buf[128] = {};
+			if (fgets(buf, sizeof(buf), f))
+			{
+				int len = (int)strlen(buf);
+				while (len > 0 && (buf[len - 1] == '\n' || buf[len - 1] == '\r' || buf[len - 1] == ' '))
+					buf[--len] = '\0';
+
+				if (len > 0)
+				{
+					strncpy_s(g_Win64Username, sizeof(g_Win64Username), buf, _TRUNCATE);
+				}
+			}
+			fclose(f);
+		}
 	}
 
+	if (g_Win64Username[0] == 0)
+	{
+		DWORD sz = 17;
+		if (!GetUserNameA(g_Win64Username, &sz))
+			strncpy_s(g_Win64Username, 17, "Player", _TRUNCATE);
+		g_Win64Username[16] = 0;
+	}
+
+	MultiByteToWideChar(CP_ACP, 0, g_Win64Username, -1, g_Win64UsernameW, 17);
+
 	// Initialize global strings
 	MyRegisterClass(hInstance);
 
@@ -935,6 +977,8 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 		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();