### External Cheat Setup in C++

Source: https://github.com/kiocode/xenon-cheats/blob/main/README.md

Provides a basic example of how to set up an external cheat using the Xenon framework. This involves initializing the builder and specifying that it's an external cheat.

```cpp
#include <windows.h>
#include <xenon/xenon.hpp>

int main() {
    Builder builder("External Cheat Example");
    builder.xenon->g_pSystem->IsInternal(false);
    // ... (setup configurations and features)
    Cheat cheat = builder.Build();
    cheat.Run();
    return 0;
}
```

--------------------------------

### Unity Integration with IL2CPP Resolver

Source: https://github.com/kiocode/xenon-cheats/blob/main/README.md

Example of adapting Xenon for Unity games, including initialization of the IL2CPP Resolver for improved target acquisition and crash avoidance. This snippet demonstrates setting Unity-specific parameters and running the cheat.

```cpp
pSystem->IsUnityEngine(true);
// Unity-specific memory reading/writing logic goes here.
//..
Cheat cheat = builder.Build();
cheat.Run();

if (IL2CPP::Initialize(true)) {
  spdlog::info("Il2Cpp initialize success.");
}
else {
  spdlog::error("Il2Cpp initialize failed.");
  Sleep(300);
  exit(0);
}
if (!cheat.FetchSDK()) return FALSE;
```

--------------------------------

### External Cheat Example for 2D Games

Source: https://github.com/kiocode/xenon-cheats/blob/main/README.md

A C++ example demonstrating how to create an external cheat for a 2D game using Xenon. It covers attaching to a game process, reading memory addresses, and setting up game dimension configurations.

```cpp
#include <windows.h>
#include <xenon/xenon.hpp>

int main() {
    Builder builder("External Cheat Example");
    builder.xenon->g_pSystem->IsInternal(false);
    builder.SetConsoleEnabled();
    builder.SetInfoLogLevel();

    builder.xenon->g_pSystem->SetGameDimension(GameDimension::DIM_2D);

    builder.xenon->g_cMemoryService->AttachGame("Your\\Game\\Path.exe");
    uintptr_t serverAddr = builder.xenon->g_cMemoryService->ReadPointer(offsets.staticServerAddr);
    uintptr_t clientAddr = builder.xenon->g_cMemoryService->ReadPointer(offsets.staticClientAddr);

    if (!serverAddr || !clientAddr) {
        spdlog::error("Failed to find server or client address");
        return 1;
    }

    builder.GameManager->OnEvent("Update", [builder]() {
        // Update game variables and targets
    });

    Cheat cheat = builder.Build();
    cheat.UseUICustom();
    cheat.UseUIMenu();
    cheat.Run();

    return 0;
}
```

--------------------------------

### Internal Cheat Setup in C++

Source: https://github.com/kiocode/xenon-cheats/blob/main/README.md

Demonstrates the basic structure for an internal cheat using the Xenon framework. It involves setting up a main thread for cheat logic and using DLL injection via DllMain.

```cpp
#include <Windows.h>
#include "basic_ue.hpp"
#include <xenon/xenon.hpp>

DWORD WINAPI MainThread(LPVOID lpReserved) {
    Builder builder("Internal Cheat Example");
    std::shared_ptr<GameVariables> pGameVariables = builder.xenonConfig->g_pGameVariables;
    // ... (setup configurations and features)
    Cheat cheat = builder.Build();
    cheat.Run();
    return TRUE;
}

BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
    if (ul_reason_for_call == DLL_PROCESS_ATTACH) {
        CreateThread(nullptr, 0, MainThread, hModule, 0, nullptr);
    }
    return TRUE;
}
```

--------------------------------

### Xenon Configuration and Customization Examples

Source: https://github.com/kiocode/xenon-cheats/blob/main/README.md

Illustrative C++ snippets showcasing Xenon's customization capabilities. This includes modifying Aimbot and UI configurations, such as setting distance scales and adding UI elements like sliders.

```cpp
std::shared_ptr<AimConfig> pAimConfig = builder.xenonConfig->g_pAimConfig;
pAimConfig->m_fDistanceScale = 0.06f;
pAimConfig->m_nLimitDistance = 100000;

std::shared_ptr<UIConfig> pUIConfig = builder.xenonConfig->g_pUIConfig;
pUIConfig->m_qActions->AddSlider("Distance Scale", &pAimConfig->m_fDistanceScale, 0.001, 2);
```

--------------------------------

### Internal Cheat Example for Unreal Engine 4

Source: https://github.com/kiocode/xenon-cheats/blob/main/README.md

A C++ example of an internal cheat for an Unreal Engine game using Xenon. It demonstrates setting up game-specific configurations like engine version, dimension, rendering type, and event handling for game updates.

```cpp
#include <Windows.h>
#include <xenon/xenon.hpp>

DWORD WINAPI MainThread(LPVOID lpReserved) {
    Builder builder("Internal Cheat Example");
    std::shared_ptr<GameVariables> pGameVariables = builder.xenonConfig->g_pGameVariables;
    std::shared_ptr<EspConfig> pEspConfig = builder.xenonConfig->g_pEspConfig;

    pSystem->IsInternal(true);
    pSystem->IsUnrealEngine(UnrealEngineVersion::UE4); // check your game
    pSystem->SetGameDimension(GameDimension::DIM_3D);
    pSystem->SetRenderingType(RenderingType::DX11); 

    builder.SetInfoLogLevel();
    builder.SetConsoleEnabled();

    pEspConfig->m_nLimitDistance = 10000;
    pEspConfig->m_fHealthBarWidth = 40;

    builder.GameManager->OnEvent("Update", [pGameVariables]() {
        // Update game variables and targets,
	// so there you can get players in any way you need in any game
    });

    Cheat cheat = builder.Build();
    cheat.UseUICustom(RenderingHookType::KIERO);
    cheat.UseUIMenu();
    cheat.Run();

    return TRUE;
}

BOOL APIENTRY DllMain(HMODULE hModule, DWORD dReasonForCall, LPVOID lpReserved)
{
	switch (dReasonForCall)
	{
		case DLL_PROCESS_ATTACH:
			DisableThreadLibraryCalls(hModule);
			CreateThread(nullptr, 0, MainThread, hModule, 0, nullptr);
		case DLL_THREAD_ATTACH:
		case DLL_THREAD_DETACH:
		case DLL_PROCESS_DETACH:
			break;
	}
	return TRUE;
}
```

--------------------------------

### Automatic DLL Injection using Xenon

Source: https://github.com/kiocode/xenon-cheats/blob/main/README.md

Example C++ code demonstrating Xenon's built-in DLL injection functionality. This snippet shows how to open a target game process and inject a specified DLL, with options for launch parameters.

```cpp
#include <spdlog/spdlog.h>
#include <xenon/xenon.hpp>
#include <xenon/components/services/injection_service.hpp>

void Inject(std::string dllPath, std::string exePath, std::string launchOptions) {
    Builder builder("Custom Injector");
    builder.SetDebugLogLevel();

    spdlog::info("Game Path: {}", exePath);
    spdlog::info("DLL Path: {}", dllPath);

    HANDLE hProcess, hThread;
    if (!builder.xenon->g_cInjectionService->OpenGame(&hProcess, &hThread, exePath, launchOptions)) {
        spdlog::error("Failed to open game process.");
        system("pause");
        return;
    }

    builder.xenon->g_cInjectionService->Inject(hProcess, dllPath, InjectionType::LoadLibraryDLL);

    Sleep(3000);
    ResumeThread(hThread);
    CloseHandle(hProcess);
}

int main() {
    // Example usage:
    Inject("E:\\Projects\\xenon\\example-redmatch2-internal\\build\\example-redmatch2-internal.dll", 
           "D:\\Steam\\steamapps\\common\\Redmatch 2\\Redmatch 2.exe", "");

    //Inject("E:\\Projects\\xenon\\example-amongus-internal\\build\\example-amongus-internal.dll", 
    //       "D:\\Among Us\\Among Us.exe", "");

    return 0;
}
```

--------------------------------

### Kanban Board Settings

Source: https://github.com/kiocode/xenon-cheats/blob/main/xenon-docs/Tasks Organization.md

Configuration settings for the kanban board plugin, including board display options, list collapse states, checkbox visibility, and table sizing.

```json
{
  "kanban-plugin":"board",
  "list-collapse":[false,false,false,false],
  "show-checkboxes":true,
  "table-sizing":{
    "card":217
  }
}
```

--------------------------------

### Git Branching and Committing

Source: https://github.com/kiocode/xenon-cheats/blob/main/CONTRIBUTING.md

Standard Git commands for creating a new feature branch, committing changes, and pushing them to a remote repository.

```git
git checkout -b feature-branch
git commit -m "Description of changes"
git push origin feature-branch
```

--------------------------------

### Unreal Engine World-to-Screen Conversion in C++

Source: https://github.com/kiocode/xenon-cheats/blob/main/README.md

Shows how to implement a world-to-screen (W2S) conversion function for Unreal Engine games using Xenon. It utilizes the game's controller to project world coordinates to screen coordinates.

```cpp
pSystem->IsUnrealEngine(UnrealEngineVersion::UE4);
pSystem->m_fnW2S3D = [](Vec3 pos) {
    SDK::FVector2D screenPos;
    SDK::FVector unrealPos(pos.x, pos.z, pos.y);
    if (UE::m_pMyController->ProjectWorldLocationToScreen(unrealPos, &screenPos, false)) {
        return Vec2(screenPos.X, screenPos.Y);
    }
    return Vec2(-99, -99);
};
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.