str1k3r/MCLEClient
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ef7d4658dc802c59f87b303a6e26efde31dfc3bb
MCLEClient/Minecraft.Client/Windows64/Windows64_Launcher.cpp
T
Byte 2bc24119cf restore: discord rpc
2026-07-07 17:17:27 +02:00

548 lines
20 KiB
C++
Raw Blame History

#include "stdafx.h"
#include "Windows64_Launcher.h"
#include "Xbox/resource.h"
#include "../Minecraft.h"
#include "../MultiplayerLocalPlayer.h"
#include "Network/WinsockNetLayer.h"
#include <shlobj.h>
#include <fstream>
#include <string>
#include <vector>
#include <regex>
#include <windows.h>
#include <shellapi.h>
#include <winhttp.h>
#include "./ExtraLibs/discordsdk/discord.h"
#pragma comment(lib, "winhttp.lib")
float g_sleepPercentage = 100;
int g_autosaveInterval = 120;
bool g_doBoatBreak = true;
static const wchar_t* kAuthHost = L"auth.mclegacyedition.xyz";
static std::string g_username = "";
static std::string g_authToken = "";
std::string g_discordUserId = "";
static bool g_offlineMode = false;
static bool g_loadedDedicated = false;
discord::Core* g_discordCore = nullptr;
static bool g_startedCallbackThread = false;
static bool g_startedRPCThread = false;
HWND g_launcherHWND = NULL;
static bool g_shouldContinue = true;
static HWND hBottomBar;
static HWND hStatusText;
static HWND hBtnLaunch;
static HWND hBtnOffline;
static HWND hBtnLogin;
static HWND hBtnRegister;
static HWND hBtnLogout;
static HWND hBtnDiscord;
static HWND hBtnDiscordLogin;
static HWND hUsernameLabel;
static HWND hUsernameEdit;
static HWND hPasswordLabel;
static HWND hPasswordEdit;
static HWND hLoginUsernameLabel;
bool Windows64Launcher::IsInOfflineMode() { return g_offlineMode; }
const std::string& Windows64Launcher::GetAuthenticationToken() { return g_authToken; }
const std::string& Windows64Launcher::GetUsername() { return g_username; }
DWORD WINAPI DiscordCallbackThreadFunc(LPVOID lpParam)
{
auto result = discord::Core::Create(1424889204110004316LL, DiscordCreateFlags_NoRequireDiscord, &g_discordCore);
if (result != discord::Result::Ok || !g_discordCore)
return 1;
while (true)
{
g_discordCore->RunCallbacks();
Sleep(100);
}
return 0;
}
DWORD WINAPI DiscordRPCThreadFunc(LPVOID lpParam)
{
while (!g_discordCore)
Sleep(100);
discord::Activity activity{};
activity.GetTimestamps().SetStart(time(0));
static std::string detailsStr = "Playing as " + Windows64Launcher::GetUsername();
activity.SetDetails(detailsStr.c_str());
activity.GetAssets().SetLargeImage("MCLE");
activity.GetAssets().SetLargeText("MCLE");
g_discordCore->ActivityManager().UpdateActivity(activity, [](discord::Result r) {});
while (true)
{
Minecraft* minecraft = Minecraft::GetInstance();
if (minecraft && minecraft->player)
{
discord::Activity updatedActivity{};
updatedActivity.SetDetails(detailsStr.c_str());
switch (minecraft->player->dimension)
{
case -1:
updatedActivity.GetAssets().SetSmallImage("nether");
updatedActivity.GetAssets().SetSmallText("In The Nether");
break;
case 0:
updatedActivity.GetAssets().SetSmallImage("overworld");
updatedActivity.GetAssets().SetSmallText("In The Overworld");
break;
case 1:
updatedActivity.GetAssets().SetSmallImage("end");
updatedActivity.GetAssets().SetSmallText("In The End");
break;
}
g_discordCore->ActivityManager().UpdateActivity(updatedActivity, [](discord::Result r) {});
}
Sleep(2000);
}
return 0;
}
static std::vector<std::string> SplitString(const std::string& str, char delim)
{
std::vector<std::string> result;
size_t start = 0, end = 0;
while ((end = str.find(delim, start)) != std::string::npos)
{
result.push_back(str.substr(start, end - start));
start = end + 1;
}
result.push_back(str.substr(start));
return result;
}
static bool IsValidUsername(const std::string& s)
{
std::regex p("^[A-Za-z0-9_]+$");
return std::regex_match(s, p);
}
static bool IsValidPassword(const std::string& s)
{
std::regex p("^[A-Za-z0-9%$#@&_]+$");
return std::regex_match(s, p);
}
static std::string GetLauncherFolder()
{
char path[MAX_PATH];
SHGetFolderPathA(NULL, CSIDL_APPDATA, NULL, 0, path);
std::string folder = path;
folder += "\\LCENLauncher";
CreateDirectoryA(folder.c_str(), NULL);
return folder;
}
void Windows64Launcher::SaveAuthenticationData(const std::string& token, const std::string& username)
{
if (g_loadedDedicated) return;
std::string folder = GetLauncherFolder();
std::string file = folder + "\\AccountToken_DoNotShare.dat";
std::ofstream out(file, std::ios::trunc);
out << token << "\n" << username;
out.close();
}
bool Windows64Launcher::GetAuthenticationData(std::string& tokenOut, std::string& usernameOut, bool dedicated)
{
std::ifstream in;
if (dedicated)
{
wchar_t exePath[MAX_PATH] = {};
GetModuleFileNameW(NULL, exePath, MAX_PATH);
wchar_t* lastSlash = wcsrchr(exePath, L'\\');
if (lastSlash) *(lastSlash + 1) = L'\0';
wchar_t filePath[MAX_PATH] = {};
_snwprintf_s(filePath, MAX_PATH, _TRUNCATE, L"%sWindows64\\AccountToken_DoNotShare.dat", exePath);
in.open(filePath);
g_loadedDedicated = true;
}
if (!in.is_open())
{
std::string folder = GetLauncherFolder();
in.open(folder + "\\AccountToken_DoNotShare.dat");
}
if (!in.is_open()) return false;
std::getline(in, tokenOut);
std::getline(in, usernameOut);
in.close();
if (tokenOut.empty()) return false;
return true;
}
bool Windows64Launcher::GetAuthenticationDataAndLoad(bool dedicated)
{
return Windows64Launcher::GetAuthenticationData(g_authToken, g_username, dedicated);
}
int Windows64Launcher::API_GetAccountInfo(const std::string token)
{
std::vector<std::wstring> headers;
std::wstring wtoken(token.begin(), token.end());
headers.push_back(L"Authorization:" + wtoken);
headers.push_back(L"Content-Type: text/plain");
HttpResponse resp = WinsockNetLayer::DoWinHttpRequest(kAuthHost, L"/accountinfo", L"POST", "", headers);
if (resp.status == 0) return -1;
if (resp.status != 200) return 20000 + resp.status;
if (resp.body.find('-') == std::string::npos) return std::stoi(resp.body);
g_username = resp.body.substr(1);
return 0;
}
int Windows64Launcher::API_AttemptAccountRegister(const std::string username, const std::string password, std::string& tokenOut)
{
std::vector<std::wstring> headers;
headers.push_back(L"Content-Type: text/plain");
HttpResponse resp = WinsockNetLayer::DoWinHttpRequest(kAuthHost, L"/register", L"POST", username + ":" + password, headers);
if (resp.status != 200) return 20000 + resp.status;
if (resp.body.find('-') == std::string::npos) return std::stoi(resp.body);
auto parts = SplitString(resp.body.substr(1), ':');
if (parts.size() < 2) return -2;
g_username = parts[0];
g_authToken = parts[1];
tokenOut = g_authToken;
return 0;
}
int Windows64Launcher::API_AttemptAccountLogin(const std::string username, const std::string password, std::string& tokenOut)
{
std::vector<std::wstring> headers;
headers.push_back(L"Content-Type: text/plain");
HttpResponse resp = WinsockNetLayer::DoWinHttpRequest(kAuthHost, L"/login", L"POST", username + ":" + password, headers);
if (resp.status != 200) return 20000 + resp.status;
if (resp.body.find('-') == std::string::npos) return std::stoi(resp.body);
auto parts = SplitString(resp.body.substr(1), ':');
if (parts.size() < 2) return -2;
g_username = parts[0];
g_authToken = parts[1];
tokenOut = g_authToken;
return 0;
}
int Windows64Launcher::API_AttemptDiscordLogin(const std::string& accessToken, std::string& tokenOut)
{
std::vector<std::wstring> headers;
headers.push_back(L"Content-Type: text/plain");
HttpResponse resp = WinsockNetLayer::DoWinHttpRequest(kAuthHost, L"/discordlogin", L"POST", accessToken, headers);
if (resp.status == 0) return -1;
if (resp.status != 200) return 20000 + resp.status;
if (resp.body.find('-') == std::string::npos) return std::stoi(resp.body);
std::string body = resp.body.substr(1);
size_t colon = body.find(':');
if (colon == std::string::npos) return -2;
g_username = body.substr(0, colon);
g_authToken = body.substr(colon + 1);
tokenOut = g_authToken;
return 0;
}
static void ShowLoggedIn()
{
SetWindowTextA(hLoginUsernameLabel, ("Welcome: " + g_username).c_str());
ShowWindow(hBtnLaunch, SW_SHOW);
ShowWindow(hBtnOffline, SW_SHOW);
ShowWindow(hBtnLogout, SW_SHOW);
ShowWindow(hLoginUsernameLabel, SW_SHOW);
ShowWindow(hUsernameLabel, SW_HIDE);
ShowWindow(hUsernameEdit, SW_HIDE);
ShowWindow(hPasswordLabel, SW_HIDE);
ShowWindow(hPasswordEdit, SW_HIDE);
ShowWindow(hBtnLogin, SW_HIDE);
ShowWindow(hBtnRegister, SW_HIDE);
ShowWindow(hBtnDiscordLogin, SW_HIDE);
if (!g_startedRPCThread)
{
HANDLE hThread = CreateThread(NULL, 0, DiscordRPCThreadFunc, NULL, 0, NULL);
CloseHandle(hThread);
g_startedRPCThread = true;
}
}
static void ShowLoggedOut()
{
ShowWindow(hBtnLaunch, SW_HIDE);
ShowWindow(hBtnOffline, SW_HIDE);
ShowWindow(hBtnLogout, SW_HIDE);
ShowWindow(hLoginUsernameLabel, SW_HIDE);
ShowWindow(hUsernameLabel, SW_SHOW);
ShowWindow(hUsernameEdit, SW_SHOW);
ShowWindow(hPasswordLabel, SW_SHOW);
ShowWindow(hPasswordEdit, SW_SHOW);
ShowWindow(hBtnLogin, SW_SHOW);
ShowWindow(hBtnRegister, SW_SHOW);
ShowWindow(hBtnDiscordLogin, SW_SHOW);
}
static void AttemptAutoLogin()
{
std::string token, username;
if (!Windows64Launcher::GetAuthenticationData(token, username))
{
ShowLoggedOut();
return;
}
int result = Windows64Launcher::API_GetAccountInfo(token);
if (result == 0)
{
g_authToken = token;
ShowLoggedIn();
}
else
{
ShowLoggedOut();
MessageBoxW(g_launcherHWND, L"Could not connect to saved account.", L"Login", MB_OK);
}
}
static void DoRegister()
{
char ubuf[32] = {}, pbuf[64] = {};
GetWindowTextA(hUsernameEdit, ubuf, sizeof(ubuf));
GetWindowTextA(hPasswordEdit, pbuf, sizeof(pbuf));
if (!IsValidUsername(ubuf))
{ MessageBoxW(g_launcherHWND, L"Username: letters, numbers and underscores only.", L"Register", MB_OK); return; }
if (!IsValidPassword(pbuf))
{ MessageBoxW(g_launcherHWND, L"Password: letters, numbers and %$#@&_ only.", L"Register", MB_OK); return; }
std::string tokenOut;
int r = Windows64Launcher::API_AttemptAccountRegister(ubuf, pbuf, tokenOut);
if (r == 0)
{
Windows64Launcher::SaveAuthenticationData(g_authToken, g_username);
AttemptAutoLogin();
}
else if (r == 3333) MessageBoxW(g_launcherHWND, L"Username already taken.", L"Register", MB_OK);
else if (r == 7777) MessageBoxW(g_launcherHWND, L"Username contains a banned word.", L"Register", MB_OK);
else if (r == 8888) MessageBoxW(g_launcherHWND, L"That username is banned.", L"Register", MB_OK);
else if (r == 5555) MessageBoxW(g_launcherHWND, L"VPNs are not allowed.", L"Register", MB_OK);
else if (r == 6666) MessageBoxW(g_launcherHWND, L"Too many accounts from this IP.", L"Register", MB_OK);
else MessageBoxW(g_launcherHWND, (L"Registration failed: " + std::to_wstring(r)).c_str(), L"Register", MB_OK);
}
static void DoLogin()
{
char ubuf[32] = {}, pbuf[64] = {};
GetWindowTextA(hUsernameEdit, ubuf, sizeof(ubuf));
GetWindowTextA(hPasswordEdit, pbuf, sizeof(pbuf));
if (!IsValidUsername(ubuf))
{ MessageBoxW(g_launcherHWND, L"Username: letters, numbers and underscores only.", L"Login", MB_OK); return; }
if (!IsValidPassword(pbuf))
{ MessageBoxW(g_launcherHWND, L"Password: letters, numbers and %$#@&_ only.", L"Login", MB_OK); return; }
std::string tokenOut;
int r = Windows64Launcher::API_AttemptAccountLogin(ubuf, pbuf, tokenOut);
if (r == 0)
{
Windows64Launcher::SaveAuthenticationData(g_authToken, g_username);
AttemptAutoLogin();
}
else if (r == 1111 || r == 2222) MessageBoxW(g_launcherHWND, L"Invalid username or password.", L"Login", MB_OK);
else if (r == 2) MessageBoxW(g_launcherHWND, L"You are banned.", L"Login", MB_OK);
else MessageBoxW(g_launcherHWND, (L"Login failed: " + std::to_wstring(r)).c_str(), L"Login", MB_OK);
}
static void DoLogout()
{
Windows64Launcher::SaveAuthenticationData("", g_username);
g_authToken = "";
ShowLoggedOut();
}
static void DoDiscordLogin()
{
if (!g_discordCore)
{
MessageBoxW(g_launcherHWND, L"Discord is not running.", L"Discord Login", MB_OK);
return;
}
g_discordCore->ApplicationManager().GetOAuth2Token([](discord::Result res, discord::OAuth2Token const& token)
{
if (res != discord::Result::Ok)
{
PostMessageA(g_launcherHWND, WM_APP + 2, 0, 0);
return;
}
std::string t = token.GetAccessToken();
PostMessageA(g_launcherHWND, WM_APP + 1, 0, (LPARAM)new std::string(t));
});
}
static LRESULT CALLBACK LauncherWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_CREATE:
{
if (!g_startedCallbackThread)
{
HANDLE hThread = CreateThread(NULL, 0, DiscordCallbackThreadFunc, NULL, 0, NULL);
CloseHandle(hThread);
g_startedCallbackThread = true;
}
hBottomBar = CreateWindowW(L"STATIC", nullptr, WS_CHILD | WS_VISIBLE, 0,0,0,0, hWnd, nullptr, nullptr, nullptr);
hStatusText = CreateWindowW(L"STATIC", L"Launcher v" L"" LAUNCHER_VERSION, WS_CHILD | WS_VISIBLE, 10,10,300,20, hBottomBar, nullptr, nullptr, nullptr);
hBtnLaunch = CreateWindowW(L"BUTTON", L"Launch", WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON, 0,0,80,25, hWnd, (HMENU)1, nullptr, nullptr);
hBtnOffline = CreateWindowW(L"BUTTON", L"Play Offline", WS_CHILD | WS_VISIBLE, 0,0,80,25, hWnd, (HMENU)2, nullptr, nullptr);
hBtnRegister = CreateWindowW(L"BUTTON", L"Register", WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON, 0,0,80,25, hWnd, (HMENU)3, nullptr, nullptr);
hBtnLogin = CreateWindowW(L"BUTTON", L"Login", WS_CHILD | WS_VISIBLE, 0,0,80,25, hWnd, (HMENU)4, nullptr, nullptr);
hBtnLogout = CreateWindowW(L"BUTTON", L"Logout", WS_CHILD | WS_VISIBLE, 0,0,80,25, hWnd, (HMENU)5, nullptr, nullptr);
hBtnDiscord = CreateWindowW(L"BUTTON", L"Discord", WS_CHILD | WS_VISIBLE, 0,0,80,25, hWnd, (HMENU)6, nullptr, nullptr);
hBtnDiscordLogin = CreateWindowW(L"BUTTON", L"Discord Login", WS_CHILD | WS_VISIBLE, 0,0,95,25, hWnd, (HMENU)7, nullptr, nullptr);
hUsernameLabel = CreateWindowW(L"STATIC", L"Username:", WS_CHILD | WS_VISIBLE, 0,0,80,20, hWnd, nullptr, nullptr, nullptr);
hUsernameEdit = CreateWindowW(L"EDIT", L"", WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL, 0,0,180,25, hWnd, nullptr, nullptr, nullptr);
hPasswordLabel = CreateWindowW(L"STATIC", L"Password:", WS_CHILD | WS_VISIBLE, 0,0,80,20, hWnd, nullptr, nullptr, nullptr);
hPasswordEdit = CreateWindowW(L"EDIT", L"", WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL | ES_PASSWORD, 0,0,180,25, hWnd, nullptr, nullptr, nullptr);
hLoginUsernameLabel = CreateWindowW(L"STATIC", L"Welcome:", WS_CHILD | WS_VISIBLE, 0,0,300,20, hWnd, nullptr, nullptr, nullptr);
AttemptAutoLogin();
return 0;
}
case WM_SIZE:
{
int W = LOWORD(lParam), H = HIWORD(lParam);
int inputW = 180, labelW = 80, barH = 50;
int cx = W / 2 - inputW / 2;
int startY = 40;
MoveWindow(hLoginUsernameLabel, 0, 0, 300, 20, TRUE);
MoveWindow(hBtnLogout, 0, 30, labelW, 20, TRUE);
MoveWindow(hBtnDiscord, cx - 5, 125, 75, 20, TRUE);
MoveWindow(hBtnDiscordLogin, cx + 75, 125, 95, 20, TRUE);
MoveWindow(hUsernameLabel, cx - labelW + 50, startY - 5, labelW, 20, TRUE);
MoveWindow(hUsernameEdit, cx + 50, startY - 8, inputW, 25, TRUE);
MoveWindow(hPasswordLabel, cx - labelW + 50, startY + 40, labelW, 20, TRUE);
MoveWindow(hPasswordEdit, cx + 50, startY + 37, inputW, 25, TRUE);
MoveWindow(hBottomBar, 0, H - barH, W, barH, TRUE);
int bY = H - barH + (barH - 25) / 2;
MoveWindow(hBtnLaunch, W - 10 - 80, bY, 80, 25, TRUE);
MoveWindow(hBtnLogin, W - 10 - 80, bY, 80, 25, TRUE);
MoveWindow(hBtnRegister, W - 10*2 - 80*2, bY, 80, 25, TRUE);
MoveWindow(hBtnOffline, W - 10*2 - 80*2, bY, 80, 25, TRUE);
MoveWindow(hStatusText, 10, (barH - 20) / 2, 300, 20, TRUE);
return 0;
}
case WM_APP + 1:
{
std::string* token = reinterpret_cast<std::string*>(lParam);
int r = Windows64Launcher::API_AttemptDiscordLogin(*token, g_authToken);
delete token;
if (r == 0)
{
Windows64Launcher::SaveAuthenticationData(g_authToken, g_username);
AttemptAutoLogin();
}
else if (r == 1111) MessageBoxW(g_launcherHWND, L"Invalid username or password.", L"Discord Login", MB_OK);
else if (r == 2222) MessageBoxW(g_launcherHWND, L"You are banned.", L"Discord Login", MB_OK);
else if (r == 3333) MessageBoxW(g_launcherHWND, L"Invalid OAuth token.", L"Discord Login", MB_OK);
else if (r == 4444) MessageBoxW(g_launcherHWND, L"Discord isn't linked to any account.", L"Discord Login", MB_OK);
else MessageBoxW(g_launcherHWND, (L"Unknown Error: " + std::to_wstring(r)).c_str(), L"Discord Login", MB_OK);
return 0;
}
case WM_APP + 2:
MessageBoxW(hWnd, L"Failed to get Discord token.\nMake sure Discord is open.", L"Discord Login", MB_OK);
return 0;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case 1: g_shouldContinue = true; g_offlineMode = false; DestroyWindow(hWnd); break;
case 2: g_shouldContinue = true; g_offlineMode = true; DestroyWindow(hWnd); break;
case 3: DoRegister(); break;
case 4: DoLogin(); break;
case 5: DoLogout(); break;
case 6: ShellExecuteA(0, 0, "https://discord.gg/mclegacyedition", 0, 0, SW_SHOW); break;
case 7: DoDiscordLogin(); break;
}
return 0;
case WM_CLOSE:
g_shouldContinue = false;
DestroyWindow(hWnd);
return 0;
case WM_DESTROY:
PostQuitMessage(0);
return 0;
default:
return DefWindowProcW(hWnd, msg, wParam, lParam);
}
return 0;
}
void Windows64Launcher::CreateLauncherWindow(HINSTANCE hInstance, std::function<void()> onLaunch)
{
WNDCLASSEXW wcex = {};
wcex.cbSize = sizeof(wcex);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = LauncherWndProc;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIconW(hInstance, L"Minecraft");
wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wcex.lpszClassName = L"LCENLauncherClass";
wcex.hIconSm = LoadIconW(hInstance, L"Minecraft");
RegisterClassExW(&wcex);
RECT wr = {0, 0, 320, 220};
AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
g_launcherHWND = CreateWindowW(L"LCENLauncherClass", L"LCEN Launcher",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0,
wr.right - wr.left, wr.bottom - wr.top,
nullptr, nullptr, hInstance, nullptr);
ShowWindow(g_launcherHWND, SW_SHOW);
UpdateWindow(g_launcherHWND);
MSG msg;
while (GetMessage(&msg, nullptr, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if (g_shouldContinue && onLaunch)
onLaunch();
}
Reference in New Issue View Git Blame Copy Permalink