UpdateWorldResourceNodes

/// For now, this destroys any meshes that aren't explicity marked as our randomized meshes
/// It also updates the locations of resource nodes based on raycasting if they haven't
/// been raycast before
/// Destroying any vanilla meshes on udpate may not be necessary, but requires more playtesting
/// @param World
void UResourceRouletteManager::UpdateWorldResourceNodes(const UWorld* World) const
{
    if (!World)
    {
        FResourceRouletteUtilityLog::Get().LogMessage("UpdateWorldResourceNodes aborted: World is invalid.",ELogLevel::Error);
        return;
    }

    if (!(bIsResourcesScanned && bIsResourcesRandomized && bIsResourcesSpawned))
    {
        FResourceRouletteUtilityLog::Get().LogMessage("Updating Skipped.", ELogLevel::Debug);
        return;
    }

    FVector PlayerLocation;
    APlayerController* PlayerController = UGameplayStatics::GetPlayerController(World, 0);
    if (PlayerController && PlayerController->GetPawn())
    {
        PlayerLocation = PlayerController->GetPawn()->GetActorLocation();
    }
    else
    {
        return;
    }

    const float UpdateRadius = 150000.0f;

    AResourceRouletteSubsystem* ResourceRouletteSubsystem = AResourceRouletteSubsystem::Get(World);
    if (!ResourceRouletteSubsystem)
    {
        FResourceRouletteUtilityLog::Get().LogMessage("ResourceRouletteSubsystem is invalid.", ELogLevel::Error);
        return;
    }

    TArray<FResourceNodeData> ProcessedNodes = ResourceRouletteSubsystem->GetSessionRandomziedResourceNodes();

    bool bNodeUpdated = false;
    for (FResourceNodeData& NodeData : ProcessedNodes)
    {
        if (!NodeData.IsRayCasted && FVector::Dist(NodeData.Location, PlayerLocation) <= UpdateRadius)
        {
            UResourceRouletteUtility::CalculateLocationAndRotationForNode(NodeData, World);
            bNodeUpdated = true;

            if (AFGResourceNode** ResourceNodePtr = ResourceNodeSpawner->GetSpawnedResourceNodes().Find(NodeData.NodeGUID))
            {
                AFGResourceNode* ResourceNode = *ResourceNodePtr;
                ResourceNode->SetActorLocation(NodeData.Location, false, nullptr, ETeleportType::TeleportPhysics);
                ResourceNode->SetActorRotation(NodeData.Rotation, ETeleportType::TeleportPhysics);

                if (UStaticMeshComponent* MeshComponent = ResourceNode->FindComponentByClass<UStaticMeshComponent>())
                {
                    FResourceRouletteUtilityLog::Get().LogMessage(FString::Printf(TEXT("Updating MeshComponent Location to: %s, Rotation to: %s"),
                        *NodeData.Location.ToString(), *NodeData.Rotation.ToString()),  ELogLevel::Debug);
                    MeshComponent->SetWorldLocation(NodeData.Location, false, nullptr, ETeleportType::TeleportPhysics);
                    MeshComponent->SetWorldRotation(NodeData.Rotation, false, nullptr, ETeleportType::TeleportPhysics);
                }
            }
        }
    }
    if (bNodeUpdated)
    {
        ResourceRouletteSubsystem->SetSessionRandomizedResourceNodes(ProcessedNodes);
    }

    for (TObjectIterator<UStaticMeshComponent> It; It; ++It)
    {
        UStaticMeshComponent* StaticMeshComponent = *It;
        if (StaticMeshComponent && StaticMeshComponent->GetWorld() == World && !StaticMeshComponent->ComponentTags.
            Contains(ResourceRouletteTag))
        {
            if (const UStaticMesh* StaticMesh = StaticMeshComponent->GetStaticMesh())
            {
                FName MeshPath = FName(*StaticMesh->GetPathName());

                if (MeshesToDestroy.Contains(MeshPath))
                {
                    StaticMeshComponent->SetActive(false);
                    StaticMeshComponent->SetVisibility(false);
                    StaticMeshComponent->DestroyComponent();
                }
            }
        }
    }
}