Belt.h

/*
 * ░▒▓ APPARATUS ▓▒░
 * 
 * File: Belt.cpp
 * Created: Friday, 23rd October 2020 7:00:48 pm
 * Author: Vladislav Dmitrievich Turbanov (vladislav@turbanov.ru)
 * ───────────────────────────────────────────────────────────────────
 * Last Modified: Saturday, 3rd April 2021 5:21:16 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 "Subjective.h"
#include "BeltSlot.h"
#include "Components/ActorComponent.h"
#include "CoreMinimal.h"
#include "Fingerprint.h"
#include "Filter.h"
#include "UObject/NoExportTypes.h"
 
#include "Belt.generated.h"
 
DECLARE_STATS_GROUP(TEXT("Belt"), STATGROUP_Belt, STATCAT_Advanced);
 
FORCEINLINE uint32 GetTypeHash(const TArray<const UClass*>& Types)
{
    uint32 h = 0;
    for (auto Type : Types)
    {
        h += Type->GetUniqueID();
    }
    return h;
}
 
FORCEINLINE uint32 GetTypeHash(const TArray<UClass*>& Types)
{
    uint32 h = 0;
    for (auto Type : Types)
    {
        h += Type->GetUniqueID();
    }
    return h;
}
 
UCLASS(BlueprintType)
class APPARATUSRUNTIME_API UBelt : public UObject
{
    GENERATED_BODY()
 
    
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Belt,
              Meta = (AllowPrivateAccess = "true"))
    FFilter Filter;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Transient, Category = Belt,
              Meta = (AllowPrivateAccess = "true"))
    int32 Count = 0;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Transient, Category = Belt,
              Meta = (AllowPrivateAccess = "true"))
    uint32 bBuffering : 1;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Belt,
              Meta = (AllowPrivateAccess = "true"))
    uint32 bSparse : 1;
 
  public:
 
    static const int32 InvalidSlotIndex = FBeltSlot::InvalidIndex;
 
    FORCEINLINE bool IsBuffering() const { return bBuffering; }
 
    FORCEINLINE bool IsSparse() const { return bSparse; }
 
    FORCEINLINE const FFilter& GetFilter() const
    {
        return Filter;
    }
 
    class iterator
    {
        UBelt* Owner = nullptr;
 
        int32 Index = -1;
 
        friend class UBelt;
 
        iterator(UBelt* o, int32 i) : Owner(o), Index(i) {}
 
      public:
        FORCEINLINE iterator& operator++()
        {
            check(Owner != nullptr);
            check(Index != -1);
            Index = Owner->GetNextSlotIndex(Index);
            return *this;
        }
 
        FORCEINLINE iterator operator++(int)
        {
            check(Owner != nullptr);
            check(Index != -1);
            const auto IndexSave = Index;
            Index = Owner->GetNextSlotIndex(Index);
            return iterator(Owner, IndexSave);
        }
 
        FORCEINLINE bool operator==(const iterator& other) const
        {
            check(Owner != nullptr);
            if (Owner != other.Owner)
                return false;
            if (Index == other.Index)
                return true;
            if (Index >= Owner->Num() && other.Index == -1)
                return true;
            if (other.Index >= other.Owner->Num() && Index == -1)
                return true;
            return false;
        }
 
        FORCEINLINE bool operator!=(const iterator& other) const
        {
            check(Owner != nullptr);
            if (Owner != other.Owner)
                return true;
            if (Index == other.Index)
                return false;
            if (Index >= Owner->Num() && other.Index == -1)
                return false;
            if (other.Index >= other.Owner->Num() && Index == -1)
                return false;
            return true;
        }
 
        FORCEINLINE FBeltSlot& operator*()
        {
            check(Owner != nullptr);
            check(Index != -1);
            return Owner->Slots[Index];
        }
    }; // class iterator
 
  private:
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Transient, Category = Belt,
              Meta = (AllowPrivateAccess = "true"))
    TArray<FBeltSlot> Slots;
 
    FBeltSlot EndSlot;
 
    friend struct FBeltSlot;
    friend class USubjectiveActorComponent;
    friend class USubjectiveUserWidget;
    friend class UDetail;
    friend class UMechanism;
    friend class FApparatusRuntimeModule;
 
    UBelt();
 
    ~UBelt();
 
    const static TArray<UBelt*> NoBelts;
 
  public:
    bool Expand(const FFingerprint& NewFingerprint,
                const EBootFilter BootFilter = EBootFilter::None);
 
    FORCEINLINE int32 Num() const { return Count; }
 
    FORCEINLINE int32 GetCount() const { return Count; }
 
    FORCEINLINE FBeltSlot& operator[](int32 Index)
    {
        return Slots[Index];
    }
 
    FORCEINLINE const FBeltSlot& operator[](int32 Index) const
    {
        return Slots[Index];
    }
 
    FORCEINLINE iterator begin()
    {
        auto& f = GetFirstSlot();
        if (!f.IsValid())
            return end();
        return iterator(this, f.Index);
    }
 
    FORCEINLINE iterator end() { return iterator(this, -1); }
 
    void FetchDetails();
 
    UFUNCTION(BlueprintCallable, Category = "Apparatus")
    void BufferDetailsFromBelt(UBelt* Belt,
                               const FFilter& TargetFilter);
 
    UFUNCTION(BlueprintCallable, Category = "Apparatus")
    void BufferDetailsFromBelts(const TArray<class UBelt*>& Belts,
                                const FFilter& TargetFilter);
 
    void Refresh(TScriptInterface<ISubjective> Subjective);
 
    void Refresh(TScriptInterface<ISubjective> Subjective,
                 const TArray<class UDetail*>& Details);
 
    bool Remove(TScriptInterface<ISubjective> Subjective);
 
    static class UBelt* New(UObject* Owner,
                            const FFingerprint& Fingerprint);
 
    static class UBelt* New(UObject* Owner,
                            const FName& Name,
                            const FFingerprint& Fingerprint);
 
    static class UBelt* New(UObject* Owner,
                            const FName& Name,
                            const FFingerprint& Fingerprint,
                            const EBootFilter BootFilter);
 
    static class UBelt* NewBuffering(UObject* Owner);
 
    bool Matches(const FFilter& Filter) const;
 
    FBeltSlot& Remove(FBeltSlot& slot);
 
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "Apparatus")
    static UDetail* GetDetailFromSlotByIndex(const FBeltSlot& Slot,
                                             const int32 DetailIndex);
 
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "Apparatus",
              Meta = (DeterminesOutputType = "DetailType", KeyWords = "belt"))
    static UDetail* GetDetailFromSlot(const FBeltSlot& Slot,
                                      const TSubclassOf<UDetail> DetailType);
 
    UFUNCTION(BlueprintCallable, Category = "Apparatus",
              Meta = (DeterminesOutputType = "DetailType"))
    UDetail* GetDetailFromSlotAtIndex(const int32 SlotIndex,
                                      const TSubclassOf<UDetail> DetailType) const;
 
    UFUNCTION(BlueprintCallable, Category = "Apparatus",
              Meta = (DeterminesOutputType = "DetailType",
                      BlueprintInternalUseOnly))
    UDetail*
    GetDetailFromSlotAtIndexHinted(const int32 SlotIndex,
                                   const TSubclassOf<UDetail> DetailType,
                                   const int32 IndexHint);
 
    UFUNCTION(BlueprintCallable, Category = "Apparatus")
    TScriptInterface<ISubjective>
    GetSubjectFromSlotAtIndex(const int32 SlotIndex);
 
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "Apparatus",
              Meta = (KeyWords = "belt"))
    static bool IsEndSlot(const FBeltSlot& Slot);
 
    UFUNCTION(BlueprintCallable, Category = "Apparatus")
    FBeltSlot& GetFirstSlot();
 
    UFUNCTION(BlueprintCallable, Category = "Apparatus",
              Meta = (KeyWords = "belt"))
    static FBeltSlot& GetNextSlot(const FBeltSlot& Slot);
 
    UFUNCTION(BlueprintCallable, Category = "Apparatus")
    int32 GetFirstSlotIndex();
 
    UFUNCTION(BlueprintCallable, Category = "Apparatus")
    int32 GetNextSlotIndex(const int32 SlotIndex);
 
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "Apparatus")
    FBeltSlot& GetEndSlot();
}; // class UBelt
 
FORCEINLINE FBeltSlot& UBelt::GetEndSlot() { return EndSlot; }
 
FORCEINLINE bool UBelt::IsEndSlot(const FBeltSlot& Slot)
{
    if (Slot.Owner == nullptr)
        return true;
    return !Slot.IsValid();
}
 
FORCEINLINE bool UBelt::Matches(const FFilter& InFilter) const
{
    if (!bSparse)
    {
        return Filter.Matches(InFilter);
    }
    // Sparse belts may actually have holes,
    // so the details <- filter exclusions are tested during the iteration, not here.
    // Only the belt exclusions -> filter details is tested here.
    return Filter.GetDetailsMask().Includes(InFilter.GetDetailsMask()) &&
           !Filter.GetExcludedDetailsMask().IncludesPartially(InFilter.GetDetailsMask());
}
 
FORCEINLINE UDetail* UBelt::GetDetailFromSlotByIndex(const FBeltSlot& Slot,
                                                     const int32 DetailIndex)
{
    return Slot.GetDetail(DetailIndex);
}
 
FORCEINLINE UDetail*
UBelt::GetDetailFromSlot(const FBeltSlot& Slot,
                         const TSubclassOf<UDetail> DetailType)
{
    return Slot.GetDetail(DetailType);
}
 
FORCEINLINE UDetail*
UBelt::GetDetailFromSlotAtIndex(const int32 SlotIndex,
                                const TSubclassOf<UDetail> DetailType) const
{
    const FBeltSlot& Slot = Slots[SlotIndex];
    return Slot.GetDetail(DetailType);
}
 
FORCEINLINE UDetail*
UBelt::GetDetailFromSlotAtIndexHinted(const int32 SlotIndex,
                                      const TSubclassOf<UDetail> DetailType,
                                      const int32 IndexHint)
{
    const FBeltSlot& Slot = Slots[SlotIndex];
    UDetail* rDetail = Slot.GetDetail(IndexHint);
    checkfSlow(rDetail->IsA(DetailType),
               TEXT("The hinted type is not the same."));
    return rDetail;
}
 
FORCEINLINE TScriptInterface<ISubjective>
UBelt::GetSubjectFromSlotAtIndex(const int32 SlotIndex)
{
    const FBeltSlot& Slot = Slots[SlotIndex];
    return Slot.GetSubjective();
}
 
FORCEINLINE int32
UBelt::GetFirstSlotIndex()
{
    if (Count == 0)
    {
        return InvalidSlotIndex;
    }
    const FBeltSlot& Slot = GetFirstSlot();
    if (Slot.IsValid())
    {
        return Slot.GetIndex();
    }
    // No valid slot was found.
    return InvalidSlotIndex;
}
 
FORCEINLINE int32
UBelt::GetNextSlotIndex(const int32 SlotIndex)
{
    if (SlotIndex >= Count)
        return InvalidSlotIndex;
    if (SlotIndex < 0)
        return InvalidSlotIndex;
    FBeltSlot& Slot = Slots[SlotIndex];
    FBeltSlot& Next = Slot.GetNext();
    if (Next.IsValid())
    {
        return Next.GetIndex();
    }
    return InvalidSlotIndex;
}
 
FORCEINLINE FBeltSlot&
UBelt::GetNextSlot(const FBeltSlot& Slot)
{
    return ((FBeltSlot&)Slot).GetNext();
}
 
// BEGIN - Belt slot inlines.
 
FORCEINLINE FBeltSlot::FBeltSlot(class UBelt* Belt) : Owner(Belt) 
{ 
    Index = Belt->Slots.Num(); 
}
 
FORCEINLINE bool FBeltSlot::IsValid() const
{
    return Subjective != nullptr && Owner != nullptr && Index >= 0 &&
           Index < Owner->Num();
}
 
FORCEINLINE bool FBeltSlot::IsBuffering() const
{
    return GetOwner()->IsBuffering();
}
 
FORCEINLINE const FFilter& FBeltSlot::GetFilter() const
{
    return GetOwner()->GetFilter();
}
 
// END - Belt slot inlines.