Merge branch 'main' into pr/win64-world-saves

# Conflicts:
#	Minecraft.Client/MinecraftServer.cpp
#	README.md

7 files changed, 1574 insertions, 222 deletions

diff --git a/Minecraft.Client/Windows64/KeyboardMouseInput.cpp b/Minecraft.Client/Windows64/KeyboardMouseInput.cpp
index fc763394..df57db44 100644
--- a/Minecraft.Client/Windows64/KeyboardMouseInput.cpp
+++ b/Minecraft.Client/Windows64/KeyboardMouseInput.cpp
@@ -103,6 +103,7 @@ void KeyboardMouseInput::OnRawMouseInput(LPARAM lParam)
 
 void KeyboardMouseInput::OnMouseButton(int button, bool down)
 {
+	if (ui.IsPauseMenuDisplayed(ProfileManager.GetPrimaryPad())) { return; }
 	if (button >= 0 && button < 3)
 	{
 		if (down && !m_mouseButtons[button]) m_mousePressedAccum[button] = true;
diff --git a/Minecraft.Client/Windows64/Network/WinsockNetLayer.cpp b/Minecraft.Client/Windows64/Network/WinsockNetLayer.cpp
new file mode 100644
index 00000000..ca1d62af
--- /dev/null
+++ b/Minecraft.Client/Windows64/Network/WinsockNetLayer.cpp
@@ -0,0 +1,920 @@
+// Code implemented by LCEMP, credit if used on other repos
+// https://github.com/LCEMP/LCEMP
+
+#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 g_Win64DedicatedServer = false;
+int g_Win64DedicatedServerPort = WIN64_NET_DEFAULT_PORT;
+char g_Win64DedicatedServerBindIP[256] = "";
+
+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, const char* bindIp)
+{
+	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 = (bindIp == NULL || bindIp[0] == 0) ? AI_PASSIVE : 0;
+
+	char portStr[16];
+	sprintf_s(portStr, "%d", port);
+
+	const char* resolvedBindIp = (bindIp != NULL && bindIp[0] != 0) ? bindIp : NULL;
+	int iResult = getaddrinfo(resolvedBindIp, portStr, &hints, &result);
+	if (iResult != 0)
+	{
+		app.DebugPrintf("getaddrinfo failed for %s:%d - %d\n",
+			resolvedBindIp != NULL ? resolvedBindIp : "*",
+			port,
+			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 %s:%d\n",
+		resolvedBindIp != NULL ? resolvedBindIp : "*",
+		port);
+	return true;
+}
+
+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;
+
+	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;
+	}
+
+	bool connected = false;
+	BYTE assignedSmallId = 0;
+	const int maxAttempts = 12;
+
+	for (int attempt = 0; attempt < maxAttempts; ++attempt)
+	{
+		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));
+
+		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);
+
+	if (!connected)
+	{
+		return false;
+	}
+	s_localSmallId = assignedSmallId;
+
+	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);
+
+	std::vector<BYTE> recvBuf;
+	recvBuf.resize(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 =
+			((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_MAX_PACKET_SIZE)
+		{
+			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 ((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[0], packetSize);
+	}
+
+	EnterCriticalSection(&s_connectionsLock);
+	for (size_t i = 0; i < s_connections.size(); i++)
+	{
+		if (s_connections[i].smallId == clientSmallId)
+		{
+			s_connections[i].active = false;
+			if (s_connections[i].tcpSocket != INVALID_SOCKET)
+			{
+				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);
+}
+
+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)
+{
+	std::vector<BYTE> recvBuf;
+	recvBuf.resize(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_MAX_PACKET_SIZE)
+		{
+			app.DebugPrintf("Win64 LAN: Invalid packet size %d from host (max=%d)\n",
+				packetSize,
+				(int)WIN64_NET_MAX_PACKET_SIZE);
+			break;
+		}
+
+		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[0], packetSize);
+	}
+
+	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
diff --git a/Minecraft.Client/Windows64/Network/WinsockNetLayer.h b/Minecraft.Client/Windows64/Network/WinsockNetLayer.h
new file mode 100644
index 00000000..fd1280f7
--- /dev/null
+++ b/Minecraft.Client/Windows64/Network/WinsockNetLayer.h
@@ -0,0 +1,154 @@
+// Code implemented by LCEMP, credit if used on other repos
+// https://github.com/LCEMP/LCEMP
+#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_NET_MAX_PACKET_SIZE (4 * 1024 * 1024)
+#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, const char* bindIp = NULL);
+	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 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 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];
+extern bool g_Win64DedicatedServer;
+extern int g_Win64DedicatedServerPort;
+extern char g_Win64DedicatedServerBindIP[256];
+
+#endif
diff --git a/Minecraft.Client/Windows64/Sentient/TelemetryEnum.h b/Minecraft.Client/Windows64/Sentient/TelemetryEnum.h
index 77d39a39..5a5a709f 100644
--- a/Minecraft.Client/Windows64/Sentient/TelemetryEnum.h
+++ b/Minecraft.Client/Windows64/Sentient/TelemetryEnum.h
@@ -8,8 +8,8 @@ EnemyWeaponID	What weapon the enemy is holding or what counter/AI the enemy is t
 EnrollmentType	How did players enroll? (Using Kinect)
 LandscapeOrPortrait	Are you currently showing in landscape or portrait mode? (Win8 only)
 LevelDurationInSeconds	How long, total, has the user been playing in this level - whatever best represents this duration for attempting the level you'd like to track.
-LevelExitProgressStat1	Refers to the highest level performance metric for your game.  For example, a performance metric could points earned, race time, total kills, etc.  This is entirely up to you and will help us understand how well the player performed, or how far the player progressed  in the level before exiting.
-LevelExitProgressStat2	Refers to the highest level performance metric for your game.  For example, a performance metric could points earned, race time, total kills, etc.  This is entirely up to you and will help us understand how well the player performed, or how far the player progressed  in the level before exiting.
+LevelExitProgressStat1	Refers to the highest level performance metric for your game.� For example, a performance metric could points earned, race time, total kills, etc.  This is entirely up to you and will help us understand how well the player performed, or how far the player progressed �in the level before exiting.
+LevelExitProgressStat2	Refers to the highest level performance metric for your game.� For example, a performance metric could points earned, race time, total kills, etc.  This is entirely up to you and will help us understand how well the player performed, or how far the player progressed �in the level before exiting.
 LevelID	This is a more granular view of mode, allowing teams to get a sense of the levels or maps players are playing and providing some insight into how players progress through a game.  Teams will have to provide the game mappings that correspond to the integers.  The intent is that a level is highest level at which modes can be dissected and provides an indication of player progression in a game.  The intent is that level start and ends do not occur more than every 2 minutes or so, otherwise the data reported will be difficult to understand.  Levels are unique only within a given modeID - so you can have a ModeID =1, LevelID =1 and a different ModeID=2, LevelID = 1 indicate two completely different levels. LevelID = 0 means undefined or unknown.
 LevelInstanceID	Generated by the game every time LevelStart or LevelResume is called.  This should be a unique ID (can be sequential) within a session.
 LowResMapX	Player position normalized to 0-255
@@ -18,7 +18,7 @@ LowResMapZ	Player position normalized to 0-255
 MapID	Unique ID for the current map the player is on
 MarketplaceOfferID	Unique ID for the Xbox LIVE marketplace offer that the upsell links to
 MicroGoodTypeID	Describes the type of consumable or microgood
-MultiplayerInstanceID	multiplayerinstanceID is a title-generated value that is the same for all players in the same multiplayer session. 
+MultiplayerInstanceID	multiplayerinstanceID is a title-generated value that is the same for all players in the same multiplayer session.�
 NumberOfLocalPlayers	the number of players that are playing together in the game locally in the current session (on the same piece of hardware)
 NumberOfOnlinePlayers	the number of players that are playing together in the game online in the current session (not on the same piece of hardware)
 NumberOfSkeletonsInView	the max and min of skeletons that were in view, regardless of enrollment
@@ -28,7 +28,7 @@ PlayerLevelUpProgressStat1	Refers to a performance metric for your player when t
 PlayerLevelUpProgressStat2	Refers to a performance metric for your player when they level or rank up.  This is entirely up to you and will help us understand how well the player performed, or how far the player has progressed.
 PlayerWeaponID	What weapon the player is holding or what approach/tact the player is taking to overcome a challenge
 PlayspaceFeedbackWarningDirection	identifies which side of the playspace players are getting too close to that results in the playspace feedback 
-SaveOrCheckpointID	It is important that you also generate and save a unique SaveOrCheckpointID that can be read and reported when the player resumes from this save file or checkpoint.  These IDs should be completely unique across the player’s experience, even if they play the same level multiple times.  These IDs are critical to allowing us to re-stitch a player’s experience in your title and provide an accurate measure of time in level.
+SaveOrCheckpointID	It is important that you also generate and save a unique SaveOrCheckpointID that can be read and reported when the player resumes from this save file or checkpoint.  These IDs should be completely unique across the player�s experience, even if they play the same level multiple times.  These IDs are critical to allowing us to re-stitch a player�s experience in your title and provide an accurate measure of time in level.
 SecondsSinceInitialize	Number of seconds elapsed since Sentient initialize.
 SecondsSinceInitializeMax	Number of seconds elapsed since Sentient initialize.
 SecondsSinceInitializeMin	Number of seconds elapsed since Sentient initialize.
@@ -224,6 +224,12 @@ enum ETelemetryChallenges
 	eTelemetryTutorial_Trading,
 	eTelemetryTutorial_TradingMenu,
 	eTelemetryTutorial_Enderchest,
+	eTelemetryTutorial_Hopper,
+	eTelemetryTutorial_Beacon,
+	eTelemetryTutorial_Horse,
+	eTelemetryTutorial_HorseMenu,
+	eTelemetryTutorial_FireworksMenu,
+	eTelemetryTutorial_BeaconMenu
 
 	// Sent over network as a byte
 };
\ No newline at end of file
diff --git a/Minecraft.Client/Windows64/Windows64_App.cpp b/Minecraft.Client/Windows64/Windows64_App.cpp
index bba33cad..ad9e1f24 100644
--- a/Minecraft.Client/Windows64/Windows64_App.cpp
+++ b/Minecraft.Client/Windows64/Windows64_App.cpp
@@ -35,9 +35,27 @@ void CConsoleMinecraftApp::FatalLoadError()
 
 void CConsoleMinecraftApp::CaptureSaveThumbnail()
 {
+	RenderManager.CaptureThumbnail(&m_ThumbnailBuffer);
 }
 void CConsoleMinecraftApp::GetSaveThumbnail(PBYTE *pbData,DWORD *pdwSize)
 {
+	// On a save caused by a create world, the thumbnail capture won't have happened
+	if (m_ThumbnailBuffer.Allocated())
+	{
+		if (pbData)
+		{
+			*pbData  = new BYTE[m_ThumbnailBuffer.GetBufferSize()];
+			*pdwSize = m_ThumbnailBuffer.GetBufferSize();
+			memcpy(*pbData, m_ThumbnailBuffer.GetBufferPointer(), *pdwSize);
+		}
+		m_ThumbnailBuffer.Release();
+	}
+	else
+	{
+		// No capture happened (e.g. first save on world creation) leave thumbnail as NULL
+		if (pbData)  *pbData  = NULL;
+		if (pdwSize) *pdwSize = 0;
+	}
 }
 void CConsoleMinecraftApp::ReleaseSaveThumbnail()
 {
@@ -57,7 +75,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
diff --git a/Minecraft.Client/Windows64/Windows64_App.h b/Minecraft.Client/Windows64/Windows64_App.h
index de8f6d85..bff916ec 100644
--- a/Minecraft.Client/Windows64/Windows64_App.h
+++ b/Minecraft.Client/Windows64/Windows64_App.h
@@ -1,7 +1,9 @@
 #pragma once
+#include "4JLibs\inc\4J_Render.h"
 
 class CConsoleMinecraftApp : public CMinecraftApp
 {
+	ImageFileBuffer m_ThumbnailBuffer;
 public:
 	CConsoleMinecraftApp();
 
diff --git a/Minecraft.Client/Windows64/Windows64_Minecraft.cpp b/Minecraft.Client/Windows64/Windows64_Minecraft.cpp
index 1bffe317..ed6781a3 100644
--- a/Minecraft.Client/Windows64/Windows64_Minecraft.cpp
+++ b/Minecraft.Client/Windows64/Windows64_Minecraft.cpp
@@ -4,6 +4,9 @@
 #include "stdafx.h"
 
 #include <assert.h>
+#include <iostream>
+#include <ShellScalingApi.h>
+#include <shellapi.h>
 #include "GameConfig\Minecraft.spa.h"
 #include "..\MinecraftServer.h"
 #include "..\LocalPlayer.h"
@@ -33,9 +36,11 @@
 #include "Sentient\SentientManager.h"
 #include "..\..\Minecraft.World\IntCache.h"
 #include "..\Textures.h"
+#include "..\Settings.h"
 #include "Resource.h"
 #include "..\..\Minecraft.World\compression.h"
 #include "..\..\Minecraft.World\OldChunkStorage.h"
+#include "Network\WinsockNetLayer.h"
 
 #include "Xbox/resource.h"
 
@@ -83,10 +88,158 @@ BOOL g_bWidescreen = TRUE;
 int g_iScreenWidth = 1920;
 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) };
 
+struct Win64LaunchOptions
+{
+	int screenMode;
+	bool serverMode;
+};
+
+static void CopyWideArgToAnsi(LPCWSTR source, char* dest, size_t destSize)
+{
+	if (destSize == 0)
+		return;
+
+	dest[0] = 0;
+	if (source == NULL)
+		return;
+
+	WideCharToMultiByte(CP_ACP, 0, source, -1, dest, (int)destSize, NULL, NULL);
+	dest[destSize - 1] = 0;
+}
+
+static void ApplyScreenMode(int screenMode)
+{
+	switch (screenMode)
+	{
+	case 1:
+		g_iScreenWidth = 1280;
+		g_iScreenHeight = 720;
+		break;
+	case 2:
+		g_iScreenWidth = 640;
+		g_iScreenHeight = 480;
+		break;
+	case 3:
+		g_iScreenWidth = 720;
+		g_iScreenHeight = 408;
+		break;
+	default:
+		break;
+	}
+}
+
+static Win64LaunchOptions ParseLaunchOptions()
+{
+	Win64LaunchOptions options = {};
+	options.screenMode = 0;
+	options.serverMode = false;
+
+	g_Win64MultiplayerJoin = false;
+	g_Win64MultiplayerPort = WIN64_NET_DEFAULT_PORT;
+	g_Win64DedicatedServer = false;
+	g_Win64DedicatedServerPort = WIN64_NET_DEFAULT_PORT;
+	g_Win64DedicatedServerBindIP[0] = 0;
+
+	int argc = 0;
+	LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
+	if (argv == NULL)
+		return options;
+
+	if (argc > 1 && lstrlenW(argv[1]) == 1)
+	{
+		if (argv[1][0] >= L'1' && argv[1][0] <= L'3')
+			options.screenMode = argv[1][0] - L'0';
+	}
+
+	for (int i = 1; i < argc; ++i)
+	{
+		if (_wcsicmp(argv[i], L"-server") == 0)
+		{
+			options.serverMode = true;
+			break;
+		}
+	}
+
+	g_Win64DedicatedServer = options.serverMode;
+
+	for (int i = 1; i < argc; ++i)
+	{
+		if (_wcsicmp(argv[i], L"-name") == 0 && (i + 1) < argc)
+		{
+			CopyWideArgToAnsi(argv[++i], g_Win64Username, sizeof(g_Win64Username));
+		}
+		else if (_wcsicmp(argv[i], L"-ip") == 0 && (i + 1) < argc)
+		{
+			char ipBuf[256];
+			CopyWideArgToAnsi(argv[++i], ipBuf, sizeof(ipBuf));
+			if (options.serverMode)
+			{
+				strncpy_s(g_Win64DedicatedServerBindIP, sizeof(g_Win64DedicatedServerBindIP), ipBuf, _TRUNCATE);
+			}
+			else
+			{
+				strncpy_s(g_Win64MultiplayerIP, sizeof(g_Win64MultiplayerIP), ipBuf, _TRUNCATE);
+				g_Win64MultiplayerJoin = true;
+			}
+		}
+		else if (_wcsicmp(argv[i], L"-port") == 0 && (i + 1) < argc)
+		{
+			wchar_t* endPtr = NULL;
+			long port = wcstol(argv[++i], &endPtr, 10);
+			if (endPtr != argv[i] && *endPtr == 0 && port > 0 && port <= 65535)
+			{
+				if (options.serverMode)
+					g_Win64DedicatedServerPort = (int)port;
+				else
+					g_Win64MultiplayerPort = (int)port;
+			}
+		}
+	}
+
+	LocalFree(argv);
+	return options;
+}
+
+static BOOL WINAPI HeadlessServerCtrlHandler(DWORD ctrlType)
+{
+	switch (ctrlType)
+	{
+	case CTRL_C_EVENT:
+	case CTRL_BREAK_EVENT:
+	case CTRL_CLOSE_EVENT:
+	case CTRL_SHUTDOWN_EVENT:
+		app.m_bShutdown = true;
+		MinecraftServer::HaltServer();
+		return TRUE;
+	default:
+		return FALSE;
+	}
+}
+
+static void SetupHeadlessServerConsole()
+{
+	if (AllocConsole())
+	{
+		FILE* stream = NULL;
+		freopen_s(&stream, "CONIN$", "r", stdin);
+		freopen_s(&stream, "CONOUT$", "w", stdout);
+		freopen_s(&stream, "CONOUT$", "w", stderr);
+		SetConsoleTitleA("Minecraft Server");
+	}
+
+	SetConsoleCtrlHandler(HeadlessServerCtrlHandler, TRUE);
+}
+
 void DefineActions(void)
 {
 	// The app needs to define the actions required, and the possible mappings for these
@@ -402,6 +555,15 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 		if (LOWORD(wParam) == WA_INACTIVE)
 			KMInput.SetCapture(false);
 		break;
+	case WM_SETFOCUS:
+		{
+			// Re-capture when window receives focus (e.g., after clicking on it)
+			Minecraft *pMinecraft = Minecraft::GetInstance();
+			bool shouldCapture = pMinecraft && app.GetGameStarted() && !ui.GetMenuDisplayed(0) && pMinecraft->screen == NULL;
+			if (shouldCapture)
+				KMInput.SetCapture(true);
+		}
+		break;
 	case WM_KILLFOCUS:
 		KMInput.SetCapture(false);
 		KMInput.ClearAllState();
@@ -415,7 +577,6 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 			return TRUE;
 		}
 		return DefWindowProc(hWnd, message, wParam, lParam);
-
 	default:
 		return DefWindowProc(hWnd, message, wParam, lParam);
 	}
@@ -443,7 +604,7 @@ ATOM MyRegisterClass(HINSTANCE hInstance)
 	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
 	wcex.lpszMenuName	= "Minecraft";
 	wcex.lpszClassName	= "MinecraftClass";
-	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
+	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_MINECRAFTWINDOWS));
 
 	return RegisterClassEx(&wcex);
 }
@@ -706,7 +867,224 @@ void CleanupDevice()
 	if( g_pd3dDevice ) g_pd3dDevice->Release();
 }
 
+static Minecraft* InitialiseMinecraftRuntime()
+{
+	app.loadMediaArchive();
+
+	RenderManager.Initialise(g_pd3dDevice, g_pSwapChain);
+
+	app.loadStringTable();
+	ui.init(g_pd3dDevice, g_pImmediateContext, g_pRenderTargetView, g_pDepthStencilView, g_iScreenWidth, g_iScreenHeight);
+
+	InputManager.Initialise(1, 3, MINECRAFT_ACTION_MAX, ACTION_MAX_MENU);
+	KMInput.Init(g_hWnd);
+	DefineActions();
+	InputManager.SetJoypadMapVal(0, 0);
+	InputManager.SetKeyRepeatRate(0.3f, 0.2f);
+
+	ProfileManager.Initialise(TITLEID_MINECRAFT,
+		app.m_dwOfferID,
+		PROFILE_VERSION_10,
+		NUM_PROFILE_VALUES,
+		NUM_PROFILE_SETTINGS,
+		dwProfileSettingsA,
+		app.GAME_DEFINED_PROFILE_DATA_BYTES * XUSER_MAX_COUNT,
+		&app.uiGameDefinedDataChangedBitmask
+	);
+	ProfileManager.SetDefaultOptionsCallback(&CConsoleMinecraftApp::DefaultOptionsCallback, (LPVOID)&app);
+
+	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);
+	}
+	wcscpy_s(IQNet::m_player[0].m_gamertag, 32, g_Win64UsernameW);
+
+	WinsockNetLayer::Initialize();
+
+	ProfileManager.SetDebugFullOverride(true);
+
+	Tesselator::CreateNewThreadStorage(1024 * 1024);
+	AABB::CreateNewThreadStorage();
+	Vec3::CreateNewThreadStorage();
+	IntCache::CreateNewThreadStorage();
+	Compression::CreateNewThreadStorage();
+	OldChunkStorage::CreateNewThreadStorage();
+	Level::enableLightingCache();
+	Tile::CreateNewThreadStorage();
+
+	Minecraft::main();
+	Minecraft* pMinecraft = Minecraft::GetInstance();
+	if (pMinecraft == NULL)
+		return NULL;
+
+	app.InitGameSettings();
+	app.InitialiseTips();
+
+	pMinecraft->options->set(Options::Option::MUSIC, 1.0f);
+	pMinecraft->options->set(Options::Option::SOUND, 1.0f);
+
+	return pMinecraft;
+}
+
+static int HeadlessServerConsoleThreadProc(void* lpParameter)
+{
+	UNREFERENCED_PARAMETER(lpParameter);
+
+	std::string line;
+	while (!app.m_bShutdown)
+	{
+		if (!std::getline(std::cin, line))
+		{
+			if (std::cin.eof())
+			{
+				break;
+			}
 
+			std::cin.clear();
+			Sleep(50);
+			continue;
+		}
+
+		wstring command = trimString(convStringToWstring(line));
+		if (command.empty())
+			continue;
+
+		MinecraftServer* server = MinecraftServer::getInstance();
+		if (server != NULL)
+		{
+			server->handleConsoleInput(command, server);
+		}
+	}
+
+	return 0;
+}
+
+static int RunHeadlessServer()
+{
+	SetupHeadlessServerConsole();
+
+	Settings serverSettings(new File(L"server.properties"));
+	wstring configuredBindIp = serverSettings.getString(L"server-ip", L"");
+
+	const char* bindIp = "*";
+	if (g_Win64DedicatedServerBindIP[0] != 0)
+	{
+		bindIp = g_Win64DedicatedServerBindIP;
+	}
+	else if (!configuredBindIp.empty())
+	{
+		bindIp = wstringtochararray(configuredBindIp);
+	}
+
+	const int port = g_Win64DedicatedServerPort > 0 ? g_Win64DedicatedServerPort : serverSettings.getInt(L"server-port", WIN64_NET_DEFAULT_PORT);
+
+	printf("Starting headless server on %s:%d\n", bindIp, port);
+	fflush(stdout);
+
+	Minecraft* pMinecraft = InitialiseMinecraftRuntime();
+	if (pMinecraft == NULL)
+	{
+		fprintf(stderr, "Failed to initialise the Minecraft runtime.\n");
+		return 1;
+	}
+
+	app.SetGameHostOption(eGameHostOption_Difficulty, serverSettings.getInt(L"difficulty", 1));
+	app.SetGameHostOption(eGameHostOption_Gamertags, 1);
+	app.SetGameHostOption(eGameHostOption_GameType, serverSettings.getInt(L"gamemode", 0));
+	app.SetGameHostOption(eGameHostOption_LevelType, 0);
+	app.SetGameHostOption(eGameHostOption_Structures, serverSettings.getBoolean(L"generate-structures", true) ? 1 : 0);
+	app.SetGameHostOption(eGameHostOption_BonusChest, serverSettings.getBoolean(L"bonus-chest", false) ? 1 : 0);
+	app.SetGameHostOption(eGameHostOption_PvP, serverSettings.getBoolean(L"pvp", true) ? 1 : 0);
+	app.SetGameHostOption(eGameHostOption_TrustPlayers, serverSettings.getBoolean(L"trust-players", true) ? 1 : 0);
+	app.SetGameHostOption(eGameHostOption_FireSpreads, serverSettings.getBoolean(L"fire-spreads", true) ? 1 : 0);
+	app.SetGameHostOption(eGameHostOption_TNT, serverSettings.getBoolean(L"tnt", true) ? 1 : 0);
+	app.SetGameHostOption(eGameHostOption_HostCanFly, 1);
+	app.SetGameHostOption(eGameHostOption_HostCanChangeHunger, 1);
+	app.SetGameHostOption(eGameHostOption_HostCanBeInvisible, 1);
+	app.SetGameHostOption(eGameHostOption_MobGriefing, 1);
+	app.SetGameHostOption(eGameHostOption_KeepInventory, 0);
+	app.SetGameHostOption(eGameHostOption_DoMobSpawning, 1);
+	app.SetGameHostOption(eGameHostOption_DoMobLoot, 1);
+	app.SetGameHostOption(eGameHostOption_DoTileDrops, 1);
+	app.SetGameHostOption(eGameHostOption_NaturalRegeneration, 1);
+	app.SetGameHostOption(eGameHostOption_DoDaylightCycle, 1);
+
+	MinecraftServer::resetFlags();
+	g_NetworkManager.HostGame(0, false, true, MINECRAFT_NET_MAX_PLAYERS, 0);
+
+	if (!WinsockNetLayer::IsActive())
+	{
+		fprintf(stderr, "Failed to bind the server socket on %s:%d.\n", bindIp, port);
+		return 1;
+	}
+
+	g_NetworkManager.FakeLocalPlayerJoined();
+
+	NetworkGameInitData* param = new NetworkGameInitData();
+	param->seed = 0;
+	param->settings = app.GetGameHostOption(eGameHostOption_All);
+
+	g_NetworkManager.ServerStoppedCreate(true);
+	g_NetworkManager.ServerReadyCreate(true);
+
+	C4JThread* thread = new C4JThread(&CGameNetworkManager::ServerThreadProc, param, "Server", 256 * 1024);
+	thread->SetProcessor(CPU_CORE_SERVER);
+	thread->Run();
+
+	g_NetworkManager.ServerReadyWait();
+	g_NetworkManager.ServerReadyDestroy();
+
+	if (MinecraftServer::serverHalted())
+	{
+		fprintf(stderr, "The server halted during startup.\n");
+		g_NetworkManager.LeaveGame(false);
+		return 1;
+	}
+
+	app.SetGameStarted(true);
+	g_NetworkManager.DoWork();
+
+	printf("Server ready on %s:%d\n", bindIp, port);
+	printf("Type 'help' for server commands.\n");
+	fflush(stdout);
+
+	C4JThread* consoleThread = new C4JThread(&HeadlessServerConsoleThreadProc, NULL, "Server console", 128 * 1024);
+	consoleThread->Run();
+
+	MSG msg = { 0 };
+	while (WM_QUIT != msg.message && !app.m_bShutdown && !MinecraftServer::serverHalted())
+	{
+		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
+		{
+			TranslateMessage(&msg);
+			DispatchMessage(&msg);
+			continue;
+		}
+
+		app.UpdateTime();
+		ProfileManager.Tick();
+		StorageManager.Tick();
+		RenderManager.Tick();
+		ui.tick();
+		g_NetworkManager.DoWork();
+		app.HandleXuiActions();
+
+		Sleep(10);
+	}
+
+	printf("Stopping server...\n");
+	fflush(stdout);
+
+	app.m_bShutdown = true;
+	MinecraftServer::HaltServer();
+	g_NetworkManager.LeaveGame(false);
+	return 0;
+}
 
 int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 					   _In_opt_ HINSTANCE hPrevInstance,
@@ -716,47 +1094,36 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 	UNREFERENCED_PARAMETER(hPrevInstance);
 	UNREFERENCED_PARAMETER(lpCmdLine);
 
+	// 4J-Win64: set CWD to exe dir so asset paths resolve correctly
+	{
+		char szExeDir[MAX_PATH] = {};
+		GetModuleFileNameA(NULL, szExeDir, MAX_PATH);
+		char *pSlash = strrchr(szExeDir, '\\');
+		if (pSlash) { *(pSlash + 1) = '\0'; SetCurrentDirectoryA(szExeDir); }
+	}
+
 	// Declare DPI awareness so GetSystemMetrics returns physical pixels
 	SetProcessDPIAware();
 	g_iScreenWidth = GetSystemMetrics(SM_CXSCREEN);
 	g_iScreenHeight = GetSystemMetrics(SM_CYSCREEN);
+	Win64LaunchOptions launchOptions = ParseLaunchOptions();
+	ApplyScreenMode(launchOptions.screenMode);
 
+	if (g_Win64Username[0] == 0)
 	{
-		char buf[128];
-		sprintf(buf, "Screen resolution: %dx%d\n", g_iScreenWidth, g_iScreenHeight);
-		OutputDebugStringA(buf);
-	}
-
-	if(lpCmdLine)
-	{
-		if(lpCmdLine[0] == '1')
-		{
-			g_iScreenWidth = 1280;
-			g_iScreenHeight = 720;
-		}
-		else if(lpCmdLine[0] == '2')
-		{
-			g_iScreenWidth = 640;
-			g_iScreenHeight = 480;
-		}
-		else if(lpCmdLine[0] == '3')
-		{
-			// Vita
-			g_iScreenWidth = 720;
-			g_iScreenHeight = 408;
-
-			// Vita native
-			//g_iScreenWidth = 960;
-			//g_iScreenHeight = 544;
-		}
+		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);
 
 	// Perform application initialization:
-	if (!InitInstance (hInstance, nCmdShow))
+	if (!InitInstance (hInstance, launchOptions.serverMode ? SW_HIDE : nCmdShow))
 	{
 		return FALSE;
 	}
@@ -769,6 +1136,13 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 		return 0;
 	}
 
+	if (launchOptions.serverMode)
+	{
+		int serverResult = RunHeadlessServer();
+		CleanupDevice();
+		return serverResult;
+	}
+
 #if 0
 	// Main message loop
 	MSG msg = {0};
@@ -821,193 +1195,13 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 	}
 
 #endif
-	app.loadMediaArchive();
-
-	RenderManager.Initialise(g_pd3dDevice, g_pSwapChain);
-
-	app.loadStringTable();
-	ui.init(g_pd3dDevice,g_pImmediateContext,g_pRenderTargetView,g_pDepthStencilView,g_iScreenWidth,g_iScreenHeight);
-
-	////////////////
-	// Initialise //
-	////////////////
-
-	// Set the number of possible joypad layouts that the user can switch between, and the number of actions
-	InputManager.Initialise(1,3,MINECRAFT_ACTION_MAX, ACTION_MAX_MENU);
-
-	// Initialize keyboard/mouse input
-	KMInput.Init(g_hWnd);
-
-	// Set the default joypad action mappings for Minecraft
-	DefineActions();
-	InputManager.SetJoypadMapVal(0,0);
-	InputManager.SetKeyRepeatRate(0.3f,0.2f);
-
-	// Initialise the profile manager with the game Title ID, Offer ID, a profile version number, and the number of profile values and settings
-	ProfileManager.Initialise(TITLEID_MINECRAFT,
-		app.m_dwOfferID,
-		PROFILE_VERSION_10,
-		NUM_PROFILE_VALUES,
-		NUM_PROFILE_SETTINGS,
-		dwProfileSettingsA,
-		app.GAME_DEFINED_PROFILE_DATA_BYTES*XUSER_MAX_COUNT,
-		&app.uiGameDefinedDataChangedBitmask
-		);
-#if 0
-	// register the awards
-	ProfileManager.RegisterAward(eAward_TakingInventory,	ACHIEVEMENT_01, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_GettingWood,		ACHIEVEMENT_02, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_Benchmarking,		ACHIEVEMENT_03, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_TimeToMine,			ACHIEVEMENT_04, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_HotTopic,			ACHIEVEMENT_05, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_AquireHardware,		ACHIEVEMENT_06, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_TimeToFarm,			ACHIEVEMENT_07, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_BakeBread,			ACHIEVEMENT_08, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_TheLie,				ACHIEVEMENT_09, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_GettingAnUpgrade,	ACHIEVEMENT_10, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_DeliciousFish,		ACHIEVEMENT_11, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_OnARail,			ACHIEVEMENT_12, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_TimeToStrike,		ACHIEVEMENT_13, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_MonsterHunter,		ACHIEVEMENT_14, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_CowTipper,			ACHIEVEMENT_15, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_WhenPigsFly,		ACHIEVEMENT_16, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_LeaderOfThePack,	ACHIEVEMENT_17, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_MOARTools,			ACHIEVEMENT_18, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_DispenseWithThis,	ACHIEVEMENT_19, eAwardType_Achievement);
-	ProfileManager.RegisterAward(eAward_InToTheNether,		ACHIEVEMENT_20, eAwardType_Achievement);
-
-	ProfileManager.RegisterAward(eAward_mine100Blocks,		GAMER_PICTURE_GAMERPIC1,			eAwardType_GamerPic,false,app.GetStringTable(),IDS_AWARD_TITLE,IDS_AWARD_GAMERPIC1,IDS_CONFIRM_OK);
-	ProfileManager.RegisterAward(eAward_kill10Creepers,		GAMER_PICTURE_GAMERPIC2,			eAwardType_GamerPic,false,app.GetStringTable(),IDS_AWARD_TITLE,IDS_AWARD_GAMERPIC2,IDS_CONFIRM_OK);
-
-	ProfileManager.RegisterAward(eAward_eatPorkChop,		AVATARASSETAWARD_PORKCHOP_TSHIRT,	eAwardType_AvatarItem,false,app.GetStringTable(),IDS_AWARD_TITLE,IDS_AWARD_AVATAR1,IDS_CONFIRM_OK);
-	ProfileManager.RegisterAward(eAward_play100Days,		AVATARASSETAWARD_WATCH,				eAwardType_AvatarItem,false,app.GetStringTable(),IDS_AWARD_TITLE,IDS_AWARD_AVATAR2,IDS_CONFIRM_OK);
-	ProfileManager.RegisterAward(eAward_arrowKillCreeper,	AVATARASSETAWARD_CAP,				eAwardType_AvatarItem,false,app.GetStringTable(),IDS_AWARD_TITLE,IDS_AWARD_AVATAR3,IDS_CONFIRM_OK);
-
-	ProfileManager.RegisterAward(eAward_socialPost,			0,									eAwardType_Theme,false,app.GetStringTable(),IDS_AWARD_TITLE,IDS_AWARD_THEME,IDS_CONFIRM_OK,THEME_NAME,THEME_FILESIZE);
-
-	// Rich Presence init - number of presences, number of contexts
-	ProfileManager.RichPresenceInit(4,1);
-	ProfileManager.RegisterRichPresenceContext(CONTEXT_GAME_STATE);
-
-	// initialise the storage manager with a default save display name, a Minimum save size, and a callback for displaying the saving message
-	StorageManager.Init(app.GetString(IDS_DEFAULT_SAVENAME),"savegame.dat",FIFTY_ONE_MB,&CConsoleMinecraftApp::DisplaySavingMessage,(LPVOID)&app);
-	// Set up the global title storage path
-	StorageManager.StoreTMSPathName();
-
-	// set a function to be called when there's a sign in change, so we can exit a level if the primary player signs out
-	ProfileManager.SetSignInChangeCallback(&CConsoleMinecraftApp::SignInChangeCallback,(LPVOID)&app);
-
-	// set a function to be called when the ethernet is disconnected, so we can back out if required
-	ProfileManager.SetNotificationsCallback(&CConsoleMinecraftApp::NotificationsCallback,(LPVOID)&app);
-
-#endif
-	// Set a callback for the default player options to be set - when there is no profile data for the player
-	ProfileManager.SetDefaultOptionsCallback(&CConsoleMinecraftApp::DefaultOptionsCallback,(LPVOID)&app);
-#if 0
-	// Set a callback to deal with old profile versions needing updated to new versions
-	ProfileManager.SetOldProfileVersionCallback(&CConsoleMinecraftApp::OldProfileVersionCallback,(LPVOID)&app);
-
-	// Set a callback for when there is a read error on profile data
-	ProfileManager.SetProfileReadErrorCallback(&CConsoleMinecraftApp::ProfileReadErrorCallback,(LPVOID)&app);
-
-#endif
-	// QNet needs to be setup after profile manager, as we do not want its Notify listener to handle
-	// XN_SYS_SIGNINCHANGED notifications. This does mean that we need to have a callback in the
-	// ProfileManager for XN_LIVE_INVITE_ACCEPTED for QNet.
-	g_NetworkManager.Initialise();
-
-
-
-	// 4J-PB moved further down
-	//app.InitGameSettings();
-
-	// debug switch to trial version
-	ProfileManager.SetDebugFullOverride(true);
-
-#if 0
-	//ProfileManager.AddDLC(2);
-	StorageManager.SetDLCPackageRoot("DLCDrive");
-	StorageManager.RegisterMarketplaceCountsCallback(&CConsoleMinecraftApp::MarketplaceCountsCallback,(LPVOID)&app);
-	// Kinect !
-
-	if(XNuiGetHardwareStatus()!=0)
+	Minecraft *pMinecraft = InitialiseMinecraftRuntime();
+	if (pMinecraft == NULL)
 	{
-		// If the Kinect Sensor is not physically connected, this function returns 0.
-		NuiInitialize(NUI_INITIALIZE_FLAG_USES_HIGH_QUALITY_COLOR | NUI_INITIALIZE_FLAG_USES_DEPTH |
-			NUI_INITIALIZE_FLAG_EXTRAPOLATE_FLOOR_PLANE | NUI_INITIALIZE_FLAG_USES_FITNESS | NUI_INITIALIZE_FLAG_NUI_GUIDE_DISABLED | NUI_INITIALIZE_FLAG_SUPPRESS_AUTOMATIC_UI,NUI_INITIALIZE_DEFAULT_HARDWARE_THREAD );
+		CleanupDevice();
+		return 1;
 	}
 
-	// Sentient !
-	hr = TelemetryManager->Init();
-
-#endif
-	// Initialise TLS for tesselator, for this main thread
-	Tesselator::CreateNewThreadStorage(1024*1024);
-	// Initialise TLS for AABB and Vec3 pools, for this main thread
-	AABB::CreateNewThreadStorage();
-	Vec3::CreateNewThreadStorage();
-	IntCache::CreateNewThreadStorage();
-	Compression::CreateNewThreadStorage();
-	OldChunkStorage::CreateNewThreadStorage();
-	Level::enableLightingCache();
-	Tile::CreateNewThreadStorage();
-
-	Minecraft::main();
-	Minecraft *pMinecraft=Minecraft::GetInstance();
-
-	app.InitGameSettings();
-
-#if 0
-	//bool bDisplayPauseMenu=false;
-
-	// set the default gamma level
-	float fVal=50.0f*327.68f;
-	RenderManager.UpdateGamma((unsigned short)fVal);
-
-	// load any skins
-	//app.AddSkinsToMemoryTextureFiles();
-
-	// set the achievement text for a trial achievement, now we have the string table loaded
-	ProfileManager.SetTrialTextStringTable(app.GetStringTable(),IDS_CONFIRM_OK, IDS_CONFIRM_CANCEL);
-	ProfileManager.SetTrialAwardText(eAwardType_Achievement,IDS_UNLOCK_TITLE,IDS_UNLOCK_ACHIEVEMENT_TEXT);
-	ProfileManager.SetTrialAwardText(eAwardType_GamerPic,IDS_UNLOCK_TITLE,IDS_UNLOCK_GAMERPIC_TEXT);
-	ProfileManager.SetTrialAwardText(eAwardType_AvatarItem,IDS_UNLOCK_TITLE,IDS_UNLOCK_AVATAR_TEXT);
-	ProfileManager.SetTrialAwardText(eAwardType_Theme,IDS_UNLOCK_TITLE,IDS_UNLOCK_THEME_TEXT);
-	ProfileManager.SetUpsellCallback(&app.UpsellReturnedCallback,&app);
-
-	// Set up a debug character press sequence
-#ifndef _FINAL_BUILD
-	app.SetDebugSequence("LRLRYYY");
-#endif
-
-	// Initialise the social networking manager.
-	CSocialManager::Instance()->Initialise();
-
-	// Update the base scene quick selects now that the minecraft class exists
-	//CXuiSceneBase::UpdateScreenSettings(0);
-#endif
-	app.InitialiseTips();
-#if 0
-
-	DWORD initData=0;
-
-#ifndef _FINAL_BUILD
-#ifndef _DEBUG
-#pragma message(__LOC__"Need to define the _FINAL_BUILD before submission")
-#endif
-#endif
-
-	// Set the default sound levels
-	pMinecraft->options->set(Options::Option::MUSIC,1.0f);
-	pMinecraft->options->set(Options::Option::SOUND,1.0f);
-
-	app.NavigateToScene(XUSER_INDEX_ANY,eUIScene_Intro,&initData);
-#endif
-
-	// Set the default sound levels
-	pMinecraft->options->set(Options::Option::MUSIC,1.0f);
-	pMinecraft->options->set(Options::Option::SOUND,1.0f);
-
 	//app.TemporaryCreateGameStart();
 
 	//Sleep(10000);
@@ -1088,7 +1282,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();
@@ -1214,12 +1408,68 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 			}
 		}
 
-		// F11 toggles fullscreen
+		// F1 toggles the HUD
+		if (KMInput.IsKeyPressed(VK_F1))
+		{
+			int primaryPad = ProfileManager.GetPrimaryPad();
+			unsigned char displayHud = app.GetGameSettings(primaryPad, eGameSetting_DisplayHUD);
+			app.SetGameSettings(primaryPad, eGameSetting_DisplayHUD, displayHud ? 0 : 1);
+			app.SetGameSettings(primaryPad, eGameSetting_DisplayHand, displayHud ? 0 : 1);
+		}
+
+		// F3 toggles onscreen debug info
+		if (KMInput.IsKeyPressed(VK_F3))
+		{
+			if (Minecraft* pMinecraft = Minecraft::GetInstance())
+			{
+				if (pMinecraft->options)
+				{
+					pMinecraft->options->renderDebug = !pMinecraft->options->renderDebug;
+				}
+			}
+		}
+
+#ifdef _DEBUG_MENUS_ENABLED
+		// F4 Open debug overlay
+        if (KMInput.IsKeyPressed(VK_F4))
+        {
+            if (Minecraft *pMinecraft = Minecraft::GetInstance())
+            {
+                if (pMinecraft->options &&
+                    app.GetGameStarted() && !ui.GetMenuDisplayed(0) && pMinecraft->screen == NULL)
+                {
+                    ui.NavigateToScene(0, eUIScene_DebugOverlay, NULL, eUILayer_Debug);
+                }
+            }
+        }
+
+        // F6 Open debug console
+        if (KMInput.IsKeyPressed(VK_F6))
+        {
+        	static bool s_debugConsole = false;
+        	s_debugConsole = !s_debugConsole;
+        	ui.ShowUIDebugConsole(s_debugConsole);
+        }
+#endif
+
+		// F11 Toggle fullscreen
 		if (KMInput.IsKeyPressed(VK_F11))
 		{
 			ToggleFullscreen();
 		}
 
+		// TAB opens game info menu. - Vvis :3 - Updated by detectiveren
+		if (KMInput.IsKeyPressed(VK_TAB) && !ui.GetMenuDisplayed(0))
+		{
+			if (Minecraft* pMinecraft = Minecraft::GetInstance())
+			{
+				{
+					ui.NavigateToScene(0, eUIScene_InGameInfoMenu);
+
+				}
+			}
+		}
+
 #if 0
 		// has the game defined profile data been changed (by a profile load)
 		if(app.uiGameDefinedDataChangedBitmask!=0)
@@ -1506,4 +1756,4 @@ void MemPixStuff()
 	PIXAddNamedCounter(((float)allSectsTotal)/(4096.0f),"MemSect total pages");
 }
 
-#endif
\ No newline at end of file
+#endif