Walker.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 "Walker.h"
 
#include "NavigationSystem.h"
#include "Kismet/KismetMathLibrary.h" 
#include "AIController.h"
#include "Navigation/PathFollowingComponent.h"
#include "Agrarsense/JSON/SimulatorJsonExporter.h"
#include "Agrarsense/Sensor/SensorFactory.h"
#include "Agrarsense/Sensor/Transform/TransformSensor.h"
 
#ifdef WITH_EDITOR
#include "DrawDebugHelpers.h"
#endif
 
AWalker::AWalker()
{
    PrimaryActorTick.bCanEverTick = false;
    InteractableName = NSLOCTEXT("Agrarsense", "WalkerInteractableName", "Walker");
}
 
void AWalker::BeginPlay()
{
    Super::BeginPlay();
 
    if (WalkerParameters.CreateTransformTopic && !TransformSensor)
    {
        FString TransformSensorID = ActorID + "/transform";
 
        FSensorSpawnParameters SpawnParams;
        SpawnParams.Transform = GetActorTransform();
        SpawnParams.SensorIdentifier = TransformSensorID;
        SpawnParams.SensorName = "transform";
        SpawnParams.SimulateSensor = true;
        SpawnParams.Parent = this;
 
        FTransformSensorParameters Params;
        Params.SaveTransformDataToDisk = false;
        Params.OwningActor = this;
 
        TransformSensor = USensorFactory::SpawnTransformSensor(SpawnParams, Params);
    }
}
 
void AWalker::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);
 
    if (TransformSensor) 
    {
        TransformSensor->Destroy();
    }
}
 
void AWalker::PauseWalker()
{
    PreviousParameters = WalkerParameters;
    WalkerParameters.WalkerAction = EWalkerAction::Stationary;
    SetIgnoreInput(true);
    ChangeWalkerParameters(WalkerParameters);
}
 
void AWalker::ResumeWalker()
{
    if (WalkerIsPaused)
    {
        WalkerParameters = PreviousParameters;
        SetIgnoreInput(false);
        ChangeWalkerParameters(WalkerParameters);
    }
}
 
void AWalker::SetIgnoreInput(bool IgnoreInput)
{
    WalkerIsPaused = IgnoreInput;
 
    AAIController* AIControllerPtr = Cast<AAIController>(GetController());
    if (AIControllerPtr)
    {
        AIControllerPtr->SetIgnoreMoveInput(WalkerIsPaused);
    }
}
 
void AWalker::SetWalkerParameters(const FWalkerParameters& InParameters)
{
    WalkerParameters = InParameters;
}
 
FString AWalker::ExportToJsonFile(const FString& FileName)
{
    return USimulatorJsonExporter::ExportWalkerToJSON(FileName, this);
}
 
void AWalker::DebugDrawLinesBetweenPoints(float LifeTime)
{
#ifdef WITH_EDITOR
    if (WalkerParameters.WalkerAction != EWalkerAction::FollowPath)
    {
        return;
    }
 
    TArray<FTransform>& Transforms = WalkerParameters.Points;
 
    // Draw lines between the points
    for (int32 i = 0; i < Transforms.Num() - 1; ++i)
    {
        const FVector Start = Transforms[i].GetLocation();
        const FVector End = Transforms[i + 1].GetLocation();
        DrawDebugLine(GetWorld(), Start, End, FColor::Green, false, LifeTime, 0, 5);
    }
#endif
}