Chat.cpp

#include "Chat.h"

#include <iostream>

#include "ChatEntryManager.h"
#include "Menu.h"

struct LineVertex
{
	float x, y, z, rhw;
	D3DCOLOR color;
};

#define LINE_FVF (D3DFVF_XYZRHW | D3DFVF_DIFFUSE)

struct Rect
{
	DWORD top, bottom, left, right;
};

uintptr_t SAMPGetAddress(SAMPAddressesType type) {
	static const auto versionIndex = Chat::getSampVersion() - 2;
	static const auto base = Chat::getSampBaseAddress();
	return (base + SAMPAddresses[versionIndex][type]);
}

uintptr_t SAMPGetOffset(SAMPAddressesType type)
{
	static const auto versionIndex = Chat::getSampVersion() - 2;
	return SAMPAddresses[versionIndex][type];
}

void Chat::MainLoop(const decltype(mainLoopHook)& hook)
{
	static bool init = false;
	if (!init && isSampAvailable())
	{
		// Setup hooks
		auto& instance = getInstance();
		SetHook(instance.mChatRenderEntryHook, SAMPGetAddress(SAMP_ADDRESS_CHAT_RENDER_ENTRY), &CChat__RenderEntry);
		// Setup patches
		SetPatch(SAMPGetAddress(SAMP_ADDRESS_COMMAND_SET_PAGESIZE) + 0x2F, { 0x83, 0xFE, 0x40 }); // cmp esi, 0x40
		SetPatch(SAMPGetAddress(SAMP_ADDRESS_COMMAND_SET_PAGESIZE_HINT) + 0xD, { '6', '4' }); // "20" -> "64"

		init = true;
	}
	else if (init)
	{
		// While true

	}

	return hook.get_trampoline()();
}

uintptr_t Chat::getSampBaseAddress()
{
	return reinterpret_cast<uintptr_t>(GetModuleHandleA("samp.dll"));
}

bool Chat::isSampAvailable()
{
	return *reinterpret_cast<uintptr_t*>(0x00C8D4C0) == 9 && getSampBaseAddress() > 0;
}

bool Chat::isGTAMenuActive()
{
	return *reinterpret_cast<uint32_t*>(0xBA67A4) != 0;
}

SampVersion Chat::getSampVersion()
{
	static SampVersion version = SAMP_NOT_LOADED;
	if (version <= SAMP_UNKNOWN)
	{
		const auto base = getSampBaseAddress();
		if (base == 0) return SAMP_NOT_LOADED;

		const auto* ntHeader = reinterpret_cast<IMAGE_NT_HEADERS*>(base + reinterpret_cast<IMAGE_DOS_HEADER*>(base)->e_lfanew);
		static const auto entryPoint = ntHeader->OptionalHeader.AddressOfEntryPoint;
		for (size_t i = 0; i < SAMPEntryPoints.size(); i++)
		{
			const auto& curEntryPoint = SAMPEntryPoints[i];
			
			if (curEntryPoint == entryPoint)
			{
				return static_cast<SampVersion>(i + 2);
			}
		}
	}
	return SAMP_UNKNOWN;
}

HWND Chat::getGameHWND()
{
	static const HWND gameHWND = **reinterpret_cast<HWND**>(0xC17054);
	return gameHWND;
}

ChatEntryManager& Chat::getChatEntryManager()
{
	return getInstance().mChatEntryManager;
}

int Chat::getSampCursorMode()
{
	const auto CGame = *reinterpret_cast<uintptr_t*>(SAMPGetAddress(SAMP_ADDRESS_GLOBAL_GAME_PTR));
	if (!CGame) return 0;

	return *reinterpret_cast<int*>(CGame + SAMPGetOffset(SAMP_OFFSET_GLOBAL_GAME_MOUSEMODE));
}

void Chat::setSampCursorMode(const int nMode)
{
	const auto CGame = *reinterpret_cast<uintptr_t*>(SAMPGetAddress(SAMP_ADDRESS_GLOBAL_GAME_PTR));
	if (!CGame || getSampCursorMode() == nMode) return;

	const auto setCursorModeFunc = reinterpret_cast<dGameSetCursorMode>(SAMPGetAddress(SAMP_ADDRESS_GAME_SET_CURSOR_MODE));
	setCursorModeFunc(reinterpret_cast<void*>(CGame), nMode, 0);
}

float Chat::getSampFontSize()
{
	return static_cast<float>(reinterpret_cast<int(*)()>(SAMPGetAddress(SAMP_ADDRESS_FONTSIZE_VALUE))());
}

float Chat::getSampFontSizeParam()
{
	return (getSampFontSize() - 20) / 2;
}

char* Chat::getSampFontName()
{
	return reinterpret_cast<char* (*)()>(SAMPGetAddress(SAMP_ADDRESS_CHAT_GET_FONTFACE))();
}

std::string Chat::getFontRelativePathByName(const std::string& fontName)
{
	HKEY hKey;
	const char* subKey = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts";
	LONG result = RegOpenKeyExA(HKEY_LOCAL_MACHINE, subKey, 0, KEY_READ, &hKey);

	if (result != ERROR_SUCCESS) return std::string{};

	char value[512];
	DWORD valueLength = sizeof(value);
	const std::string fontRegistryName = fontName + " (TrueType)";

	result = RegQueryValueExA(hKey, fontRegistryName.c_str(), nullptr, nullptr, (LPBYTE)value, &valueLength);

	if (result != ERROR_SUCCESS) {
		RegCloseKey(hKey);
		return std::string{};
	}

	RegCloseKey(hKey);

	std::string fontPath = value;
	return fontPath;
}

void Chat::chatUpdate()
{
	const auto& pChat = getInstance().pChat;
	if (pChat == nullptr) return;

	pChat->m_bRedraw = 1;
	reinterpret_cast<int(__thiscall*)(void*)>(SAMPGetAddress(SAMP_ADDRESS_CHAT_RENDER))(pChat);
}

void Chat::sampDeleteChatLine(const int& id)
{
	const auto& pChat = getInstance().pChat;
	
	for (int i = id; i > 0; --i)
		pChat->m_entry[i] = pChat->m_entry[i - 1];

	pChat->m_entry[0] = CChatEntry();

	getInstance().chatUpdate();
}

void Chat::sampDeleteChatLineAll()
{
	const auto& pChat = getInstance().pChat;
	
	for (auto& entry : pChat->m_entry)
		entry = CChatEntry();

	getInstance().chatUpdate();
}

std::string Chat::convertToUTF8(const std::string& os_str) {
	const UINT os_codepage = GetACP();
	
	const int wchars_num = MultiByteToWideChar(os_codepage, 0, os_str.c_str(), -1, nullptr, 0);
	if (wchars_num == 0) {
		return std::string{};
	}
	std::wstring wstr(wchars_num, 0);
	MultiByteToWideChar(os_codepage, 0, os_str.c_str(), -1, wstr.data(), wchars_num);
	
	const int utf8_chars_num = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, nullptr, 0, nullptr, nullptr);
	if (utf8_chars_num == 0) {
		return std::string{};
	}
	std::string utf8_str(utf8_chars_num, 0);
	WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, utf8_str.data(), utf8_chars_num, nullptr, nullptr);

	return utf8_str;
}

std::string Chat::convertFromUTF8(const std::string& utf8_str) {
	const UINT os_codepage = GetACP();
	
	const int len = MultiByteToWideChar(CP_UTF8, 0, utf8_str.c_str(), -1, nullptr, 0);
	auto* utf16_buffer = new wchar_t[len];
	MultiByteToWideChar(CP_UTF8, 0, utf8_str.c_str(), -1, utf16_buffer, len);
	
	const int os_chars_num = WideCharToMultiByte(os_codepage, 0, utf16_buffer, -1, nullptr, 0, nullptr, nullptr);
	if (os_chars_num == 0) {
		delete[] utf16_buffer;
		return std::string{};
	}
	auto* os_buffer = new char[os_chars_num];
	WideCharToMultiByte(os_codepage, 0, utf16_buffer, -1, os_buffer, os_chars_num, nullptr, nullptr);

	delete[] utf16_buffer;

	std::string result(os_buffer);

	delete[] os_buffer;

	return result;
}

HRESULT __stdcall Chat::OnWndProc(const decltype(mWndProcHook)& hook, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	auto& menu = Menu::getInstance();

	wchar_t wch;
	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, reinterpret_cast<char*>(&wParam), 1, &wch, 1);

	// ImGui key handle
	ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam);

	// Check for mouse move
	if (msg == WM_MOUSEMOVE || msg == WM_RBUTTONDOWN) {
		const auto cursorMode = getInstance().getSampCursorMode();
		auto& mSelectedEntry = getInstance().mSelectedEntry;
		const bool isEdit = menu.IsPopupActive() || menu.IsEditLineActive();

		if (cursorMode >= 2 && cursorMode <= 3) // SAMP Cursor is enabled
		{
			if (!isEdit)
			{
				auto xPos = GET_X_LPARAM(lParam);
				auto yPos = GET_Y_LPARAM(lParam);

				const auto entryId = getChatEntryManager().getEntryIdByScreenCoords(xPos, yPos);
				auto& cchat = Chat::getInstance().pChat;
				if (
					entryId > -1 &&
					cchat->m_entry[entryId].m_textColor != 0
				) {
					mSelectedEntry = entryId;

					if (msg == WM_RBUTTONDOWN) menu.ShowPopup();
				}
				else mSelectedEntry = -1;
			}
		}
		else if (!isEdit) mSelectedEntry = -1;
	}

	// Close editline window by esc/enter + block keys for game
	if (menu.IsEditLineActive())
	{
		if ((msg == WM_CHAR || msg == WM_KEYUP || msg == WM_KEYDOWN) && (wParam == VK_RETURN || wParam == VK_ESCAPE))
		{
			if (msg != WM_KEYUP) return TRUE;
			if (!menu.IsColorPopupActive()) menu.CloseEditLine();
		}
	}

	return hook.call_trampoline(hwnd, msg, wParam, lParam);
}

std::optional<HRESULT> Chat::OnPresent(const decltype(mOnPresentHook)& hook, IDirect3DDevice9* pDevice, const RECT*, const RECT*, HWND, const RGNDATA*) {
	auto& menu = Menu::getInstance();

	if (!menu.imguiInited) {
		ImGui::CreateContext();
		ImGui_ImplWin32_Init(getGameHWND());
		ImGui_ImplDX9_Init(pDevice);

		ImGui_ImplDX9_InvalidateDeviceObjects();
		ImGui_ImplDX9_CreateDeviceObjects();

		Menu::getInstance().RebuildFonts();

		menu.imguiInited = true;
	}

	ImGui_ImplDX9_NewFrame();
	ImGui_ImplWin32_NewFrame();
	ImGui::NewFrame();

	menu.Render();

	ImGui::EndFrame();
	ImGui::Render();
	ImGui_ImplDX9_RenderDrawData(ImGui::GetDrawData());

	return std::nullopt;
}

std::optional<HRESULT> Chat::OnLost(const decltype(mOnResetHook)& hook, IDirect3DDevice9* pDevice, D3DPRESENT_PARAMETERS* parameters) {
	ImGui_ImplDX9_InvalidateDeviceObjects();
	return std::nullopt;
}

void Chat::OnReset(const decltype(mOnResetHook)& hook, HRESULT& return_value, IDirect3DDevice9* pDevice, D3DPRESENT_PARAMETERS* parameters) {
	ImGui_ImplDX9_InvalidateDeviceObjects();
}

void DrawRect(
	IDirect3DDevice9* device,
	float x1, float y1,
	float x2, float y2,
	D3DCOLOR color = D3DCOLOR_ARGB(255, 255, 0, 0))
{
	LineVertex v[8] =
	{
		{ x1, y1, 0.f, 1.f, color }, { x2, y1, 0.f, 1.f, color },
		{ x2, y1, 0.f, 1.f, color }, { x2, y2, 0.f, 1.f, color },
		{ x2, y2, 0.f, 1.f, color }, { x1, y2, 0.f, 1.f, color },
		{ x1, y2, 0.f, 1.f, color }, { x1, y1, 0.f, 1.f, color }
	};

	device->SetFVF(LINE_FVF);
	device->DrawPrimitiveUP(
		D3DPT_LINELIST,
		4,
		v,
		sizeof(LineVertex)
	);
}

void* __fastcall Chat::CChat__Render(const decltype(mChatRenderHook)& hook, void* ptr, void*)
{
	auto chat = reinterpret_cast<CChat*>(ptr);

	int firstLine = max(1, chat->m_pScrollbar->m_nPos);
	int charH = chat->m_nCharHeight;

	auto& manager = Chat::getInstance().getChatEntryManager();
	Chat::getInstance().pChat = chat;
	manager.setChatPointer(chat);

	int maxTextWidth = 445;

	for (int screenIndex = 0; screenIndex < chat->m_nPageSize; ++screenIndex)
	{
		int entryId = firstLine + screenIndex;
		auto& entry = chat->m_entry[entryId];

		auto cfont = chat->m_pFontRenderer->m_pFont;

		using DrawTextFn = int(__stdcall*)(
			void*, void*, const char*, int, RECT*, unsigned int, D3DCOLOR
		);

		auto drawText = reinterpret_cast<DrawTextFn>(cfont->m_lpVtbl[14]);

		RECT rc{};
		drawText(cfont, nullptr, entry.m_szText, -1, &rc, DT_CALCRECT, 0);

		int width = rc.right - rc.left;

		if (chat->m_bTimestamp)
			width += chat->m_nTimestampWidth;

		maxTextWidth = max(maxTextWidth, width);
	}

	int y = 10;

	for (int screenIndex = 0; screenIndex < chat->m_nPageSize; ++screenIndex)
	{
		int entryId = firstLine + screenIndex;

		CRect rect{};
		rect.x1 = 45;
		rect.y1 = y;
		rect.x2 = rect.x1 + maxTextWidth + 5;
		rect.y2 = y + charH + 1;

		manager.push(entryId, screenIndex, rect);

		y += charH + 1;
	}

	return hook.call_trampoline(ptr, nullptr);
}

int __fastcall Chat::CChat__RenderEntry(const decltype(mChatRenderEntryHook)& hook, void* ptr, void*, const char* src, CRect rect, uint32_t color)
{
	static bool init = false;
	if (!init)
	{
		auto& instance = getInstance();
		SetHook(instance.mChatRenderHook, SAMPGetAddress(SAMP_ADDRESS_CHAT_RENDER), &CChat__Render);
		SetHook(instance.mWndProcHook, SAMPGetAddress(SAMP_ADDRESS_CHATINPUT_WNDPROC), &OnWndProc);

		SetHook(instance.mChatAddEntryHook, SAMPGetAddress(SAMP_ADDRESS_CHAT_ADD_ENTRY), &CChat__AddEntry);
		SetHook(instance.mChatRecalcFontSizeHook, SAMPGetAddress(SAMP_ADDRESS_RECALC_FONTSIZE), &CChat__RecalcFontSize);

		instance.mOnPresentHook.before += instance.OnPresent;
		instance.mOnResetHook.before += instance.OnLost;
		instance.mOnResetHook.after += instance.OnReset;

		init = true;
	}
	return hook.call_trampoline(ptr, nullptr, src, rect, color);
}

void __fastcall Chat::CChat__AddEntry(const decltype(mChatAddEntryHook)& hook, void* ptr, void*, int nType, const char* szText, const char* szPrefix, D3DCOLOR textColor, D3DCOLOR prefixColor)
{
	auto& mSelected = getInstance().mSelectedEntry;
	if (mSelected > -1) mSelected--;

	return hook.call_trampoline(ptr, nullptr, nType, szText, szPrefix, textColor, prefixColor);
}

int __fastcall Chat::CChat__RecalcFontSize(const decltype(mChatRecalcFontSizeHook)& hook, void* ptr, void*)
{
	Menu::getInstance().RebuildFonts();
	return hook.call_trampoline(ptr, nullptr);
}