GameManager.cpp

Go to the documentation of this file.

// Fill out your copyright notice in the Description page of Project Settings.
 
#include "Managers/GameManager.h"
 
#include "EventSystem/Events/Experience/InitializationEvent.h"
#include "EventSystem/Events/Story/NewStepLoadedEvent.h"
#include "EventSystem/Events/Story/NewStoryLoadedEvent.h"
#include "GameFramework/GameModeBase.h"
#include "Interfaces/PixoCoreInterface.h"
#include "Kismet/GameplayStatics.h"
#include "Managers/SoundManager.h"
 
UGameManager::UGameManager()
{
    DEFINE_EVENT_HANDLER(UNewStepLoadedEvent);
    DEFINE_EVENT_HANDLER(UNewStoryLoadedEvent);
    DEFINE_EVENT_HANDLER(UInitializationEvent);
 
    OnWrongInteractableActorGrabbed.AddDynamic(this, &UGameManager::OnGrabbingWrongActor);
}
 
void UGameManager::AddNewInteractableObject(ABaseStoryActor* InteractableActor)
{
    InteractiveItemsArray.Add(InteractableActor);
    OnInteractiveItemAdded(InteractableActor);
    OnNewInteractableItemAdded.Broadcast(InteractableActor);
    if (InteractableActor->IsAutoStepDataPopulationActive && (InteractiveObjectStepDataBase.Num() != 0))
        PopulateInteractiveObjectsWithStepData(InteractableActor);
}
 
void UGameManager::NewDynamicStoryAdded(FDynamicStoryData DynamicStoryData)
{
    if (StoryManagerRef)
    {
        if (StoryManagerRef->StoryFinished)
        {
            InitializeNewDynamicStory(DynamicStoryData);
        }
        else
        {
            DynamicStoryQueue.Add(DynamicStoryData);
        }
    }
}
 
void UGameManager::SpawnStoryScripts()
{
    if (ScriptInstancesData.Num())
        ScriptInstancesData.Empty();
    
    if (!StoryScriptClassData || StoryScriptClassData->ScriptData.Num() == 0)
    {
        return;
    }
    for (auto StoryScript : StoryScriptClassData->ScriptData)
    {
        UStoryScript* TempScript = NewObject<UStoryScript>(this, StoryScript.StepScriptClass);
        ScriptInstancesData.Add(FScriptInstanceData(StoryScript.StepName, TempScript));
        TempScript->ScriptInitialization();
    }
}
 
void UGameManager::InitializeNewDynamicStory(FDynamicStoryData DynamicStoryData)
{
    DynamicStoryScripts = DynamicStoryData.StoryScripts;
    StoryScriptClassData = DynamicStoryScripts[0];
    SpawnStoryScripts();
 
    InteractiveObjectStepDataBase = DynamicStoryData.InteractiveObjectData;
    
    for(auto InteractiveObject : InteractiveItemsArray)
    {
        PopulateInteractiveObjectsWithStepData(InteractiveObject);
    }
 
    StoryManagerRef->StoryDataArray = DynamicStoryData.DynamicStoryData;
    StoryManagerRef->InitNewStory(0);
}
 
void UGameManager::OnEndStoryReached()
{
    if (StoryManagerRef)
    {
        if (StoryManagerRef->IsAutoSwitchingToNextStoryActive && DynamicStoryQueue.IsValidIndex(ActiveDynamicStoryIndex+1))
        {
            ActiveDynamicStoryIndex += 1;
            InitializeNewDynamicStory(DynamicStoryQueue[ActiveDynamicStoryIndex]);
        }
        else
        {
            ActiveDynamicStoryIndex = -1;
            DynamicStoryQueue.Empty();
        }
    }
}
 
void UGameManager::GetAllActorsOfClass(TSubclassOf<AActor> TargetClass, TArray<AActor*>& OutActors)
{
    if (UWorld* World = GetWorld())
    {
        UGameplayStatics::GetAllActorsOfClass(World, TargetClass, OutActors);
    }
}
 
void UGameManager::OnInitialization_Implementation()
{
}
 
void UGameManager::PopulateInteractiveObjectsWithStepData(ABaseStoryActor* TargetActor)
{
    if (TargetActor && TargetActor->Story && !TargetActor->ActiveStepsAcquiredFromParent)
    {
        TargetActor->Story->ActiveSteps.Empty();
        TargetActor->HighlightComponent->HighlightActiveOnSteps.Empty();
        for (auto const InteractableObjectDataBase : InteractiveObjectStepDataBase)
        {
            for (auto const & InteractableObjectData : InteractableObjectDataBase->InteractiveObjectData)
            {
                if (TargetActor->IsA(InteractableObjectData.InteractiveObject))
                {
                    TargetActor->Story->ActiveSteps.Append(InteractableObjectData.StorySteps);
                    TargetActor->HighlightComponent->HighlightActiveOnSteps.Append(InteractableObjectData.HighlightSteps);
                    // Populate with step data child actors
                    if (TargetActor->ChildClassesThatAcquiredPopulatedData.Num())
                    {
                        TArray<AActor*> ChildActorsArray;
                        TargetActor->GetAllChildActors(ChildActorsArray);
                        for (auto const ChildActor : ChildActorsArray)
                        {
                            Cast<ABaseStoryActor>(ChildActor)->Story->ActiveSteps.Empty();
                            Cast<ABaseStoryActor>(ChildActor)->HighlightComponent->HighlightActiveOnSteps.Empty();
                            for (auto ChildClass : TargetActor->ChildClassesThatAcquiredPopulatedData)
                            {
                                if (ChildActor->IsA(ChildClass))
                                {
                                    Cast<ABaseStoryActor>(ChildActor)->ActiveStepsAcquiredFromParent = true;
                                    Cast<ABaseStoryActor>(ChildActor)->Story->ActiveSteps.Append(InteractableObjectData.StorySteps);
                                    Cast<ABaseStoryActor>(ChildActor)->HighlightComponent->HighlightActiveOnSteps.Append(InteractableObjectData.HighlightSteps);
                                }
                            }
                        }
                    }
                    break;
                }
            }
        }
    }
}
 
void UGameManager::OnGrabbingWrongActor_Implementation(AActor* WrongActor)
{
}
 
void UGameManager::OnTeleportActivatedRaw_Implementation(EControllerHand Hand, bool InActivate)
{
}
 
void UGameManager::HandleEvent_Impl(UNewStepLoadedEvent* Event)
{
    CurrentStep = Event->CurrentStep.StepName;
    OnNewStepLoaded(CurrentStep);
}
 
void UGameManager::HandleEvent_Impl(UNewStoryLoadedEvent* Event)
{
    CurrentStep = Event->CurrentStep.StepName;
    OnNewStoryLoaded(CurrentStep);
}
 
void UGameManager::HandleEvent_Impl(UInitializationEvent* Event)
{
    GameModeBaseRef = GetWorld()->GetAuthGameMode();
    if (GameModeBaseRef->GetClass()->ImplementsInterface(UPixoCoreInterface::StaticClass()))
    {
        SoundManagerRef = Cast<USoundManager>(IPixoCoreInterface::Execute_GetManagerRef(GameModeBaseRef, USoundManager::StaticClass()));
        if (!SoundManagerRef)
        {
            UE_LOG(LogTemp, Error, TEXT("Sound Manager has not been setup for this project!"));
        }
 
        StoryManagerRef = Cast<UStoryManager>(IPixoCoreInterface::Execute_GetManagerRef(GameModeBaseRef, UStoryManager::StaticClass()));
        if (StoryManagerRef)
        {
            StoryManagerRef->OnEndOfStory.AddDynamic(this, &UGameManager::OnEndStoryReached);
        }
    }
    else
        UE_LOG(LogTemp, Error, TEXT("Game mode doesn't implement PixoCore Interface"));
 
    PlayerPawnRef = Cast<APixoVRCharacter>(GetWorld()->GetFirstPlayerController()->GetPawn());
    if (PlayerPawnRef)
    {
        PlayerPawnRef->OnTeleportationActivated().AddUObject(this, &UGameManager::OnTeleportActivatedRaw);
    }
    else
        UE_LOG(LogTemp, Error, TEXT("PlayerPawn reference is invalid!"));
 
    if (IsUsingStoryScriptData)
    {
        SpawnStoryScripts();
    }
 
    OnInitialization();
}