Overlay.cpp

#include "stdafx.h"
#include "Overlay.h"
#include <iostream>
#include "Globals.h"
#include "Utility.h"

Overlay::Overlay() {};

WPARAM Overlay::Loop() {
	MSG message;
	RECT rect;

	while (TRUE) {
		ZeroMemory(&message, sizeof(MSG));

		if (PeekMessage(&message, NULL, 0, 0, PM_REMOVE)) {
			TranslateMessage(&message);
			DispatchMessage(&message);
		}

		if (message.message == WM_QUIT) {
			exit(0);
		}

		tWindow = NULL;
		tWindow = FindWindow(NULL, L"Rainbow Six");
		if (!tWindow) {
			std::cout << "uygulama kapatılıyor, gerekli pencere modunda ayarlanmadı!" << std::endl;
			ExitProcess(0);
		}

		ZeroMemory(&rect, sizeof(RECT));

		GetWindowRect(tWindow, &rect);
		ScreenWidth = rect.right - rect.left;
		ScreenHeight = rect.bottom - rect.top;

		MoveWindow(hWindow, rect.left, rect.top, ScreenWidth, ScreenHeight, true);

		HWND hWindow2 = GetForegroundWindow();
		HWND hWindow3 = GetWindow(hWindow2, GW_HWNDPREV);

		SetWindowPos(hWindow, hWindow3, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);

		UpdateWindow(hWindow);

		Render();

		Sleep(5);
	}
	return message.wParam;
}

void Overlay::Render() {
	d3dev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0);
	d3dev->BeginScene();

	ESP();

	d3dev->EndScene();
	d3dev->Present(NULL, NULL, NULL, NULL);
}

void Overlay::ESP() {
	
	Global::Memory.UpdateAddresses();

	
	DWORD boxColor = D3DCOLOR_ARGB(255, 255, 255, 255); 
	DWORD headCircleColor = D3DCOLOR_ARGB(255, 62, 229, 65); 
	DWORD healthBarColor = D3DCOLOR_ARGB(255, 240, 96, 96); 
	DWORD nameColor = D3DCOLOR_ARGB(255, 250, 190, 253); 
	DWORD blackColor = D3DCOLOR_ARGB(255, 0, 0, 0); 

	
	DWORD_PTR LocalEntity = Global::Memory.GetLocalEntity();

	
	PlayerInfo LocalPlayer = Global::Memory.GetAllEntityInfo(LocalEntity);

	
	for (int i = 0; i < 12; i++) {

		
		DWORD_PTR Entity = Global::Memory.GetEntity(i);

		
		PlayerInfo Player = Global::Memory.GetAllEntityInfo(Entity);

		
		if (Player.Health > 0 
			&& Player.Health <= 200 
			&& Player.w2s.z >= 1.0f 
			&& Player.w2sHead.z >= 1.0f 
			&& !Player.Name.empty() 
			&& Player.TeamId != LocalPlayer.TeamId)
		{

			
			float BoxHeight1 = Player.w2s.y - Player.w2sHead.y;
			float BoxHeight2 = std::abs(Player.w2s.x - Player.w2sHead.x);
			float BoxHeight = (BoxHeight1 > BoxHeight2) ? BoxHeight1 : BoxHeight2;
			float BoxWidth = BoxHeight / 1.15f;

			
			Global::Over.DrawBox(Player.w2sHead.x - (BoxWidth / 2) - 1, Player.w2sHead.y - (BoxHeight / 5) - 1, BoxWidth + 2, BoxHeight + 12, blackColor);
			Global::Over.DrawBox(Player.w2sHead.x - (BoxWidth / 2), Player.w2sHead.y - (BoxHeight / 5), BoxWidth, BoxHeight + 10, boxColor);

			
			Global::Over.DrawCircle(Player.w2sHead.x, Player.w2sHead.y - 3, BoxHeight / 10, 20, headCircleColor);

			
			float CurrentHealth = Player.Health / 120.0f;
			if (CurrentHealth < 0 || CurrentHealth >= 1) CurrentHealth = 1;

			
			Global::Over.FillArea(Player.w2sHead.x - (BoxWidth / 2) - 6 - 1, Player.w2sHead.y - (BoxHeight / 5) - 1, 5, BoxHeight + 10 + 2, blackColor);
			Global::Over.FillArea(Player.w2sHead.x - (BoxWidth / 2) - 6, Player.w2sHead.y - (BoxHeight / 5), 3, (BoxHeight + 10) * CurrentHealth, healthBarColor);

			
			Global::Over.DrawString(Player.w2sHead.x - (BoxWidth / 2), (Player.w2sHead.y - (BoxHeight / 5)) + BoxHeight + 10, blackColor, Global::Over.d3Font, "[%s]", Player.Name);
			Global::Over.DrawString(Player.w2sHead.x - (BoxWidth / 2) - 1, (Player.w2sHead.y - (BoxHeight / 5)) + BoxHeight + 10 - 1, nameColor, Global::Over.d3Font, "[%s]", Player.Name);

		}

	}
}

void Overlay::InitD3D(HWND handleWindow) {
	
	d3 = Direct3DCreate9(D3D_SDK_VERSION);

	D3DPRESENT_PARAMETERS direct3DPresetParams;

	ZeroMemory(&direct3DPresetParams, sizeof(direct3DPresetParams));

	direct3DPresetParams.Windowed = true;
	direct3DPresetParams.SwapEffect = D3DSWAPEFFECT_DISCARD;
	direct3DPresetParams.hDeviceWindow = handleWindow;
	direct3DPresetParams.BackBufferFormat = D3DFMT_A8R8G8B8;
	direct3DPresetParams.BackBufferWidth = ScreenWidth;
	direct3DPresetParams.BackBufferHeight = ScreenHeight;

	direct3DPresetParams.EnableAutoDepthStencil = TRUE;
	direct3DPresetParams.AutoDepthStencilFormat = D3DFMT_D16;


	d3->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, handleWindow, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &direct3DPresetParams, &d3dev);
	D3DXCreateFontA(d3dev, 13, 0, FW_HEAVY, 1, 0, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, ANTIALIASED_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Arial", &d3Font);

	D3DXCreateLine(d3dev, &d3Line);
}

void Overlay::DrawCircle(int X, int Y, int radius, int numSides, DWORD color) {
	D3DXVECTOR2 Line[128];
	float Step = M_PI * 2.0 / numSides;
	int Count = 0;
	for (float a = 0; a < M_PI*2.0; a += Step)
	{
		float X1 = radius * cos(a) + X;
		float Y1 = radius * sin(a) + Y;
		float X2 = radius * cos(a + Step) + X;
		float Y2 = radius * sin(a + Step) + Y;
		Line[Count].x = X1;
		Line[Count].y = Y1;
		Line[Count + 1].x = X2;
		Line[Count + 1].y = Y2;
		Count += 2;
	}
	d3Line->Draw(Line, Count, color);
}

void Overlay::FillArea(float x, float y, float width, float height, D3DCOLOR color) {
	D3DXVECTOR2 vectorLine[2];
	d3Line->SetWidth(width);

	vectorLine[0].x = x + width / 2;
	vectorLine[0].y = y;
	vectorLine[1].x = x + width / 2;
	vectorLine[1].y = y + height;

	d3Line->Draw(vectorLine, 2, color);
}

void Overlay::FillRectangle(double x, double y, double w, double h, D3DCOLOR color)
{
	struct Vertex
	{
		float x, y, z, h;
		D3DCOLOR color;
	};

	Vertex vertices[4] =
	{
		x,  y, 0.0f, 1.0f, color,
		x + w, y, 0.0f, 1.0f, color,

		x + w, y + h, 0.0f, 1.0f, color,
		x,  y + h, 0.0f, 1.0f, color,
	};

	d3dev->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
	d3dev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
	d3dev->SetFVF(D3DFVF_XYZRHW | D3DFVF_DIFFUSE);
	d3dev->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, vertices, sizeof(Vertex));
}

void Overlay::DrawBox(float x, float y, float width, float height, D3DCOLOR color) {
	D3DXVECTOR2 points[5];
	points[0] = D3DXVECTOR2(x, y);
	points[1] = D3DXVECTOR2(x + width, y);
	points[2] = D3DXVECTOR2(x + width, y + height);
	points[3] = D3DXVECTOR2(x, y + height);
	points[4] = D3DXVECTOR2(x, y);
	d3Line->SetWidth(1);
	d3Line->Draw(points, 5, color);
}

void Overlay::DrawString(int x, int y, DWORD color, LPD3DXFONT g_pFont, const char *fmt, ...)
{
	char buf[1024] = { 0 };
	va_list va_alist;
	RECT FontPos = { x, y, x + 120, y + 16 };
	va_start(va_alist, fmt);
	vsprintf_s(buf, fmt, va_alist);
	va_end(va_alist);
	g_pFont->DrawTextA(NULL, buf, -1, &FontPos, DT_NOCLIP, color);
}

LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
	case WM_PAINT:
		Global::Over.Render();
		break;
	case WM_CREATE:
		DwmExtendFrameIntoClientArea(hWnd, &Global::Over.margins);
		break;

	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;
	}

	return DefWindowProc(hWnd, message, wParam, lParam);
}

void Overlay::SetupWindow() {

	RECT rect;

	while (!tWindow) {
		tWindow = FindWindow(NULL, L"Rainbow Six");
	}

	if (tWindow != NULL) {
		GetWindowRect(tWindow, &rect);
	}
	else {
		std::cout << "uygulama gerekli pencere modunda başatılmadı, uygulama kapatılıyor... Hata kodu: " << GetLastError() << std::endl;
		Sleep(3000);
		ExitProcess(0);
	}

	WNDCLASSEX windowClass;

	ZeroMemory(&windowClass, sizeof(WNDCLASSEX));

	windowClass.cbSize = sizeof(WNDCLASSEX);
	windowClass.style = CS_HREDRAW | CS_VREDRAW;
	windowClass.lpfnWndProc = WindowProc;
	windowClass.hInstance = GetModuleHandle(0);
	windowClass.hCursor = LoadCursor(NULL, IDC_ARROW);
	windowClass.hbrBackground = (HBRUSH)RGB(0, 0, 0);
	windowClass.lpszClassName = L"Overlay";

	RegisterClassEx(&windowClass);

	hWindow = CreateWindowEx(WS_EX_LAYERED | WS_EX_TRANSPARENT, windowClass.lpszClassName, L"", WS_POPUP, rect.left, rect.top, ScreenWidth, ScreenHeight, NULL, NULL, windowClass.hInstance, NULL);

	SetLayeredWindowAttributes(hWindow, RGB(0, 0, 0), 0, ULW_COLORKEY);
	SetLayeredWindowAttributes(hWindow, 0, 255, LWA_ALPHA);

	ShowWindow(hWindow, SW_SHOW);
	InitD3D(hWindow);
}