ApexReportingManager.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#include "Managers/ApexReportingManager.h"
#include "Kismet/KismetMathLibrary.h"
#include "EventSystem/Events/Experience/InitializationEvent.h"
#include "EventSystem/Events/Story/EndOfStoryReached.h"
#include "EventSystem/Events/Story/NewStepLoadedEvent.h"
#include "EventSystem/Events/Story/NewStoryLoadedEvent.h"
#include "EventSystem/Events/Story/StepCompletedEvent.h"
#include "GameFramework/GameModeBase.h"
#include "Interfaces/PixoCoreInterface.h"
 
UApexReportingManager::UApexReportingManager()
{
    DEFINE_EVENT_HANDLER(UNewStepLoadedEvent);
    DEFINE_EVENT_HANDLER(UNewStoryLoadedEvent);
    DEFINE_EVENT_HANDLER(UInitializationEvent);
    DEFINE_EVENT_HANDLER(UStepCompletedEvent);
    DEFINE_EVENT_HANDLER(UEndOfStoryReached);
}
 
void UApexReportingManager::CompleteApexSession(bool Completed, bool Success)
{
    if (!ApexSubSystem)
    {
        return;
    }
    
    int32 CompletedStepsCount = 0;
    int32 TotalNumberOfSteps = 0;
    
    if (GetWorld()->GetAuthGameMode()->GetClass()->ImplementsInterface(UPixoCoreInterface::StaticClass()))
    {
        if (UStoryManager* StoryManagerRef = Cast<UStoryManager>(IPixoCoreInterface::Execute_GetManagerRef(GetWorld()->GetAuthGameMode(), UStoryManager::StaticClass())))
        {
            TArray<FPassedExperiences> PassedExperiences = StoryManagerRef->PassedExperiencesArray;
            CompletedStepsCount = GetAmountOfCompletedSteps(PassedExperiences);
            for (const auto & PassExpElement : PassedExperiences)
            {
                TotalNumberOfSteps += PassExpElement.PassedStepData.Num();
            }
        }
    }
    
    FSessionData NewSessionData;
    NewSessionData.Complete = Completed;
    NewSessionData.Success = Success;
    NewSessionData.Score = CompletedStepsCount * ScoreFactor;
    NewSessionData.ScoreScaled = UKismetMathLibrary::SafeDivide((float)CompletedStepsCount, (float)TotalNumberOfSteps);
    NewSessionData.ScoreMin = 0.0f;
    NewSessionData.ScoreMax = TotalNumberOfSteps * ScoreFactor;
    NewSessionData.Duration = GetApexSessionDuration();
    ApexSubSystem->CompleteSession(NewSessionData);
}
 
void UApexReportingManager::EarlyExitSession(float Score, float MaxScore, TMap<FString, FString> ExtensionParameters)
{
    if (!ApexSubSystem)
    {
        return;
    }
 
    FXAPIExtension Extension;
    TArray<FString> ExtensionParameterKeys;
    ExtensionParameters.GetKeys(ExtensionParameterKeys);
    for (auto ExtensionKey : ExtensionParameterKeys)
    {
        FString Key = ExtensionKey;
        FString Value = ExtensionParameters.FindRef(ExtensionKey);
        Extension.AddString(Key, Value);
    }
    
    FSessionData NewSessionData;
    NewSessionData.Complete = false;
    NewSessionData.Success = false;
    NewSessionData.Score = Score;
    NewSessionData.ScoreScaled = MaxScore > 0.f? Score/MaxScore : 0.f;
    NewSessionData.ScoreMin = 0.0f;
    NewSessionData.ScoreMax = MaxScore;
    NewSessionData.Duration = GetApexSessionDuration();
    NewSessionData.AdditionalResultData = Extension;
    
    ApexSubSystem->CompleteSession(NewSessionData);
}
 
void UApexReportingManager::OnEndStoryReached_Implementation()
{
}
 
void UApexReportingManager::OnInitialized_Implementation()
{
}
 
FXAPIStatement UApexReportingManager::GetStatementData_Implementation()
{
    FXAPIStatement StatementData;
 
    StatementData.Verb.ID = FString("https://pixovr.com/xapi/verbs/completed");
    StatementData.Target.ID = FString("https://pixovr.com/xapi/objects/") +
        FString::FromInt(ApexSubSystem->LoadedModuleId) + FString("/") + CurrentStep.ToString();
 
    return StatementData;
}
 
int32 UApexReportingManager::GetAmountOfCompletedSteps(const TArray<FPassedExperiences> PassedExperiences) const
{
    int32 Counter = 0;
    for (const auto & PassExpElement : PassedExperiences)
    {
        for (const auto & Step : PassExpElement.PassedStepData)
        {
            if (Step.Step.Completed)
            {
                Counter++;
            }
        }
    }
    return Counter;
}
 
int32 UApexReportingManager::GetApexSessionDuration()
{
    return (UKismetMathLibrary::Now() - ApexStartTime).GetTotalSeconds();
}
 
void UApexReportingManager::HandleEvent_Impl(UInitializationEvent* Event)
{
    ApexSubSystem = GetWorld()->GetGameInstance()->GetSubsystem<UApexAPI>();
    if (ApexSubSystem)
    {
        ApexStartTime = UKismetMathLibrary::Now();
        if (UseDefaultSessionStart)
        {
            const FXAPIExtension Extension;
            ApexSubSystem->JoinSession(FString(FApp::GetProjectName()), Extension);
        }
    }
    else
        UE_LOG(LogTemp, Error, TEXT ("Apex SubSystem is not valid"));
 
    OnInitialized();
}
 
void UApexReportingManager::HandleEvent_Impl(UNewStepLoadedEvent* Event)
{
    CurrentStep = Event->CurrentStep.StepName;
}
 
void UApexReportingManager::HandleEvent_Impl(UNewStoryLoadedEvent* Event)
{
    CurrentStep = Event->CurrentStep.StepName;
    const UStoryManager* StoryManager = Cast<UStoryManager>(IPixoCoreInterface::Execute_GetManagerRef(GetWorld()->GetAuthGameMode(), UStoryManager::StaticClass()));
    LoadedStoryIndexesHistory.AddUnique(StoryManager->StoryIndex);
}
 
void UApexReportingManager::HandleEvent_Impl(UStepCompletedEvent* Event)
{
    if (UseReportingEachStep)
    {
        if (ApexSubSystem)
        {
            ApexSubSystem->SendSessionEvent(GetStatementData());
        }
        else
            UE_LOG(LogTemp, Error, TEXT("ApexSubSystem reference is not valid!"));
    }
}
 
void UApexReportingManager::HandleEvent_Impl(UEndOfStoryReached* Event)
{
    if (UseDefaultSessionEnd)
    {
        CompleteApexSession(true, true);
    }
    OnEndStoryReached();
}