ActorInformation.cpp

Go to the documentation of this file.

// Copyright (c) 2023 FrostBit Software Lab at the Lapland University of Applied Sciences
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#include "ActorInformation.h"
 
#include "Agrarsense/Logging/SimulatorLog.h"
 
#include "Engine/GameViewportClient.h"
#include "Engine/World.h"
#include "Engine.h"
 
#include "Kismet/GameplayStatics.h"
#include "GameFramework/Actor.h"
#include "Containers/Map.h"
#include "Misc/Guid.h"
 
struct IdentifierData
{
    FString ID = "";
    TWeakObjectPtr<AActor> Actor;
    int32 Count = 1;
};
 
static TMap<FString, IdentifierData> ExistingIDs;
 
FString IActorInformation::ValidateID(const FString& ActorID, TWeakObjectPtr<AActor> Actor)
{
    FString ActorIDLower = ActorID.ToLower();
    FString FinalID = ActorIDLower;
 
    // Check if the ID already exists
    if (ExistingIDs.Contains(FinalID))
    {
        IdentifierData& Data = ExistingIDs[FinalID];
 
        if (!Data.Actor.IsValid())
        {
            // Reuse the ID if the existing Actor no longer exists.
            Data.Actor = Actor;
            return FinalID;
        }
 
        // Append the count as a numerical suffix
        FinalID = ActorIDLower + FString::Printf(TEXT("%d"), Data.Count);
 
        while (ExistingIDs.Contains(FinalID))
        {
            // If the new ID exists, keep incrementing the count
            Data.Count++;
            FinalID = ActorIDLower + FString::Printf(TEXT("%d"), Data.Count);
        }
    }
 
    // Add the final ID to the map
    ExistingIDs.Add(FinalID, IdentifierData{ FinalID, Actor });
 
    return FinalID;
}
 
FString IActorInformation::GenerateUniqueID()
{
    return FGuid::NewGuid().ToString(EGuidFormats::DigitsWithHyphensLower);
}
 
void IActorInformation::SetAndValidateActorIDAndName(FString& ActorName, FString& ActorID, TWeakObjectPtr<AActor> Actor)
{
    if (!Actor.IsValid())
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("IActorID.cpp: Invalid Actor!"));
#endif
        return;
    }
 
    if (ActorName.IsEmpty())
    {
        // If the given Actor name is empty, use Actor actual name or label as name
        // this name is used for Unreal UI side only.
        ActorName = Actor->GetActorNameOrLabel();
    }
 
    if (!ActorID.IsEmpty())
    {
        // Validate the ID, If same ID exists, ValidateID adds available number at the end: Actor1..Actor2..ActorN
        ActorID = ValidateID(ActorID, Actor);
    }
    else
    {
        // If given Actor ID is empty, generate unique ID (long string)
        ActorID = GenerateUniqueID();
    }
}
 
bool IActorInformation::DestroyActorByID(const FString& ID)
{
    if (!GEngine || !GEngine->GameViewport)
    {
        return false;
    }
 
    TArray<AActor*> ActorsWithInterface;
    UWorld* World = GEngine->GameViewport->GetWorld();
    UGameplayStatics::GetAllActorsWithInterface(World, UActorInformation::StaticClass(), ActorsWithInterface);
 
    // All ID's are in lowercase.
    FString IDLowered = ID.ToLower();
 
    for (AActor* Actor : ActorsWithInterface)
    {
        FString ActorID = IActorInformation::Execute_GetActorID(Actor);
        if (ActorID == IDLowered)
        {
            return Actor->Destroy();
        }
    }
 
    return false;
}
 
AActor* IActorInformation::GetActorByID(const FString& ID)
{
    if (!GEngine || !GEngine->GameViewport)
    {
        return nullptr;
    }
 
    TArray<AActor*> ActorsWithInterface;
    UWorld* World = GEngine->GameViewport->GetWorld();
    UGameplayStatics::GetAllActorsWithInterface(World, UActorInformation::StaticClass(), ActorsWithInterface);
 
    // All ID's are in lowercase.
    FString IDLowered = ID.ToLower();
 
    for (AActor* Actor : ActorsWithInterface)
    {
        if (Actor)
        {
            FString ActorID = IActorInformation::Execute_GetActorID(Actor);
            if (ActorID == IDLowered)
            {
                return Actor;
            }
        }
    }
 
    return nullptr;
}
 
template<typename T>
TArray<T*> IActorInformation::GetActorsWithInterface()
{
    if (!GEngine || !GEngine->GameViewport)
    {
        return TArray<T*>();
    }
 
    TArray<AActor*> ActorsWithInterface;
    UWorld* World = GEngine->GameViewport->GetWorld();
    UGameplayStatics::GetAllActorsWithInterface(World, UActorInformation::StaticClass(), ActorsWithInterface);
 
    // Convert the TArray<AActor*> to TArray<T*>
    TArray<T*> ConvertedActors;
    for (AActor* Actor : ActorsWithInterface)
    {
        T* TypedActor = Cast<T>(Actor);
        if (TypedActor)
        {
            ConvertedActors.Add(TypedActor);
        }
    }
 
    return ConvertedActors;
}
 
void IActorInformation::PrintAllIds()
{
    FString Message = "IDs: ";
    int32 NumIds = ExistingIDs.Num();
 
    // Iterate through the ExistingIDs map
    int32 IdCounter = 0;
    for (auto It = ExistingIDs.CreateIterator(); It; ++It)
    {
        if (It.Value().Actor.IsValid())
        {
            // Append the ID to the Message string
            Message += FString::Printf(TEXT("%s"), *It.Key());
            if (++IdCounter < NumIds)
            {
                // Add a comma if it's not the last value
                Message += TEXT(", ");
            }
        }
        else
        {
            // Remove entries with nullptr actors
            It.RemoveCurrent();
        }
    }
 
    SimulatorLog::Log(Message);
}
 
#if WITH_EDITOR
void IActorInformation::ClearTMapEditor()
{
    ExistingIDs.Empty();
}
#endif