Walker.h

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>.
 
#pragma once
 
#include "CoreMinimal.h"
#include "GameFramework/Character.h"
 
#include "Agrarsense/Utils/EnumUtilities.h"
#include "Agrarsense/ActorInterfaces/ActorInformation.h"
#include "Agrarsense/ActorInterfaces/Interactable.h"
#include "Agrarsense/ActorInterfaces/Destroyable.h"
#include "WalkerParameters.h"
 
#include "Walker.generated.h"
 
class ATransformSensor;
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FWalkerEventDelegate_ParametersChanged, FWalkerParameters, NewWalkerParameters);
 
/*
* Base class for all Walkers.
* Actual movement logic is defined in BP_WalkerBase blueprint
* and individual Walkers blueprints like BP_Reindeer.
*/
UCLASS()
class AGRARSENSE_API AWalker : public ACharacter, public IInteractable, public IDestroyable, public IActorInformation
{
    GENERATED_BODY()
 
public:
 
    AWalker();
 
    UFUNCTION(BlueprintCallable)
    virtual void PauseWalker();
 
    UFUNCTION(BlueprintCallable)
    virtual void ResumeWalker();
 
    UFUNCTION(BlueprintCallable)
    virtual void SetIgnoreInput(bool IgnoreInput);
 
    void SetWalkerParameters(const FWalkerParameters& InParameters);
 
    UFUNCTION(BlueprintCallable)
    FString ExportToJsonFile(const FString& FileName);
 
    UFUNCTION(BlueprintCallable)
    void ChangeWalkerParameters(const FWalkerParameters& newParameters)
    {
        SetWalkerParameters(newParameters);
        OnWalkerParametersChanged.Broadcast(WalkerParameters);
    }
 
    UFUNCTION(BlueprintCallable)
    void DebugDrawLinesBetweenPoints(float LifeTime = 10.0f);
 
    UFUNCTION(BlueprintCallable)
    virtual EWalkerType GetWalkerType() const
    {
        return WalkerParameters.WalkerType;
    }
 
    UFUNCTION(BlueprintPure)
    FWalkerParameters GetWalkerParameters() const
    {
        return WalkerParameters;
    }
 
    UFUNCTION(BlueprintCallable)
    FTransform GetStartTransform() const
    {
        if (!WalkerParameters.Points.IsEmpty())
        {
            return WalkerParameters.Points[0];
        }
 
        return FTransform::Identity;
    }
 
    UFUNCTION(BlueprintCallable)
    FTransform GetEndTransform() const
    {
        if (!WalkerParameters.Points.IsEmpty())
        {
            return WalkerParameters.Points.Last();
        }
 
        return FTransform::Identity;
    }
 
    UFUNCTION(BlueprintPure)
    bool IsWalkerPaused() const
    {
        return WalkerIsPaused;
    }
 
    virtual FText GetInteractableName_Implementation() const override
    {
        return InteractableName;
    }
 
    virtual FTransform GetInteractableWorldTransform_Implementation() const override
    {
        return GetActorTransform();
    }
 
    virtual FString GetActorID_Implementation() const override
    {
        return ActorID;
    }
 
    virtual FString GetActorName_Implementation() const override
    {
        return ActorName;
    }
 
    virtual FString GetActorInformation_Implementation() const override
    {
        const FString Walker = UEnumUtilities::ConvertWalkerTypeToString(WalkerParameters.WalkerType);
        const FString ID = IActorInformation::Execute_GetActorID(this);
        const FString Name = IActorInformation::Execute_GetActorName(this);
        const FTransform VehicleTransform = GetActorTransform();
        const FVector Location = VehicleTransform.GetLocation();
        const FRotator Rotation = VehicleTransform.Rotator();
        FString Information = FString::Printf(TEXT("Walker: %s, Name: %s, ID: %s, Location: %s, Rotation: %s"), *Walker, *Name, *ID, *Location.ToString(), *Rotation.ToString());
 
        return Information;
    }
 
    virtual void SetActorName_Implementation(const FString& NewActorName) override
    {
        ActorName = NewActorName;
    }
 
    virtual void SetActorIDAndName_Implementation(const FString& NewActorName, const FString& NewID) override
    {
        ActorName = NewActorName;
        ActorID = NewID;
        SetAndValidateActorIDAndName(ActorName, ActorID, TWeakObjectPtr<AActor>(this));
    }
 
    UPROPERTY(BlueprintAssignable)
    FWalkerEventDelegate_ParametersChanged OnWalkerParametersChanged;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Interactable")
    FText InteractableName;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    ATransformSensor* TransformSensor = nullptr;
 
protected:
 
    virtual void BeginPlay() override;
 
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
    UPROPERTY(VisibleAnywhere)
    FString ActorName;
 
    UPROPERTY(VisibleAnywhere)
    FString ActorID;
 
private:
 
    UPROPERTY(VisibleAnywhere, Category = "Walker")
    bool WalkerIsPaused = true;
 
    UPROPERTY(VisibleAnywhere, Category = "Walker")
    FWalkerParameters WalkerParameters;
 
    FWalkerParameters PreviousParameters;
 
};