EOS platform services

Game Instance variable: ReportInProgress (Boolean, false).

Game module dependencies: EIKBlueprints, EIKCore, BetideCore, Engine.

// EosReportsGameInstance.h
#pragma once
#include "Engine/GameInstance.h"
#include "AsyncFunctions/Reports/EIK_SendReport_AsyncFunction.h"
#include "EosReportsGameInstance.generated.h"

UCLASS()
class UEosReportsGameInstance : public UGameInstance
{
    GENERATED_BODY()
  public:
    UFUNCTION(BlueprintCallable)
    void ReportSelectedPlayer(const FString &TargetPuid, EEIKPlayerReportCategory Category,
                              const FString &Message);
    UPROPERTY(BlueprintReadOnly)
    bool ReportInProgress = false;

  private:
    UFUNCTION()
    void ReportSucceeded(const FBetideError &Error);
    UFUNCTION()
    void ReportFailed(const FBetideError &Error);
};

// EosReportsGameInstance.cpp
#include "EosReportsGameInstance.h"
#include "Logging/LogMacros.h"

DEFINE_LOG_CATEGORY_STATIC(LogEosReportExample, Log, All);

void UEosReportsGameInstance::ReportSelectedPlayer(const FString &TargetPuid,
                                                   EEIKPlayerReportCategory Category,
                                                   const FString &Message)
{
    if (ReportInProgress)
    {
        UE_LOG(LogEosReportExample, Warning, TEXT("Wait for the current report to finish"));
        return;
    }
    auto *Request = UEIK_SendReport_AsyncFunction::SendEIKPlayerReportAsyncFunction(
        this, 0, TargetPuid, Category, Message, FString());
    Request->Success.AddDynamic(this, &ThisClass::ReportSucceeded);
    Request->Failure.AddDynamic(this, &ThisClass::ReportFailed);
    ReportInProgress = true;
    Request->Activate();
}

void UEosReportsGameInstance::ReportSucceeded(const FBetideError &Error)
{
    ReportInProgress = false;
    UE_LOG(LogEosReportExample, Log, TEXT("Player report submitted"));
}

void UEosReportsGameInstance::ReportFailed(const FBetideError &Error)
{
    ReportInProgress = false;
    UE_LOG(LogEosReportExample, Warning, TEXT("%s"), *Error.Message);
}

Add EIKBlueprints and EIKSDK for these SDK-facing headers.

#include "Engine/GameInstance.h"
#include "Logging/LogMacros.h"
#include "SdkFunctions/SanctionsInterface/EIK_Sanctions_QueryActivePlayerSanctions.h"
#include "SdkFunctions/SanctionsInterface/EIK_Sanctions_CreatePlayerSanctionAppeal.h"
#include "SdkFunctions/SanctionsInterface/EIK_SanctionsSubsystem.h"

DEFINE_LOG_CATEGORY_STATIC(LogEosSanctionExample, Log, All);

void QueryEosSanctions(UGameInstance &GameInstance, FEIK_ProductUserId LocalUserId,
                       FEIK_ProductUserId TargetUserId, const FScriptDelegate &OnComplete)
{
    auto *Request =
        UEIK_Sanctions_QueryActivePlayerSanctions::EIK_Sanctions_QueryActivePlayerSanctions(
            LocalUserId, TargetUserId);
    if (!Request)
        return;
    Request->RegisterWithGameInstance(&GameInstance);
    Request->OnCallback.Add(OnComplete);
    Request->Activate();
}

void ReadQueriedEosSanctions(FEIK_ProductUserId TargetUserId, TEnumAsByte<EEIK_Result> QueryResult)
{
    if (QueryResult != EEIK_Result::EOS_Success)
    {
        UE_LOG(LogEosSanctionExample, Warning, TEXT("Sanctions query failed: %d"),
               int32(QueryResult));
        return;
    }
    const int32 Count = UEIK_SanctionsSubsystem::EIK_Sanctions_GetPlayerSanctionCount(TargetUserId);
    if (Count < 0)
    {
        UE_LOG(LogEosSanctionExample, Warning, TEXT("Unable to read cached sanctions"));
        return;
    }
    for (int32 Index = 0; Index < Count; ++Index)
    {
        FEIK_Sanctions_PlayerSanction Sanction;
        const auto Result = UEIK_SanctionsSubsystem::EIK_Sanctions_CopyPlayerSanctionByIndex(
            TargetUserId, Index, Sanction);
        if (Result != EEIK_Result::EOS_Success)
        {
            UE_LOG(LogEosSanctionExample, Warning, TEXT("Sanction copy failed: %d"), int32(Result));
            continue;
        }
        UE_LOG(LogEosSanctionExample, Log, TEXT("%s | Ref %s | Expires %lld"), *Sanction.Action,
               *Sanction.ReferenceId, Sanction.TimeExpires);
    }
    UE_LOG(LogEosSanctionExample, Log, TEXT("Finished reading %d cached sanctions"), Count);
}

void SubmitEosSanctionAppeal(UGameInstance &GameInstance, FEIK_ProductUserId LocalUserId,
                             const FString &ReferenceId,
                             TEnumAsByte<EEIK_ESanctionAppealReason> Reason,
                             const FScriptDelegate &OnComplete)
{
    auto *Request =
        UEIK_Sanctions_CreatePlayerSanctionAppeal::EIK_Sanctions_CreatePlayerSanctionAppeal(
            LocalUserId, Reason, ReferenceId);
    if (!Request)
        return;
    Request->RegisterWithGameInstance(&GameInstance);
    Request->OnCallback.Add(OnComplete);
    Request->Activate();
}

Bind OnComplete to a UFUNCTION before dispatch. The query handler takes const FEIK_ProductUserId& LocalUserId, const FEIK_ProductUserId& TargetUserId, and const TEnumAsByte<EEIK_Result>& Result; call ReadQueriedEosSanctions(TargetUserId, Result) there. The appeal handler takes only LocalUserId and Result; check for EOS_Success.

Controller variables: ClientProtectionStarted, ServerPlayerRegistered (Boolean). Game Mode variables: SessionBound, SessionRunning (Boolean). All default to false. Keep both graphs together: the Game Mode calls events on the controller class.

EosProtection.h

// Copyright (c) 2026 Betide Studio. All Rights Reserved.
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/PlayerController.h"
#include "GameFramework/GameModeBase.h"
#include "AntiCheat/AntiCheatClient.h"
#include "AntiCheat/AntiCheatServer.h"
#include "EosProtection.generated.h"

UCLASS()
class AEosProtectionController : public APlayerController
{
    GENERATED_BODY()
  public:
    void RegisterAuthenticatedPlayer(const FString &VerifiedPuid,
                                     TEnumAsByte<EUserPlatform> Platform);
    void UnregisterProtectedPlayer();
    UFUNCTION(Client, Reliable) void ClientBeginProtection(const FString &VerifiedPuid);
    UFUNCTION(Client, Reliable) void ClientAntiCheatMessage(const TArray<uint8> &Message);
    UFUNCTION(Server, Reliable) void ServerAntiCheatMessage(const TArray<uint8> &Message);
    UFUNCTION(Server, Reliable) void ServerProtectionFailed();

  protected:
    void EndPlay(const EEndPlayReason::Type Reason) override;

  private:
    UPROPERTY() TObjectPtr<UAntiCheatClient> Client;
    UPROPERTY() TObjectPtr<UAntiCheatServer> Server;
    bool bClientProtectionStarted = false;
    bool bServerPlayerRegistered = false;
    void StopClientProtection();
    UFUNCTION() void SendToServer(const TArray<uint8> &Message);
    UFUNCTION()
    void IntegrityViolated(const FEIK_AntiCheatClientIntegrityViolatedCallbackInfo &Data);
};

UCLASS()
class AEosProtectionGameMode : public AGameModeBase
{
    GENERATED_BODY()
  public:
    AEosProtectionGameMode();
    UFUNCTION(BlueprintCallable) void StartProtection(const FString &ServerName);
    UFUNCTION(BlueprintCallable) void StopProtection();
    UFUNCTION(BlueprintCallable)
    void AdmitAuthenticatedPlayer(APlayerController *Player, const FString &VerifiedPuid,
                                  TEnumAsByte<EUserPlatform> Platform);

  protected:
    void EndPlay(const EEndPlayReason::Type Reason) override;

  private:
    UPROPERTY() TObjectPtr<UAntiCheatServer> Server;
    bool bSessionBound = false;
    bool bSessionRunning = false;
    UFUNCTION()
    void SendToClient(APlayerController *ControllerRef, const TArray<uint8> &ClientData);
    UFUNCTION() void ActionRequired(APlayerController *ControllerRef, bool bRemoveFromSession);
};

EosProtection.cpp

// Copyright (c) 2026 Betide Studio. All Rights Reserved.
#include "EosProtection.h"
#include "Engine/GameInstance.h"
#include "Engine/World.h"
#include "Kismet/GameplayStatics.h"

DEFINE_LOG_CATEGORY_STATIC(LogEosProtection, Log, All);

void AEosProtectionController::RegisterAuthenticatedPlayer(const FString &VerifiedPuid,
                                                           TEnumAsByte<EUserPlatform> Platform)
{
    if (!HasAuthority() || bServerPlayerRegistered)
        return;
    Server = GetGameInstance()->GetSubsystem<UAntiCheatServer>();
    if (!Server)
    {
        ServerProtectionFailed();
        return;
    }
    // Keep startup ahead of protection packets on this controller's reliable channel.
    ClientBeginProtection(VerifiedPuid);
    bServerPlayerRegistered =
        Server->RegisterClientForAntiCheat(VerifiedPuid, this, Platform, EOS_ProtectedClient);
    if (!bServerPlayerRegistered)
        ServerProtectionFailed();
}

void AEosProtectionController::ClientBeginProtection_Implementation(const FString &VerifiedPuid)
{
    if (bClientProtectionStarted)
        return;
    Client = GetGameInstance()->GetSubsystem<UAntiCheatClient>();
    if (!Client)
    {
        ServerProtectionFailed();
        return;
    }
    Client->OnSendMessageToServer.AddUniqueDynamic(this, &ThisClass::SendToServer);
    Client->OnClientIntegrityViolated.AddUniqueDynamic(this, &ThisClass::IntegrityViolated);
    // The wrapper installs notifications before BeginSession, even when BeginSession fails.
    bClientProtectionStarted = true;
    if (!Client->RegisterAntiCheatClient(VerifiedPuid))
    {
        StopClientProtection();
        ServerProtectionFailed();
        return;
    }
    UE_LOG(LogEosProtection, Log, TEXT("Client session started; authentication is still pending"));
}

void AEosProtectionController::SendToServer(const TArray<uint8> &Message)
{
    ServerAntiCheatMessage(Message);
}

void AEosProtectionController::ClientAntiCheatMessage_Implementation(const TArray<uint8> &Message)
{
    if (!bClientProtectionStarted)
        return;
    if (!Client || !Client->RecievedMessageFromServer(Message))
    {
        StopClientProtection();
        ServerProtectionFailed();
    }
}

void AEosProtectionController::ServerAntiCheatMessage_Implementation(const TArray<uint8> &Message)
{
    if (!bServerPlayerRegistered || Message.IsEmpty() || Message.Num() > 512 || !Server ||
        !Server->RecievedMessageFromClient(this, Message))
    {
        ServerProtectionFailed();
    }
}

void AEosProtectionController::IntegrityViolated(
    const FEIK_AntiCheatClientIntegrityViolatedCallbackInfo &Data)
{
    StopClientProtection();
    ServerProtectionFailed();
}

void AEosProtectionController::StopClientProtection()
{
    if (!bClientProtectionStarted)
        return;
    const bool bEnded = Client && Client->UnregisterAntiCheatClient();
    bClientProtectionStarted = false;
    if (Client)
    {
        Client->OnSendMessageToServer.RemoveDynamic(this, &ThisClass::SendToServer);
        Client->OnClientIntegrityViolated.RemoveDynamic(this, &ThisClass::IntegrityViolated);
    }
    if (!bEnded)
        UE_LOG(LogEosProtection, Error, TEXT("Client protection cleanup failed"));
}

void AEosProtectionController::UnregisterProtectedPlayer()
{
    if (!HasAuthority() || !bServerPlayerRegistered)
        return;
    const bool bRemoved = Server && Server->UnregisterClientFromAntiCheat(this);
    bServerPlayerRegistered = false;
    if (!bRemoved)
        UE_LOG(LogEosProtection, Error, TEXT("Player protection cleanup failed"));
}

void AEosProtectionController::ServerProtectionFailed_Implementation()
{
    if (!HasAuthority())
        return;
    UnregisterProtectedPlayer();
    Destroy();
}

void AEosProtectionController::EndPlay(const EEndPlayReason::Type Reason)
{
    if (HasAuthority())
        UnregisterProtectedPlayer();
    else
        StopClientProtection();
    Super::EndPlay(Reason);
}

AEosProtectionGameMode::AEosProtectionGameMode()
{
    PlayerControllerClass = AEosProtectionController::StaticClass();
}

void AEosProtectionGameMode::StartProtection(const FString &ServerName)
{
    if (GetNetMode() != NM_DedicatedServer || bSessionBound)
        return;
    Server = GetGameInstance()->GetSubsystem<UAntiCheatServer>();
    if (!Server)
    {
        UE_LOG(LogEosProtection, Error, TEXT("Anti-cheat server subsystem is unavailable"));
        return;
    }
    Server->OnAntiCheatRegisterClient.AddUniqueDynamic(this, &ThisClass::SendToClient);
    Server->OnAntiCheatActionRequired.AddUniqueDynamic(this, &ThisClass::ActionRequired);
    bSessionBound = true;
    bSessionRunning = Server->RegisterAntiCheatServer(ServerName, FString());
    if (!bSessionRunning)
    {
        StopProtection();
        UE_LOG(LogEosProtection, Error, TEXT("Server protection failed; do not admit players"));
    }
}

void AEosProtectionGameMode::AdmitAuthenticatedPlayer(APlayerController *Player,
                                                      const FString &VerifiedPuid,
                                                      TEnumAsByte<EUserPlatform> Platform)
{
    if (!IsValid(Player))
        return;
    auto *ProtectedPlayer = Cast<AEosProtectionController>(Player);
    if (!ProtectedPlayer)
    {
        Player->Destroy();
        return;
    }
    if (!bSessionRunning)
    {
        ProtectedPlayer->ServerProtectionFailed();
        return;
    }
    ProtectedPlayer->RegisterAuthenticatedPlayer(VerifiedPuid, Platform);
}

void AEosProtectionGameMode::SendToClient(APlayerController *ControllerRef,
                                          const TArray<uint8> &ClientData)
{
    if (auto *Player = Cast<AEosProtectionController>(ControllerRef); IsValid(Player))
        Player->ClientAntiCheatMessage(ClientData);
}

void AEosProtectionGameMode::ActionRequired(APlayerController *ControllerRef,
                                            bool bRemoveFromSession)
{
    if (!bRemoveFromSession)
        return;
    if (auto *Player = Cast<AEosProtectionController>(ControllerRef); IsValid(Player))
        Player->ServerProtectionFailed();
}

void AEosProtectionGameMode::StopProtection()
{
    if (!bSessionBound)
        return;
    bSessionRunning = false;
    TArray<AActor *> Players;
    UGameplayStatics::GetAllActorsOfClass(this, AEosProtectionController::StaticClass(), Players);
    for (AActor *Actor : Players)
        if (auto *Player = Cast<AEosProtectionController>(Actor); IsValid(Player))
            Player->ServerProtectionFailed();
    const bool bEnded = Server && Server->UnregisterAntiCheatServer();
    bSessionBound = false;
    if (Server)
    {
        Server->OnAntiCheatRegisterClient.RemoveDynamic(this, &ThisClass::SendToClient);
        Server->OnAntiCheatActionRequired.RemoveDynamic(this, &ThisClass::ActionRequired);
    }
    if (!bEnded)
        UE_LOG(LogEosProtection, Error, TEXT("Server protection cleanup failed"));
}

void AEosProtectionGameMode::EndPlay(const EEndPlayReason::Type Reason)
{
    StopProtection();
    Super::EndPlay(Reason);
}

Add EIKBlueprints, EIKSDK, EOSIntegrationKit, OnlineSubsystem, and Engine to your module dependencies.