ExperienceManager.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#include "EventSystem/ExperienceManager.h"
#include "GameFramework/PlayerController.h"
#include "Engine/World.h"
#include "PixoVRGameState.h"
#include "EventSystem/Events/BaseEvent.h"
#include "EventSystem/EventLogService.h"
#include "EventSystem/Events/Experience/InitializationEvent.h"
#include "EventSystem/Events/Experience/StartPlayEvent.h"
#include "EventSystem/Events/Experience/PlayerJoinedEvent.h"
#include "EventSystem/Events/Experience/ClearExperienceEvent.h"
#include "EventSystem/BaseManager.h"
 
PRAGMA_DISABLE_OPTIMIZATION
 
UExperienceManager::UExperienceManager()
    : Super()
{
}
 
void UExperienceManager::InitExperience()
{
    {
        FRWScopeLock(Lock, SLT_Write);
 
        for (TSubclassOf<UBaseManager> ListenerClass : SingleListenerClasses)
        {
            SingleListeners.Add(NewObject<UBaseManager>(this, ListenerClass));
        }
    }
 
    EventLogService::NewEvent<UInitializationEvent>();
}
 
void UExperienceManager::StartExperience()
{
    if (APixoVRGameState* GameState = GetWorld() != nullptr ? GetWorld()->GetGameState<APixoVRGameState>() : nullptr)
    {
        GameState->ServerStartGameSession();
        EventLogService::NewEvent<UStartPlayEvent>();
    }
}
 
void UExperienceManager::JoinExperience(uint8 PlayerIndex, APlayerController* NewPlayer)
{
    {
        FRWScopeLock(Lock, SLT_Write);
 
        for (TSubclassOf<UBaseManager> ListenerClass : PerPlayerListenerClasses)
        {
            PerPlayerListeners.Add(NewManager<UBaseManager>(NewPlayer, ListenerClass));
        }
    }
 
    EventLogService::NewEvent<UPlayerJoinedEvent>(NewPlayer);
}
 
void UExperienceManager::TickExperience(float DeltaTime)
{
    HandleEvents();
}
 
void UExperienceManager::LeaveExperience(AController* LeavingPlayer, uint8 PlayersLeft)
{
    {
        FRWScopeLock(Lock, SLT_Write);
 
        PerPlayerListeners.RemoveAllSwap([LeavingPlayer](const UBaseManager* Listener) -> bool
        {
            return Listener->GetPrivateOwner() == LeavingPlayer;
        });
    }
    if (PlayersLeft == 0)
    {
        EventLogService::NewEvent<UClearExperienceEvent>();
    }
}
 
void UExperienceManager::EndExperience()
{
    HandleEvents();
}
 
UBaseManager* UExperienceManager::GetManagerRef_Implementation(TSubclassOf<UBaseManager> ManagerClass)
{
    for (const auto Manager : SingleListeners)
    {
        if (Manager->IsA(ManagerClass))
        {
            return Manager;
        }
    }
    return nullptr;
}
 
void UExperienceManager::HandleEvent(UBaseEvent* Event)
{
}
 
void UExperienceManager::HandleEvents()
{
    FRWScopeLock(Lock, SLT_ReadOnly);
 
    TArray<UBaseEvent*> OutEvents;
    if (EventLogService::Events().GetAll(OutEvents))
    {
        for (UBaseEvent* Event : OutEvents)
        {
            HandleEvent(Event);
            DispatchEvent(Event);
        }
    }
}
 
void UExperienceManager::DispatchEvent(UBaseEvent* Event) const
{
    if (ensureMsgf(Event != nullptr, TEXT("[UExperienceManager::DispatchEvent] Event is NULL")))
    {
        Event->Lock();
        for (UBaseManager* Listener : SingleListeners)
        {
            Listener->HandleEvent(Event);
        }
        for (UBaseManager* Listener : PerPlayerListeners)
        {
            Listener->HandleEvent(Event);
        }
        Event->Unlock();
    }
}
 
PRAGMA_ENABLE_OPTIMIZATION