StoryManager.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#include "Story/StoryManager.h"
#include "Net/UnrealNetwork.h"
#include "EventSystem/Events/Story/NewStepLoadedEvent.h"
#include "EventSystem/Events/Story/NewSubStepLoadedEvent.h"
#include "EventSystem/Events/Experience/InitializationEvent.h"
#include "EventSystem/Events/Story/EndOfStoryReached.h"
#include "EventSystem/Events/Story/NewStoryLoadedEvent.h"
#include "EventSystem/Events/Story/StepCompletedEvent.h"
 
int UStoryManager::NextStoryIndex = 0;
TArray<FText> UStoryManager::StoryParameters;
 
DEFINE_LOG_CATEGORY(LogStoryManager);
 
bool FStoryStep::operator==(const FStoryStep& Step) const
{
    return Step.StepName.EqualTo(StepName);
}
 
UStoryManager::UStoryManager()
{
    DEFINE_EVENT_HANDLER(UInitializationEvent);
}
 
bool UStoryManager::InitNewStory(int newStoryIndex)
{
    if (StoryDataArray.Num() == 0)
    {
        UE_LOG(LogStoryManager, Warning, TEXT("AStoryManager::InitNewStory StoryDataArray is empty"));
        //GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, "AStoryManager::InitNewStory StoryDataArray is empty");
        return false;
    }
 
    if (!StoryDataArray.IsValidIndex(newStoryIndex))
    {
        UE_LOG(LogStoryManager, Warning, TEXT("AStoryManager::InitNewStory Index out of range"));
        return false;
    }
    // rewrite StoryDataArray with updated StoryData when loading new story in one experience
    if (StoryData)
    {
        RecordStoryStepData();
    }
    StoryData = StoryDataArray[newStoryIndex];
    StepData = StoryData->StepData;
    StepIndex = 0;
    SubStepIndex = 0;
    if (!StepData.IsValidIndex(StepIndex))
    {
        return false;
    }
 
    CurrentStep = StepData[StepIndex].Step;
    if (StepData[StepIndex].SubStep.IsValidIndex(SubStepIndex))
    {
        CurrentSubStep = StepData[StepIndex].SubStep[SubStepIndex];
    }
    else
    {
        CurrentSubStep.StepName = FText();
        CurrentSubStep.Completed = false;
    }
    StoryIndex = newStoryIndex;
    EventLogService::NewEvent<UNewStoryLoadedEvent>(nullptr, CurrentStep, true);
    OnStoryLoaded.Broadcast();
 
    return true;
}
 
bool UStoryManager::GoToNextStep()
{
    if (!StepData.IsValidIndex(StepIndex))
    {
        return false;
    }
 
    if (!StepData.IsValidIndex(StepIndex + 1))
    {
        StoryFinished = true;
        OnEndOfStory.Broadcast();
        EventLogService::NewEvent<UEndOfStoryReached>();
 
        UE_LOG(LogStoryManager, Warning, TEXT("AStoryManager::GoToNextStep Index out of range"));
        return false;
    }
 
    StepIndex++;
    PreviousStep = CurrentStep;
    CurrentStep = StepData[StepIndex].Step;
    SubStepIndex = 0;
    if (StepData[StepIndex].SubStep.IsValidIndex(SubStepIndex))
    {
        CurrentSubStep = StepData[StepIndex].SubStep[SubStepIndex];
    }
    else
    {
        CurrentSubStep.StepName = FText();
        CurrentSubStep.Completed = false;
    }
 
    OnNewStep.Broadcast(CurrentStep, true);
    EventLogService::NewEvent<UNewStepLoadedEvent>(nullptr, CurrentStep, true);
    UE_LOG(LogStoryManager, Log, TEXT("AStoryManager::GoToNextStep Next Step %s"), *CurrentStep.StepName.ToString());
 
    return true;
}
 
bool UStoryManager::GoToNextSubStep()
{
    if (!StepData.IsValidIndex(StepIndex))
    {
        return false;
    }
 
    if (!StepData[StepIndex].SubStep.IsValidIndex(SubStepIndex + 1))
    {
        StepCompleted(CurrentStep.StepName, true);
        SubStepIndex = 0;
        return false;
    }
 
    SubStepIndex++;
    //PreviousStep = CurrentStep;
    CurrentSubStep = StepData[StepIndex].SubStep[SubStepIndex];
 
    OnNewSubStep.Broadcast(CurrentSubStep);
    EventLogService::NewEvent<UNewSubStepLoadedEvent>(nullptr, CurrentSubStep, true);
    UE_LOG(LogStoryManager, Log, TEXT("AStoryManager::GoToNextSubStep Next SubStep %s"),
           *CurrentSubStep.StepName.ToString());
 
    return true;
}
 
void UStoryManager::CompleteSubStep(FStoryStep completedStep)
{
    if (!StepData.IsValidIndex(StepIndex))
    {
        return;
    }
 
    for (int i = 0; i < StepData[StepIndex].SubStep.Num(); i++)
    {
        if (StepData[StepIndex].SubStep[i].StepName.EqualTo(completedStep.StepName))
        {
            StepData[StepIndex].SubStep[i].Completed = true;
        }
    }
    if (IsAllSubStepsCompleted())
    {
        StepCompleted(CurrentStep.StepName, true);
        SubStepIndex = 0;
    }
}
 
bool UStoryManager::JumpToStepByIndex(int index)
{
    if (!StepData.IsValidIndex(index))
    {
        UE_LOG(LogStoryManager, Warning, TEXT("AStoryManager::JumpToStepByIndex Couldn't find a step by index %d"),
               index);
        return false;
    }
 
    bool isForward;
    if (index < StepIndex)
    {
        isForward = false;
 
        for (int i = StepIndex - 1; i >= index; i--)
        {
            OnStepSkipped.Broadcast(StepData[i].Step, false);
        }
    }
    else
    {
        isForward = true;
 
        for (int i = StepIndex; i < index; i++)
        {
            OnStepSkipped.Broadcast(StepData[i].Step, true);
        }
    }
 
    StepIndex = index;
    PreviousStep = CurrentStep;
    CurrentStep = StepData[StepIndex].Step;
    SubStepIndex = 0;
    if (StepData[StepIndex].SubStep.IsValidIndex(SubStepIndex))
    {
        CurrentSubStep = StepData[StepIndex].SubStep[SubStepIndex];
    }
    else
    {
        CurrentSubStep.StepName = FText();
        CurrentSubStep.Completed = false;
    }
 
    OnNewStep.Broadcast(CurrentStep, isForward);
    EventLogService::NewEvent<UNewStepLoadedEvent>(nullptr, CurrentStep, true);
    UE_LOG(LogStoryManager, Log, TEXT("AStoryManager::JumpToStepByIndex Jump To Step %s"),
           *CurrentStep.StepName.ToString());
 
    return true;
}
 
bool UStoryManager::JumpToStepByName(FText stepId)
{
    bool found = false;
    int index = 0;
 
    for (int i = 0; i < StepData.Num(); i++)
    {
        if (stepId.EqualTo(StepData[i].Step.StepName))
        {
            index = i;
            found = true;
            break;
        }
    }
 
    if (found == false)
    {
        UE_LOG(LogStoryManager, Warning, TEXT("AStoryManager::JumpToStepByName Couldn't find a step %s"),
               *stepId.ToString());
        return false;
    }
 
    bool isForward;
    if (index < StepIndex)
    {
        isForward = false;
 
        for (int i = StepIndex - 1; i >= index; i--)
        {
            OnStepSkipped.Broadcast(StepData[i].Step, false);
        }
    }
    else
    {
        isForward = true;
 
        for (int i = StepIndex; i < index; i++)
        {
            OnStepSkipped.Broadcast(StepData[i].Step, true);
        }
    }
 
    StepIndex = index;
    PreviousStep = CurrentStep;
    CurrentStep = StepData[StepIndex].Step;
    SubStepIndex = 0;
    if (StepData[StepIndex].SubStep.IsValidIndex(SubStepIndex))
    {
        CurrentSubStep = StepData[StepIndex].SubStep[SubStepIndex];
    }
    else
    {
        CurrentSubStep.StepName = FText();
        CurrentSubStep.Completed = false;
    }
 
    OnNewStep.Broadcast(CurrentStep, isForward);
    EventLogService::NewEvent<UNewStepLoadedEvent>(nullptr, CurrentStep, true);
    UE_LOG(LogStoryManager, Log, TEXT("AStoryManager::JumpToStepByName Jump To Step %s"),
           *CurrentStep.StepName.ToString());
 
    return true;
}
 
void UStoryManager::StepCompleted(FText stepToUpdate, bool goToNext)
{
    if (!StepData.IsValidIndex(StepIndex))
    {
        return;
    }
 
    if (BlockStory == false)
    {
        if (stepToUpdate.EqualTo(CurrentStep.StepName))
        {
            StepData[StepIndex].Step.Completed = true;
            RecordStoryStepData();
            OnStepCompleted.Broadcast(CurrentStep);
            EventLogService::NewEvent<UStepCompletedEvent>(nullptr, CurrentStep);
 
            if (goToNext)
            {
                GoToNextStep();
            }
        }
    }
}
 
void UStoryManager::AddStoryComponent(UStoryComponent* storyComponent)
{
    StoryComponents.AddUnique(storyComponent);
}
 
void UStoryManager::SetupNextStory(int newNextStoryIndex, TArray<FText> newStoryParameters)
{
    NextStoryIndex = newNextStoryIndex;
    StoryParameters = newStoryParameters;
}
 
bool UStoryManager::IsAllSubStepsCompleted()
{
    if (!StepData.IsValidIndex(StepIndex))
    {
        return false;
    }
 
    bool isCompleted = true;
    for (FStoryStep steps : StepData[StepIndex].SubStep)
    {
        if (!steps.Completed)
        {
            isCompleted = false;
        }
    }
    return isCompleted;
}
 
void UStoryManager::RecordStoryStepData()
{
    bool StoryAlreadyInArray = false;
    int32 FoundedStoryIndex = 0;
    for (int i = 0; i <= (PassedExperiencesArray.Num() - 1); i++)
    {
        if (PassedExperiencesArray[i].StoryIndex == StoryIndex)
        {
            StoryAlreadyInArray = true;
            FoundedStoryIndex = i;
        }
    }
    if (StoryAlreadyInArray)
    {
        PassedExperiencesArray[FoundedStoryIndex].PassedStepData = StepData;
    }
    else
    {
        FPassedExperiences TempExp;
        TempExp.PassedStepData = StepData;
        TempExp.StoryIndex = StoryIndex;
        PassedExperiencesArray.Add(TempExp);
    }
}
 
void UStoryManager::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
 
    DOREPLIFETIME(UStoryManager, StoryData);
    DOREPLIFETIME(UStoryManager, StepData);
    DOREPLIFETIME(UStoryManager, CurrentStep);
    DOREPLIFETIME(UStoryManager, StepIndex);
    DOREPLIFETIME(UStoryManager, PreviousStep);
    DOREPLIFETIME(UStoryManager, CurrentSubStep);
    DOREPLIFETIME(UStoryManager, SubStepIndex);
    DOREPLIFETIME(UStoryManager, StoryIndex);
}
 
void UStoryManager::HandleEvent_Impl(UInitializationEvent* Event)
{
    if (!StoryData->IsValidLowLevel() || StoryData->StepData.Num() == 0)
    {
        if (!InitNewStory(NextStoryIndex))
        {
            UE_LOG(LogStoryManager, Error, TEXT("AStoryManager::UInitializationEvent StoryDataArray is empty"));
        }
    }
}