Korvayne Runtime SDK reference

Integration modes

Package layout

sdk/include/anticheat.h     Public C API
sdk/bin/anticheat.dll       Runtime DLL and drop-in entry
sdk/lib/anticheat.lib       MSVC import library
sdk/anticheat.ini.example   Example config
backend-kit/                Schemas and endpoint examples
samples/ue5/                Unreal wrapper
samples/unity/              Unity wrapper
tools/KorvayneConfigurator  Config UI
tools/KorvayneDropper       File placement helper

Lifecycle

AC_Init verifies the license, adopts the callback and flags, then starts the background sensor threads. It is idempotent and safe to call early.

ac_config cfg = {0};
cfg.cb = OnKorvayneDetection;
cfg.user = MyContext;
cfg.scan_interval_ms = 500;
cfg.flags = AC_FLAG_VALUEGUARD_RESTORE;
cfg.license = NULL; // load anticheat.lic next to the game executable

int rc = AC_Init(&cfg);

Detection callback

The callback runs on an SDK background thread, not your game thread. Keep it cheap and thread-safe.

typedef void (*ac_detection_cb)(const ac_detection* det, void* user);

typedef struct {
    const char* sensor;
    ac_severity severity;
    float confidence;
    const char* message;
    unsigned long long detail;
} ac_detection;

• Copy strings if you need to keep them. Pointers are valid only during the callback.
• Do not perform file or network I/O directly inside the callback.
• Do not call AC_* functions from inside the callback.
• Queue evidence to your game thread or telemetry worker.

Runtime context

Context setters copy non-secret game/session data used by telemetry and access checks. Set them after login or session creation, and rotate the telemetry token when your backend issues a new one.

The backend JSON contract is documented in Telemetry event payload, including required fields, optional fields, and schema files.

ValueGuard API

ValueGuard protects stable 4-byte values owned by the game. Legitimate writes should go through the write-through setter so the runtime value and shadow value stay in sync.

AC_GuardFloat("player.health", &CurrentHP);
AC_SetGuardedFloat(&CurrentHP, NewHP);
AC_UnguardFloat(&CurrentHP);

SaveGame API

SaveGame protection wraps serialized save bytes with a signed envelope before writing and verifies that envelope before loading. The game owns serialization and recovery behavior.

const char* ctx = "player=studio-123;slot=campaign-1;schema=2";
int rc = AC_ProtectSaveFile("profile.ksave", saveBytes, saveLen, ctx);

unsigned outLen = 0;
unsigned char out[1024 * 1024];
int rc = AC_VerifySaveFile("profile.ksave", ctx, out, sizeof(out), &outLen);
if (rc == AC_SAVE_OK) {
    Deserialize(out, outLen);
}

See SaveGame protection for context-binding, config, Unity, Unreal, and telemetry guidance.

Behavior API

Behavior reports are optional cooperative signals. Drop-in mode cannot know where a player aimed, when a target became visible, or whether a shot had line of sight. The SDK does not read mouse input, target positions, or visibility state by itself. The game must send that context after a local human player's shot.

AC_ReportAim(
    aimSpeedPerMs,
    reactionMs,
    hadLineOfSight ? 1 : 0,
    hit ? 1 : 0
);

How to produce the values

1. Call it once per resolved shot, not every frame.
2. Only report the local human player. Do not report bots, remote replicated players, spectators, or replay playback.
3. Start with behavior_response = report until normal gameplay has been observed.
4. Correlate behavior events with server-side match data before strong punishment.

What the runtime checks

The built-in checks are intentionally simple advisory heuristics, not automatic full-match aim analysis. They only run when the game calls AC_ReportAim.

Telemetry categorizes those events as aim_behavior, controlled by [TelemetryEvents] aim_behavior and [Enforcement] behavior_response. Keep them report-only until the studio has compared the events with normal gameplay and server-side match data.

Engine wrappers

Unreal and Unity teams should normally use wrapper code instead of calling raw C exports directly from gameplay scripts.

• Unreal: startup plugin/module loads the DLL and exposes Blueprint-friendly nodes.
• Unity: KorvayneManager, KorvayneProtectedFloat, and KorvayneProtectedInt wrap native calls safely.

Return codes and flags