Mechanism.h

/*
 * ░▒▓ APPARATUS ▓▒░
 * 
 * File: ApparatusFunctionLibrary.h
 * Created: Friday, 23rd October 2020 7:00:48 pm
 * Author: Vladislav Dmitrievich Turbanov (vladislav@turbanov.ru)
 * ───────────────────────────────────────────────────────────────────
 * Last Modified: Tuesday, 6th April 2021 1:36:08 pm
 * Modified By: Vladislav Dmitrievich Turbanov (vladislav@turbanov.ru)
 * ───────────────────────────────────────────────────────────────────
 * 
 * The Apparatus source code is for your internal usage only.
 * Redistribution of this file is strictly prohibited.
 * 
 * Community forums: https://talk.turbanov.ru
 * 
 * Copyright 2020 - 2021, SP Vladislav Dmitrievich Turbanov
 * Made in Russia, Moscow City, Chekhov City
 */
 
#pragma once
 
#include <map>
#include <ostream>
#include <typeinfo>
 
#include "CoreUObject.h"
#include "Engine.h"
#include "UObject/Class.h"
 
#include "Fingerprint.h"
#include "Filter.h"
#include "Mechanical.h"
#include "SubjectiveActorComponent.h"
 
#include "Mechanism.generated.h"
 
DECLARE_STATS_GROUP(TEXT("Mechanism"), STATGROUP_Mechanism, STATCAT_Advanced);
 
DECLARE_CYCLE_STAT_EXTERN(TEXT("Boot"), STAT_MechanismBoot,
                          STATGROUP_Mechanism, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Buffer"), STAT_MechanismBuffer,
                          STATGROUP_Mechanism, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Find Matching Belts"), STAT_MechanismFindMatchingBelts,
                          STATGROUP_Mechanism, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Evaluate"), STAT_MechanismEvaluate,
                          STATGROUP_Mechanism, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Evaluate ~ Input"), STAT_MechanismEvaluateInput,
                          STATGROUP_Mechanism, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Evaluate ~ Steady"),
                          STAT_MechanismEvaluateSteady, STATGROUP_Mechanism, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Evaluate ~ Presentation"),
                          STAT_MechanismEvaluatePresentation,
                          STATGROUP_Mechanism, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Fetch"), STAT_MechanismFetchDetails,
                          STATGROUP_Mechanism, );
 
UCLASS()
class APPARATUSRUNTIME_API UMechanism: public UObject
{
    GENERATED_BODY()
 
    
    static TArray<TWeakObjectPtr<UBelt>> Belts;
 
    static TArray<TWeakInterfacePtr<IMechanical>> Mechanicals;
 
    static TMap<FFilter, TArray<TWeakObjectPtr<UBelt>>> BeltsByFilters;
 
    static TSet<TWeakInterfacePtr<ISubjective>> All;
 
    static TArray<TWeakInterfacePtr<ISubjective>> AllNotBooted;
 
    static void DoRegister(TScriptInterface<ISubjective> Subjective);
 
    static void DoUnregister(TScriptInterface<ISubjective> Subjective);
 
    static void DoHandleChange(TScriptInterface<ISubjective> Subjective);
 
    static void DoHandleChange(TScriptInterface<ISubjective> Subjective,
                               const TArray<UDetail*>& Details);
 
    static class UBelt* DoBufferBelt(class UBelt* BufferingBelt,
                                     class UBelt* Belt,
                                     const FFilter& Filter);
 
    static class UBelt* DoBufferBelts(class UBelt* BufferingBelt,
                                      const TArray<class UBelt*>& TargetBelts,
                                      const FFilter& Filter);
 
    static FORCEINLINE void DoClearMatchingBeltsCache()
    {
        BeltsByFilters.Reset();
    }
 
    static FORCEINLINE void ClearMatchingBeltsCache()
    {
        DoClearMatchingBeltsCache();
    }
 
    static class UBelt*
    DoObtainMostSpecificBelt(UObject* BeltOwner,
                             TScriptInterface<ISubjective> Subjective);
 
    static void DoFindMatchingBelts(const struct FFilter& InFilter,
                                   TArray<class UBelt*>& OutBelts);
 
    static FORCEINLINE void
    DoGetBeltsMatchingFingerprint(const struct FFingerprint& Fingerprint,
                                  TArray<class UBelt*>& OutBelts)
    {
        return DoFindMatchingBelts(FFilter(Fingerprint), OutBelts);
    }
 
    static void DoFetchDetailsInAllBelts();
 
    static void FetchDetailsInAllBelts();
 
    static TWeakObjectPtr<class UMechanism> Instance;
 
    friend class UBelt;
 
public:
 
    FORCEINLINE static const TSet<TWeakInterfacePtr<ISubjective>>& GetAll()
    {
        return All;
    }
 
    FORCEINLINE static const TArray<TWeakInterfacePtr<ISubjective>>& GetAllNotBooted()
    {
        return AllNotBooted;
    }
 
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "Apparatus")
    static void
    GetBeltsMatchingFingerprint(const struct FFingerprint& Fingerprint,
                                TArray<class UBelt*>& OutBelts);
 
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "Apparatus")
    static void
    FindMatchingBelts(const struct FFilter& Filter,
                     TArray<class UBelt*>& OutBelts);
 
    UFUNCTION(BlueprintCallable, Category = "Apparatus")
    static void BootAll();
 
    UFUNCTION(BlueprintCallable, Category = "Apparatus|Mechanics",
              Meta = (HidePin = "Mechanical", DefaultToSelf = "Mechanical"))
    static class UBelt*
    BufferBelt(UObject* Mechanical,
               class UBelt* Belt,
               const FFilter& Filter);
 
    UFUNCTION(BlueprintCallable, Category = "Apparatus|Mechanics",
              Meta = (HidePin = "Mechanical", DefaultToSelf = "Mechanical"))
    static class UBelt*
    BufferBelts(UObject* Mechanical,
                const TArray<class UBelt*>& TargetBelts,
                const FFilter& Filter);
 
    static void HandleChange(TScriptInterface<ISubjective> Subjective);
 
    static void HandleChange(TScriptInterface<ISubjective> Subjective,
                             const TArray<UDetail*>& Details);
 
    static void RegisterSubjective(TScriptInterface<ISubjective> Subjective);
 
    static void UnregisterSubjective(TScriptInterface<ISubjective> Subjective);
 
    static class UBelt*
    ObtainMostSpecificBelt(UObject* BeltOwner,
                           TScriptInterface<ISubjective> Subjective);
 
 
    static class UMechanism* GetInstance()
    {
        if (Instance.IsValid())
        {
            return Instance.Get();
        }
        Instance = NewObject<UMechanism>(GetTransientPackage());
        check(Instance.IsValid());
        Instance->AddToRoot();
        return Instance.Get();
    }
 
    static void RegisterMechanical(TScriptInterface<IMechanical> Mechanical);
 
    static FORCEINLINE void UnregisterMechanical(TScriptInterface<IMechanical> Mechanical)
    {
        check(Mechanical);
        Mechanicals.Remove(Mechanical.GetObject());
    }
}; // class UMechanism
 
FORCEINLINE class UBelt* UMechanism::DoBufferBelt(
    UBelt* BufferingBelt,
    class UBelt* Belt,
    const FFilter& Filter)
{
    if (Filter.GetBootFilter() == EBootFilter::Booted)
    {
        // Trigger the booting when buffering for booted subjects:
        BootAll();
    }
    
    SCOPE_CYCLE_COUNTER(STAT_MechanismBuffer);
    BufferingBelt->BufferDetailsFromBelt(Belt, Filter);
 
    return BufferingBelt;
}
 
FORCEINLINE class UBelt* UMechanism::DoBufferBelts(
    UBelt* BufferingBelt,
    const TArray<class UBelt*>& TargetBelts,
    const FFilter& Filter)
{
    if (Filter.GetBootFilter() == EBootFilter::Booted)
    {
        // Trigger the booting when buffering for booted subjects:
        BootAll();
    }
    SCOPE_CYCLE_COUNTER(STAT_MechanismBuffer);
    BufferingBelt->BufferDetailsFromBelts(TargetBelts, Filter);
 
    return BufferingBelt;
}
 
inline void UMechanism::DoFetchDetailsInAllBelts()
{
    SCOPE_CYCLE_COUNTER(STAT_MechanismFetchDetails);
    for (auto Belt : Belts)
    {
        if (Belt == nullptr)
            continue;
        Belt->FetchDetails();
    }
}
 
FORCEINLINE class UBelt*
UMechanism::BufferBelt(UObject* Mechanical,
                       class UBelt* Belt,
                       const FFilter& Filter)
{
    IMechanical* M = CastChecked<IMechanical>(Mechanical);
    return DoBufferBelt(M->GetBufferingBelt(), Belt, Filter);
}
 
FORCEINLINE class UBelt*
UMechanism::BufferBelts(UObject* Mechanical,
                        const TArray<class UBelt*>& TargetBelts,
                        const FFilter& Filter)
{
    IMechanical* M = CastChecked<IMechanical>(Mechanical);
    return DoBufferBelts(M->GetBufferingBelt(), TargetBelts, Filter);
}
 
FORCEINLINE void UMechanism::DoHandleChange(TScriptInterface<ISubjective> Subjective)
{
    check(Subjective);
    DoObtainMostSpecificBelt(GetTransientPackage(), Subjective)->Refresh(Subjective);
}
 
FORCEINLINE void UMechanism::DoHandleChange(TScriptInterface<ISubjective> Subjective,
                                            const TArray<UDetail*>& Details)
{
    check(Subjective);
    DoObtainMostSpecificBelt(GetTransientPackage(), Subjective)->Refresh(Subjective, Details);
}
 
FORCEINLINE void UMechanism::HandleChange(TScriptInterface<ISubjective> Subjective)
{
    DoHandleChange(Subjective);
}
 
FORCEINLINE void
UMechanism::FindMatchingBelts(const struct FFilter& Filter,
                             TArray<class UBelt*>& OutBelts)
{
    DoFindMatchingBelts(Filter, OutBelts);
}
 
FORCEINLINE void
UMechanism::GetBeltsMatchingFingerprint(const struct FFingerprint& Fingerprint,
                                        TArray<class UBelt*>& OutBelts)
{
    DoGetBeltsMatchingFingerprint(Fingerprint, OutBelts);
}
 
FORCEINLINE void
UMechanism::HandleChange(TScriptInterface<ISubjective> Subjective,
                         const TArray<UDetail*>& Details)
{
    DoHandleChange(Subjective, Details);
}
 
FORCEINLINE void UMechanism::RegisterSubjective(TScriptInterface<ISubjective> Subjective)
{
    DoRegister(Subjective);
}
 
FORCEINLINE void UMechanism::UnregisterSubjective(TScriptInterface<ISubjective> Subjective)
{
    DoUnregister(Subjective);
}
 
inline void UMechanism::RegisterMechanical(TScriptInterface<IMechanical> Mechanical)
{
    check(Mechanical);
    Mechanicals.Add(Mechanical.GetObject());
    // Make sure that all of the currently collected subjectives are in some belt.
    for (int32 i = 0; i < AllNotBooted.Num(); ++i)
    {
        if (!AllNotBooted[i].IsValid()) 
        {
            AllNotBooted.RemoveAt(i--);
            continue;
        }
        if (AllNotBooted[i]->GetSlot() != nullptr)
        {
            continue;
        }
        HandleChange(AllNotBooted[i].ToScriptInterface());
    }
}
 
inline UDetail* ISubjective::EnableDetail(TSubclassOf<UDetail> DetailType)
{
    if (GetFingerprint().ContainsDetail(DetailType))
    {
        // The detail is already available and is active.
        auto r = FindDetail(DetailType);
        check(r);
        return r;
    }
 
    // Try to find among existing details first,
    // including the inactive ones.
    const bool bIncludeDisabled = true;
    UDetail* Detail = FindDetail(DetailType, bIncludeDisabled);
    if (Detail)
    {
        if (!Detail->IsEnabled())
        {
            // Found an inactive detail.
            // Activate it and return.
            Detail->SetEnabled();
            return Detail;
        }
        return Detail;
    }
 
    // Create a new detail of a needed type.
    Detail = NewObject<UDetail>(this->_getUObject(), DetailType);
    check(Detail);
 
    GetDetailsRef().Add(Detail);
    GetFingerprint().Add(DetailType);
 
    checkSlow(FindDetailByType(DetailType));
 
    UMechanism::HandleChange(this->_getUObject());
    
    Detail->Activated();
 
    return Detail;
}
 
inline UDetail* ISubjective::AddDetail(TSubclassOf<UDetail> DetailType,
                                       const bool bReuseInactive)
{
    check(DetailType);
 
    if (bReuseInactive)
    {
        // Try to find an inactive detail.
 
        // In the UDetail case we can skip the IsA checks for a slight
        // performance benefit.
        if (UNLIKELY(DetailType == UDetail::StaticClass()))
        {
            for (auto Detail : GetDetailsRef())
            {
                if (!Detail)
                    continue;
                if (!Detail->IsEnabled())
                {
                    // Set the detail to be active and return it to the user.
                    Detail->SetEnabled(true);
                    return Detail;
                }
                return Detail;
            }
        }
        else
        {
            for (auto Detail : GetDetailsRef())
            {
                if (!Detail)
                    continue;
                if (Detail->IsEnabled())
                    continue;
                if (Detail->IsA(DetailType))
                {
                    // Set the detail to be active and return it to the user.
                    Detail->SetEnabled(true);
                    return Detail;
                }
            }
        }
    }
 
    // No existing inactive detail was found,
    // so create a new detail of a needed type.
    UDetail* Detail = NewObject<UDetail>(this->_getUObject(), DetailType);
    check(Detail);
 
    GetDetailsRef().Add(Detail);
    GetFingerprint().Add(DetailType);
 
    checkSlow(FindDetailByType(DetailType));
 
    UMechanism::HandleChange(this->_getUObject());
 
    Detail->Activated();
 
    return Detail;
}