<ClInclude Include="Classes.h" />

<ClInclude Include="Core.h" />

<ClInclude Include="CustomLoadingScreen.h" />

<ClInclude Include="Engine.h" />

<ClInclude Include="ESP.h" />

<ClInclude Include="Feature.h" />

<ItemGroup>

<ClCompile Include="Core.cpp" />

<ClCompile Include="CustomLoadingScreen.cpp" />

<ClCompile Include="Engine.cpp" />

<ClCompile Include="ESP.cpp" />

<ClCompile Include="Feature.cpp" />

<ClInclude Include="VmtHook.h">

<Filter>Header Files</Filter>

</ClInclude>

</ItemGroup>

<ItemGroup>

<ClCompile Include="imgui\imgui.cpp">

<ClCompile Include="VmtHook.cpp">

<Filter>Source Files</Filter>

</ClCompile>

</ItemGroup>

</Project> \ No newline at end of file

#include "Engine.h"

#include "FeatureManager.h"

#include "Utility.h"

//Features

#include "ResourceInformation.h"

#include "MinimapText.h"

#include "RelicManager.h"

#include "CustomLoadingScreen.h"

Core::Core()

{

FeatureManager* featureManager = FeatureManager::Get();

//Register Features here

FeatureManager::Get()->OnInitialise();

}

ImGui::Text("%s", unit->pUnitData->name);

ImGui::SameLine();

std::string text = std::string("Copy##") + std::string(unit->pUnitData->name) + std::to_string(i);

if (ImGui::Button(text.c_str()))

{

Utility::CopyToClipboard((uint64_t)unit);

}

{

buildingCount++;

}

if (unit->pUnitData->Class == (int16_t)EnumUnitDataClass::Cavalry)

{

calavaryCount++;

}

}

ImGui::Text("Buildings %.d", buildingCount);

{

continue;

}

{

continue;

}

class CustomLoadingScreen : public Feature

{

private:

char* imagePath;

public:

//Supports .gif, .bmp, .jpg, .png

CustomLoadingScreen(char* imagePath);

//Callbacks

}; \ No newline at end of file

void ESP::OnUnitIteration(Unit* unit, Player* player, int playerIndex)

{

if (playerUnitEsp[playerIndex])

{

if (strcmp(unit->pUnitData->name, "FLARE") == 0)

}

if (strcmp(unitName.c_str(), "BOARX") == 0 || strcmp(unitName.c_str(), "RHINO") == 0 ||

{

Renderer::Get()->RenderCircleFilled(ImVec2(screenPos.x, screenPos.y), 20, 0x4000ff00);

Renderer::Get()->RenderText(unitName, ImVec2(screenPos.x, screenPos.y), 16, 0xffffffff);

}

{

Renderer::Get()->RenderCircleFilled(ImVec2(screenPos.x, screenPos.y), 20, 0x4000ffff);

Renderer::Get()->RenderText(unitName, ImVec2(screenPos.x, screenPos.y), 16, 0xffffffff);

Renderer::Get()->RenderText(unitName, ImVec2(screenPos.x, screenPos.y), 16, 0xffffffff);

}

if (strcmp(unitName.c_str(), "WOLFX") == 0 || strcmp(unitName.c_str(), "KOMODO") == 0 ||

strcmp(unitName.c_str(), "GJAGR") == 0 || strcmp(unitName.c_str(), "SLEOPA") == 0 ||

strcmp(unitName.c_str(), "BEAR") == 0 || strcmp(unitName.c_str(), "CROCO") == 0 ||

static uint32_t colors_hex[8];

//Callbacks

void DrawBox(Unit* unit, int32_t color, bool drawName);

void DrawBox(Vector3 position, Vector2 edgeSize, int32_t color);

return instance;

}

{

PathfindingSystem* pathfindingSystem = reinterpret_cast<PathfindingSystem*>(base + Offsets::pathfindingSystem);

if (!pathfindingSystem)

{

return NULL;

return pathfindingSystem->GetWorld();

}

{

return reinterpret_cast<MainScreen*>(base + Offsets::mainScreen);

}

{

return *reinterpret_cast<int32_t*>(base + Offsets::totalPlayers);

}

{

MainScreen* mainScreen = GetMainScreen();

if (!mainScreen)

return world->pPlayerArray;

}

{

MainScreen* mainScreen = GetMainScreen();

static int tileSize = GetWorld()->pMap->GetTileSize();

return Vector2(screenXfinal,screenYfinal);

}

{

return worldToScreen(unit->position);

}

{

return playerColors[colorIndex];

}

{

ImVec4 color;

switch (colorIndex)

return color;

}

{

MainScreen* mainScreen = GetMainScreen();

if (!mainScreen)

return NULL;

}

{

if (!tribePanelInven)

{

return NULL;

{

return *reinterpret_cast<Player**>(tribePanelInven + Offsets::tribePanelInven_localPlayer);

}

} \ No newline at end of file

public:

static Engine* Get();

}; \ No newline at end of file

}

void Feature::OnShutdown()

{

bool enabled = true;

public:

virtual void OnInitialise();

virtual void OnShutdown();

virtual void OnDraw();

return instance;

}

{

static int feature_numer = 0;

printf("Registered feature %d\n", feature_numer++);

}

}

void FeatureManager::OnShutdown()

{

for (Feature* feature : features)

public:

static FeatureManager* Get();

//Callbacks

void OnInitialise();

void OnShutdown();

void OnDraw();

void OnMenuMainWindow();

class MidfunctionHook

{

//bytes overwritten by placing the detour

//location where hook is placed

//runs overwritten instructions

//number of bytes to overwrite (don't cut instructions in half)

public:

static void OverwriteRegister(int64_t rsp, Register reg, int64_t value);

#include "MinimapText.h"

#include "Engine.h"

{

hookEnabled = &enabled;

minimapHook.Hook((BYTE*)(int64_t)GetModuleHandle(NULL) + Offsets::minimapHookOffset, (BYTE*)minimapProxy, 14);

}

class DetourHook64;

class MinimapText : public Feature

{

//Callbacks

}; \ No newline at end of file

{

//48 8D 0D ? ? ? ? 41 B8 ? ? ? ? E8 ? ? ? ? 33 C0 //1

//48 8D 0D ? ? ? ? E8 ? ? ? ? 0F B6 C0 //1

//48 8B 0D ? ? ? ? E8 ? ? ? ? C6 85 //1

//44 89 25 ? ? ? ? 2B //1

//41 8B 45 28 99 + c //1

//48 8B 0D ? ? ? ? 48 85 C9 0F 84 ? ? ? ? 40

int64_t tribePanelInven = 0x2910550;

//48 8B 83 ? ? ? ? 48 8B 48 70 F3 0F 10

int64_t tribePanelInven_localPlayer = 0x208;

//ESP

//48 8B 8B ? ? ? ? E8 ? ? ? ? 48 85 FF

int64_t unit_actionlist = 0x278;

//MinimapText

int64_t minimapHookOffset = 0xBE6F99;

} \ No newline at end of file

extern int64_t pathfindingSystem;

extern int64_t mainScreen;

extern int64_t totalPlayers;

extern int64_t tribePanelInven;

extern int64_t tribePanelInven_localPlayer;

extern int64_t unit_actionlist ;

extern int64_t minimapHookOffset;

} \ No newline at end of file

void RelicManager::OnNeutralUnit(Unit* unit)

{

}

void RelicManager::OnMenuMainWindow()

}

}

ImGui::Separator();

struct Vector3;

class RelicManager : public Feature

{

std::vector<Unit*> relics;

int currentRelic = 0;

//Callbacks

}; \ No newline at end of file

if (center)

{

}

else

{

}

}

RenderLine(points[pointCount - 1], points[0], color, thickness);

}

void Renderer::RenderCircle(const ImVec2& position, float radius, uint32_t color, float thickness, uint32_t segments)

{

ImGuiWindow* window = ImGui::GetCurrentWindow();

window->DrawList->AddRectFilled(from, to, ImGui::GetColorU32({ r / 255.0f, g / 255.0f, b / 255.0f, a / 255.0f }), rounding, roundingCornersFlags);

}

void Renderer::DrawUnitCollisionRectangle(ImVec2 screenPositionCenter, ImVec2 collision, uint32_t color)

{

ImVec2 ivOne = ImVec2(screenPositionCenter.x - collision.x, screenPositionCenter.y - collision.y);

{

private:

static Renderer* _instance;

Renderer();

~Renderer();

ImGui::Text("Food: %.f", player->pResources->food);

ImGui::Text("Gold: %.f", player->pResources->gold);

ImGui::Text("Stone: %.f", player->pResources->stone);

} \ No newline at end of file

class ResourceInformation : public Feature

{

//Callbacks

}; \ No newline at end of file

#include "FeatureManager.h"

#include "VmtHook.h"

#include "main.h" //helper funcs

firstTime = false; //only once

//get device

{

//SwapChain = pSwapChain;

pSwapChain->GetDevice(__uuidof(pDevice), (void**)&pDevice);

pDevice->GetImmediateContext(&pContext);

}

//imgui

DXGI_SWAP_CHAIN_DESC sd;

pSwapChain->GetDesc(&sd);

io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls

window = sd.OutputWindow;

//wndprochandler

OriginalWndProcHandler = (WNDPROC)SetWindowLongPtr(window, GWLP_WNDPROC, (LONG_PTR)hWndProc);

rasterizer_desc.MultisampleEnable = false;

rasterizer_desc.AntialiasedLineEnable = false;

pDevice->CreateRasterizerState(&rasterizer_desc, &DEPTHBIASState_FALSE);

//create normal rasterizer state

D3D11_RASTERIZER_DESC nrasterizer_desc;

ZeroMemory(&nrasterizer_desc, sizeof(nrasterizer_desc));

nrasterizer_desc.MultisampleEnable = false;

nrasterizer_desc.AntialiasedLineEnable = false;

pDevice->CreateRasterizerState(&nrasterizer_desc, &DEPTHBIASState_TRUE);

//load cfg settings

LoadCfg();

}

//create rendertarget

{

//viewport

pContext->RSGetViewports(&vps, &viewport);

ScreenCenterY = viewport.Height / 2.0f;

//get backbuffer

hr = pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backbuffer);

if (FAILED(hr)) {

Log("Failed to get BackBuffer");

}

//create rendertargetview

backbuffer->Release();

if (FAILED(hr)) {

Log("Failed to get RenderTarget");

}

}

else //call before you draw

//imgui

ImGui_ImplWin32_NewFrame();

hDXGIDLL = GetModuleHandleA("dxgi.dll");

Sleep(100);

} while (!hDXGIDLL);

IDXGISwapChain* pSwapChain;

return NULL;

}

pSwapChainVtable = (DWORD_PTR*)pSwapChain;

pSwapChainVtable = (DWORD_PTR*)pSwapChainVtable[0];

VmtHook presentHook = VmtHook((void**)pSwapChainVtable);

presentHook.Hook(8, hookD3D11Present);

while (!(GetAsyncKeyState(VK_F2) & 0x8000)) {

Sleep(10);

}

FeatureManager::Get()->OnShutdown();

presentHook.Unhook();

(WNDPROC)SetWindowLongPtr(window, GWLP_WNDPROC, (LONG_PTR)OriginalWndProcHandler);

}

BOOL __stdcall DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpReserved)

{

case DLL_PROCESS_ATTACH:

DisableThreadLibraryCalls(hModule);

break;

case DLL_PROCESS_DETACH:

OnDllDetach();

break;

}

return TRUE;

} \ No newline at end of file

class VmtHook

{

private:

std::map<int, void*> hookedfuncs;

public: