SoundManager.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#include "Managers/SoundManager.h"
#include "Components/AudioComponent.h"
#include "EventSystem/Events/Experience/InitializationEvent.h"
#include "EventSystem/Events/Hint/HintActivatedEvent.h"
#include "EventSystem/Events/Story/NewStepLoadedEvent.h"
#include "EventSystem/Events/Sound/PlaySoundEvent.h"
#include "EventSystem/Events/Story/NewStoryLoadedEvent.h"
#include "Kismet/GameplayStatics.h"
 
USoundManager::USoundManager()
{
    DEFINE_EVENT_HANDLER(UPlaySoundEvent);
    DEFINE_EVENT_HANDLER(UNewStepLoadedEvent);
    DEFINE_EVENT_HANDLER(UNewStoryLoadedEvent);
    DEFINE_EVENT_HANDLER(UHintActivatedEvent);
    DEFINE_EVENT_HANDLER(UInitializationEvent);
 
    AudioComponent = CreateDefaultSubobject<UAudioComponent>("Audio Component");
    AudioComponent->OnAudioFinished.AddDynamic(this, &USoundManager::OnAudioEndPlaying);
}
 
USoundCue* USoundManager::GetSoundBasedOnStep(FText stepName, UDataTable* DataTable)
{
    static const FString ContextString(TEXT("Sound"));
    if (DataTable)
    {
        TArray<FName> rowNames = DataTable->GetRowNames();
        if (rowNames.Num() == 0)
        {
            UE_LOG(LogTemp, Error, TEXT("Voice over DataTable is empty!"))
            return nullptr;
        }
        for (const auto rowName : rowNames)
        {
            FStepVO* findedSound = DataTable->FindRow<FStepVO>(rowName, ContextString);
            if (findedSound->StepName.EqualTo(stepName))
            {
                return findedSound->SoundCue;
            }
        }
    }
    else
        UE_LOG(LogTemp, Error, TEXT("Voice over DataTable is invalid!"));
    return nullptr;
}
 
void USoundManager::PlaySound(USoundCue* soundToPlay)
{
    if (soundToPlay)
    {
        AudioComponent->SetSound(soundToPlay);
        AudioComponent->Play();
    }
}
 
void USoundManager::PlayBackgroundSound(
    USoundBase* soundToPlay,
    float volumeMultiplier,
    float pitchMultiplier,
    float startTime,
    USoundConcurrency* concurrencySettings,
    AActor* owningActor,
    bool bIsUISound)
{
    if (soundToPlay)
    {
        UGameplayStatics::PlaySound2D(
            GetWorld(),
            soundToPlay,
            volumeMultiplier,
            pitchMultiplier,
            startTime,
            concurrencySettings,
            owningActor,
            bIsUISound);
        UE_LOG(LogTemp, Log, TEXT("USoundManager::PlayBackgroundSound: Playing - %s"), *soundToPlay->GetName());
    }
}
 
void USoundManager::PlaySFXSound(USoundBase* soundToPlay)
{
    if (soundToPlay)
    {
        UGameplayStatics::PlaySound2D(GetWorld(), soundToPlay, SFXVolumeMultiplier);
        UE_LOG(LogTemp, Log, TEXT("USoundManager::PlaySFXSound: Playing - %s"), *soundToPlay->GetName());
    }
}
 
void USoundManager::OnStepChange(FText stepName)
{
    PlaySound(GetSoundBasedOnStep(stepName, CurrentStepVODataTable));
}
 
void USoundManager::OnAudioEndPlaying()
{
    OnVoEndPlaying.Broadcast();
}
 
void USoundManager::HandleEvent_Impl(UPlaySoundEvent* Event)
{
    GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Blue, "UPlaySoundEvent");
    PlaySound(Event->MySoundCue);
}
 
void USoundManager::HandleEvent_Impl(UNewStepLoadedEvent* Event)
{
    CurrentStep = Event->CurrentStep.StepName;
    OnStepChange(CurrentStep);
}
 
void USoundManager::HandleEvent_Impl(UNewStoryLoadedEvent* Event)
{
    CurrentStep = Event->CurrentStep.StepName;
    OnStepChange(CurrentStep);
}
 
void USoundManager::HandleEvent_Impl(UHintActivatedEvent* Event)
{
    if (GetSoundBasedOnStep(CurrentStep, CurrentStepHintVODataTable))
    {
        PlaySound(GetSoundBasedOnStep(CurrentStep, CurrentStepHintVODataTable));
    }
}
 
void USoundManager::HandleEvent_Impl(UInitializationEvent* Event)
{
    AudioComponent->VolumeMultiplier = GeneralSoundVolumeMultiplier;
    
    const int32 StoryIndex = UStoryManager::GetNextStoryIndex();
 
    if (bPlayBackgroundSound)
    {
        for (FBackgroundSound BackgroundSound : BackgroundSounds)
        {
            if (BackgroundSound.Sound && (!BackgroundSound.AppropriateStoryParams.Num() || UStoryManager::IsSpecificParametersExist(BackgroundSound.AppropriateStoryParams)))
                PlayBackgroundSound(BackgroundSound.Sound, BackgroundVolumeMultiplier);
        }
    }
    
    if (SoundManagerParametersData)
    {
        for (auto SoundManagerParameter : SoundManagerParametersData->Data)
        {
            if (UStoryManager::IsSpecificParametersExist(SoundManagerParameter.ParametersName) && StoryIndex == SoundManagerParameter.StoryIndex)
            {
                CurrentStepVODataTable = SoundManagerParameter.DependentSoundTable;
                return;
            }
        }
    }
 
    if (StepVODataTablesArray.Num() != 0)
    {
        if (StepVODataTablesArray.IsValidIndex(StoryIndex))
        {
            CurrentStepVODataTable = StepVODataTablesArray[StoryIndex];
        }
        else if (StepVODataTablesArray[0])
        {
            CurrentStepVODataTable = StepVODataTablesArray[0];
            UE_LOG(LogTemp, Warning, TEXT("SoundManager - StepVODataTablesArray didn't have StoryIndex value, zero array element is selected"));
        }
        else
            UE_LOG(LogTemp, Error, TEXT("SoundManager - CurrentStepVODataTable wasn't set up"));
    }
    else
        UE_LOG(LogTemp, Error, TEXT("SoundManager - StepVODataTablesArray is empty!"));
 
    if (StepHintVODataTablesArray.Num() != 0)
    {
        if (StepHintVODataTablesArray.IsValidIndex(StoryIndex))
        {
            CurrentStepHintVODataTable = StepHintVODataTablesArray[StoryIndex];
        }
        else if (StepHintVODataTablesArray[0])
        {
            CurrentStepHintVODataTable = StepHintVODataTablesArray[0];
            UE_LOG(LogTemp, Warning, TEXT("SoundManager - StepVODataTablesArray didn't have StoryIndex value, zero array element is selected"));
        }
        else
            UE_LOG(LogTemp, Error, TEXT("SoundManager - CurrentStepHintVODataTable wasn't set up"));
    }
    else
        UE_LOG(LogTemp, Warning, TEXT("SoundManager - StepHintVODataTablesArray is empty!"));
}