cs2-external-esp

Detection and Safety

• Detection Status: The project is intended for single-player use. While no ban reports have been raised for other modes, use it at your own risk.
• Anti-Virus Alerts: The software may be flagged by anti-virus programs because it accesses the memory of other processes. To ensure safety, it is encouraged to read the source code and build the project yourself using the Developer Instructions.

License

This project is licensed under CC BY-NC 4.0. You may share and adapt the material provided you give appropriate attribution and do not use it for commercial purposes.

To build the project manually using Visual Studio, follow these steps:

1. Clone the repository with submodules: It is critical to use the --recursive flag to ensure all dependencies are included.

   git clone --recursive https://github.com/IMXNOOBX/cs2-external-esp

   Note: If you have already cloned the repository without submodules, run: git submodule update --init --recursive

2. Compile with Visual Studio:

   • Open the project in Visual Studio 2022 (or later).
   • Set the build configuration to x64 - Release.

3. Locate the binary: The compiled executable will be located in the <arch>/<configuration> directory, for example: x64/Release.

To use the application, follow these steps:

1. Download the latest release from the Releases tab or build it from source.
2. Launch Counter-Strike 2.
3. Launch cs2-external-esp.exe.

Requirements & Troubleshooting:

• Display Mode: Ensure your game is set to full screen windowed mode.
• Missing Dependencies: If the application crashes on startup, install the latest Windows Visual C++ redistributables.
  • 64-bit Windows (recommended for most modern systems)
  • 32-bit Windows

The menu system is organized into three primary tabs, each identified by a Tab enum value. These tabs are used to categorize different ESP and game settings:

• Tab::PLAYER: Player-related settings.
• Tab::WORLD: World-related settings.
• Tab::SETTINGS: General application settings.

Each tab is associated with a human-readable label and an icon from the Icons asset library.

enum Tab {
    PLAYER,
    WORLD,
    SETTINGS
};

static const TabItem tabs[] =
{
    { Tab::PLAYER,      "Player",   Icons::PERSON },
    { Tab::WORLD,       "World",    Icons::GLOBE },
    { Tab::SETTINGS,    "Settings", Icons::SETTINGS }
};

The WindowAffinity enum defines how the window interacts with system capture and visibility:

• WindowAffinity::Disabled: Standard window behavior.
• WindowAffinity::Black: Renders the window as a black box in screen captures (useful for preventing screenshots/recordings from seeing the ESP).
• WindowAffinity::Invisible: Makes the window invisible to capture software.

// Example: Setting the window to be black in screenshots
Window::SetAffinity(Window::hwnd, WindowAffinity::Black);

The application uses two specific font files for its visual assets:

• icons.sfd: Contains all menu and UI icons used throughout the application.
• weapons.sfd: Contains all in-game weapon icons.

The Updater class provides a static interface for initializing and processing software updates. It checks the current version against a remote status JSON located at https://github.com/IMXNOOBX/cs2-external-esp/raw/refs/heads/main/.github/status.json to determine if the software is safe to use or requires an update.

To use the updater, call Updater::Init() to set up the connection and Updater::Process() to execute the update logic. You can check the current update state using Updater::GetStatus().

// Initialize the updater
if (Updater::Init()) {
    // Process updates/status
    Updater::Process();

    // Check the current status
    Status currentStatus = Updater::GetStatus();
    if (currentStatus.unsafe) {
        // Handle unsafe version or notice
    }
}

The Config class provides a singleton interface for managing application settings via JSON. It handles reading from and writing to the configuration storage. Use Config::Read() to load settings into the application and Config::Write() to persist current settings to disk. Access the active configuration instance using Config::GetInstance().

// Loading configuration
if (Config::Read()) {
    // Configuration loaded successfully
}

// Accessing the singleton instance
Config& config = Config::GetInstance();

// Saving configuration changes
Config::Write();

Once initialized, you can retrieve handles to the game process and its core modules using the following static methods:

• GetProcess(): Returns a std::shared_ptr<pProcess> representing the game process.
• GetClient(): Returns a ProcessModule for the game's client module (e.g., client.dll).
• GetEngine(): Returns a ProcessModule for the game's engine module (e.g., engine2.dll).

auto process = Engine::GetProcess();
auto clientModule = Engine::GetClient();
auto engineModule = Engine::GetEngine();