Subjective.h

/*
 * ░▒▓ APPARATUS ▓▒░
 * 
 * File: Subjective.h
 * Created: Friday, 23rd October 2020 7:00:48 pm
 * Author: Vladislav Dmitrievich Turbanov (vladislav@turbanov.ru)
 * ───────────────────────────────────────────────────────────────────
 * Last Modified: Tuesday, 6th April 2021 1:37:06 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 "CoreMinimal.h"
#include "UObject/Interface.h"
 
#include "BeltSlot.h"
#include "Detail.h"
#include "Fingerprint.h"
 
#include "Subjective.generated.h"
 
UINTERFACE(MinimalAPI, BlueprintType)
class USubjective : public UInterface
{
    GENERATED_BODY()
};
 
class APPARATUSRUNTIME_API ISubjective
{
    GENERATED_BODY()
 
    friend struct FFingerprint;
    friend struct FBeltSlot;
    friend class UDetail;
    friend class UBelt;
    friend class UMechanism;
    friend class UApparatusFunctionLibrary;
 
    static TArray<UDetail*> EmptyDetails;
 
  protected:
 
    void MarkBooted();
 
    FORCEINLINE virtual void TakeBeltSlot(class UBelt* InBelt, int32 InSlotIndex)
    {
        unimplemented();
    }
 
    FORCEINLINE virtual TArray<UDetail*>& GetDetailsRef()
    {
        EmptyDetails.Reset();
        return EmptyDetails;
    }
 
    FORCEINLINE virtual const TArray<UDetail*>& GetDetailsRef() const
    {
        EmptyDetails.Reset();
        return EmptyDetails;
    }
 
    virtual FFingerprint& GetFingerprint()
    {
        static FFingerprint Tmp;
        Tmp.Reset();
        return Tmp;
    }
 
  public:
 
    static const int32 InvalidSlotIndex = FBeltSlot::InvalidIndex;
 
    virtual const FFingerprint& GetFingerprint() const
    {
        return FFingerprint::ZERO;
    }
 
    FORCEINLINE bool Matches(const FFilter& Filter) const
    {
        return GetFingerprint().Matches(Filter);
    }
 
    void GetDetails(const bool bIncludeDisabled,
                    TArray<UDetail*>& OutDetails) const;
 
    UDetail*
    FindDetail(TSubclassOf<UDetail> DetailType,
               const bool bIncludeDisabled = false) const;
 
    void
    FindDetails(TSubclassOf<UDetail> DetailType,
                TArray<UDetail*>& OutDetails,
                const bool bIncludeDisabled = false) const;
 
    bool
    HasDetail(TSubclassOf<UDetail> DetailType,
              const bool bIncludeDisabled = false) const;
 
    FORCEINLINE virtual class UBelt* GetPreferredBelt() const
    {
        return nullptr;
    }
 
    class UDetail*
    EnableDetail(TSubclassOf<UDetail> DetailType);
 
    class UDetail*
    AddDetail(TSubclassOf<UDetail> DetailType,
              const bool bReuseInactive = false);
 
    bool DisableDetail(TSubclassOf<UDetail> DetailType, const bool bDisableMultiple = false);
 
    FORCEINLINE virtual struct FBeltSlot* GetSlot() const { return nullptr; }
 
    FORCEINLINE bool IsBooted() const 
    {
        return GetFingerprint().IsBooted();
    }
 
    FORCEINLINE virtual uint32 GetHash() const 
    {
        return (uint32)((uint64)this % (uint64)TNumericLimits<uint32>::Max());
    }
}; // class ISubjective
 
FORCEINLINE uint32 GetTypeHash(const TWeakInterfacePtr<ISubjective>& Subjective)
{
    return Subjective->GetHash();
}
 
FORCEINLINE void ISubjective::MarkBooted()
{
    GetFingerprint().SetBooted();
}
 
inline void ISubjective::GetDetails(const bool bIncludeDisabled,
                                    TArray<UDetail*>& OutDetails) const
{
    OutDetails.Reset();
    if (bIncludeDisabled)
    {
        OutDetails.Append(GetDetailsRef());
    }
    else
    {
        for (auto Detail : GetDetailsRef())
        {
            if (Detail == nullptr)
                continue;
            if (!Detail->IsEnabled())
                continue;
 
            OutDetails.Add(Detail);
        }
    }
}
 
inline bool ISubjective::HasDetail(const TSubclassOf<UDetail> Type,
                                   const bool bIncludeDisabled) const
{
    check(Type);
 
    if (GetFingerprint().ContainsDetail(Type))
    {
        return true;
    }
 
    if (!bIncludeDisabled)
    {
        return false;
    }
 
    // In the UDetail case we can skip the IsA checks for a slight performance
    // benefit.
    if (UNLIKELY(Type == UDetail::StaticClass()))
    {
        for (auto Detail : GetDetailsRef())
        {
            if (!Detail)
            {
                continue;
            }
            return true;
        }
    }
    else
    {
        for (auto Detail : GetDetailsRef())
        {
            if (!Detail)
            {
                continue;
            }
            if (Detail->IsA(Type))
            {
                return true;
            }
        }
    }
    return false;
}
 
inline UDetail* ISubjective::FindDetail(TSubclassOf<UDetail> Type,
                                        const bool bIncludeDisabled) const
{
    check(Type);
 
    // In the UDetail case we can skip the IsA checks for a slight performance
    // benefit.
    if (UNLIKELY(Type == UDetail::StaticClass()))
    {
        for (UDetail* Detail : GetDetailsRef())
        {
            if (!Detail)
                continue;
            if (!bIncludeDisabled && !Detail->IsEnabled())
                continue;
            return Detail;
        }
    }
    else
    {
        for (UDetail* Detail : GetDetailsRef())
        {
            if (!Detail)
                continue;
            if (!bIncludeDisabled && !Detail->IsEnabled())
                continue;
            if (Detail->IsA(Type))
            {
                return Detail;
            }
        }
    }
    return nullptr;
}
 
inline void ISubjective::FindDetails(const TSubclassOf<UDetail> DetailType,
                                     TArray<UDetail*>& DetailsOut,
                                     const bool bIncludeDisabled) const
{
    check(DetailType);
    DetailsOut.Reset();
 
    const TArray<UDetail*>& Details = GetDetailsRef();
 
    // In the UDetail case we can skip the IsA checks for a slight
    // performance benefit
    if (UNLIKELY(DetailType == UDetail::StaticClass()))
    {
        if (UNLIKELY(bIncludeDisabled))
        {
            DetailsOut.Reserve(Details.Num());
            for (UDetail* Detail : Details)
            {
                if (!Detail)
                    continue;
                DetailsOut.Add(Detail);
            }
        }
        else
        {
            for (UDetail* Detail : Details)
            {
                if (!Detail)
                    continue;
                if (!Detail->IsEnabled())
                    continue;
                DetailsOut.Add(Detail);
            }
        }
    }
    else
    {
        for (UDetail* Detail : Details)
        {
            if (!Detail)
                continue;
            if (!bIncludeDisabled && !Detail->IsEnabled())
                continue;
            if (Detail->IsA(DetailType))
            {
                DetailsOut.Add(Detail);
            }
        }
    }
}
 
inline bool ISubjective::DisableDetail(TSubclassOf<UDetail> DetailType,
                                       const bool bDisableMultiple)
{
    checkf(DetailType != nullptr,
           TEXT("The detail type must be provided to be disabled on %s"),
           *this->_getUObject()->GetName());
    // Check if the detail is in a current fingerprint first.
    if (!GetFingerprint().ContainsDetail(DetailType))
    {
        return false;
    }
 
    checkSlow(FindDetail(DetailType) != nullptr);
 
    for (auto Detail : GetDetailsRef())
    {
        if (!Detail)
            continue;
        if (!Detail->IsEnabled())
            continue;
        if (Detail->IsA(DetailType))
        {
            // The following detail method will handle the
            // fingerprint and the slot change,
            // and the event calling.
            Detail->SetEnabled(false);
            if (!bDisableMultiple)
            {
                return true;
            }
        }
    }
    return true;
}