InitStateWorldSubsystem.h

Go to the documentation of this file.

// Copyright (c) 2026 Nelaric

 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Set.h"
#include "Containers/Map.h"
#include "Subsystems/WorldSubsystem.h"
#include "UObject/WeakObjectPtr.h"
#include "Pawn/InitStateTypes.h"
 
#include "InitStateWorldSubsystem.generated.h"
 
class UActorComponent;
class AActor;
 
namespace Nelaric
{
struct FInitParticipantConfiguration
{
    UActorComponent* Component = nullptr;

    FName ComponentId;

    bool bRequiredForPawnReady = true;

    TArray<UActorComponent*> Dependencies;
};
} // namespace Nelaric

UCLASS(MinimalAPI)
class UInitStateWorldSubsystem : public UWorldSubsystem
{
    GENERATED_BODY()
 
public:
    GAMEPLAYRUNTIME_API void RegisterParticipant(UActorComponent* Component);

    GAMEPLAYRUNTIME_API void UnregisterParticipant(UActorComponent* Component);

    GAMEPLAYRUNTIME_API void NotifyParticipantChanged(UActorComponent* Component,
                                                      const Nelaric::FInitStateSnapshot& Previous);

    GAMEPLAYRUNTIME_API void RequestParticipantRefresh(UActorComponent* Component);

    GAMEPLAYRUNTIME_API bool ConfigureParticipant(UActorComponent* Component, FName ComponentId,
                                                  bool bRequiredForPawnReady,
                                                  const TArray<UActorComponent*>& Dependencies);

    GAMEPLAYRUNTIME_API bool
    ConfigureParticipants(const TArray<Nelaric::FInitParticipantConfiguration>& Configurations);

    GAMEPLAYRUNTIME_API bool AreRequiredParticipantsReady(const AActor* Owner) const;

    GAMEPLAYRUNTIME_API bool IsParticipantReady(UActorComponent* Component) const;
 
public:
    virtual void Deinitialize() override;
 
private:
    friend class UPawnInitializationComponent;
    bool HasConfiguredId(const AActor* Owner, FName ComponentId) const;
    void StopConfiguredParticipants(const TArray<UActorComponent*>& Components);
    using FComponentPtr = TWeakObjectPtr<UActorComponent>;
    TSet<FComponentPtr> RegisteredComponents;
    TSet<FComponentPtr> StoppedComponents;
    bool bShuttingDown = false;
    struct FConfiguredParticipant
    {
        TWeakObjectPtr<AActor> Owner;
        FName ComponentId;
        bool bRequiredForPawnReady = true;
        TArray<FComponentPtr> Dependencies;
    };
    TMap<FComponentPtr, FConfiguredParticipant> ConfiguredComponents;
    TMap<FComponentPtr, TArray<FComponentPtr>> ForwardDependencies;
    TMap<FComponentPtr, TArray<FComponentPtr>> ReverseDependencies;
    TMap<TWeakObjectPtr<AActor>, TArray<FComponentPtr>> RequiredByOwner;
    TMap<FComponentPtr, int32> ReadyGroupByComponent;
    TArray<TArray<FComponentPtr>> ReadyGroups;
    uint64 GraphVersion = 0;
    int32 GraphEdgeCount = 0;
    TArray<FComponentPtr> PendingQueue;
    TSet<FComponentPtr> QueuedComponents;
    TSet<TWeakObjectPtr<AActor>> PendingOwners;
    bool bProcessing = false;
    bool bInvalidatingDependents = false;
    void RebuildDependencyGraph();
    void QueueParticipant(UActorComponent* Component);
    void QueueParticipantAndDependents(UActorComponent* Component);
    void QueueAllRegistered();
    void ProcessParticipants();
    bool TryCommitReadyGroup(UActorComponent* Root);
    void InvalidateConfiguredDependents(UActorComponent* Component);
};