PIDDrone.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 "Vehicle.h"
#include "DroneParameters.h"
#include "PIDDrone.generated.h"
 
class USkeletalMeshComponent;
class UStaticMeshComponent;
 
UCLASS()
class AGRARSENSE_API APIDDrone : public AVehicle
{
    GENERATED_BODY()
 
public:
 
    APIDDrone();
 
    virtual EVehicleTypes GetVehicleType() const override { return EVehicleTypes::Drone; }
 
    virtual FTransform GetInteractableWorldTransform_Implementation() const override
    {
        if (mesh)
        {
            return mesh->GetComponentTransform();
        }
        else
        {
            return GetActorTransform();
        }
    }
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    void SetDroneAction(EDroneAction mode)
    {
        DroneParameters.DroneAction = mode;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    EDroneAction GetDroneAction() const
    {
        return DroneParameters.DroneAction;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    FDroneParameters GetDroneParameters() const
    {
        return DroneParameters;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    void ChangeDroneParameters(const FDroneParameters& newParameters)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("Parameters Changed!"));
#endif
        SetDroneParameters(newParameters);
    }
 
    void SetDroneParameters(const FDroneParameters& InParameters)
    {
        DroneParameters = InParameters;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    void AddWayPoint(FVector Waypoint)
    {
        FTransform transform;
        transform.SetLocation(Waypoint);
 
        DroneParameters.Points.Add(transform);
    }
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    void ClearWaypoints()
    {
        DroneParameters.Points.Empty();
    }
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    void FlySetFlightpath();
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    void SetManualControl(bool value) 
    {
        manualControl = value;
    }
 
    void MoveDroneToPosition(const FTransform Transform);
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    TArray<FTransform> GenerateRoamingPoints(float radius, int32 roamingPoints);
 
    virtual void SetCurrentTransformToMovedFromGarageTransform() override
    {
        if (mesh)
        {
            MovedFromGarageTransform = mesh->GetComponentTransform();
            UE_LOG(LogTemp, Warning, TEXT("Moved from garage transform %s"), *MovedFromGarageTransform.ToString());
 
        }
        else
        {
            MovedFromGarageTransform = GetActorTransform();
            UE_LOG(LogTemp, Warning, TEXT("ACTOR Moved from garage transform WHAT IS THIS: %s"), *MovedFromGarageTransform.ToString());
 
        }
    }
 
private:
 
    virtual void BeginPlay() override;
 
    virtual void Tick(float DeltaTime) override;
 
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
    void AutoPilot(float DeltaTime);
 
    UFUNCTION(BlueprintCallable)
    bool IsRoaming() const
    {
        return DroneParameters.DroneAction == EDroneAction::Roaming;
    }
 
    UFUNCTION(BlueprintCallable)
    void SetDesiredLocationMesh(UStaticMeshComponent* meshcomponent)
    {
        desiredPositionMesh = meshcomponent;
    }
 
    UFUNCTION(BlueprintCallable)
    void AssignRoamingPoints(const TArray<FTransform> Points);
 
    UFUNCTION(BlueprintCallable)
    void SetDroneRotation(USkeletalMeshComponent* target, FRotator rotator);
 
    UFUNCTION(BlueprintCallable)
    FVector GetCurrentWaypointTarget();
 
    FDroneParameters DroneParameters;
 
    UPROPERTY()
    EFlightMode flightmode = EFlightMode::Roaming;
 
    UPROPERTY()
    UWorld* World = nullptr;
 
    FVector StartingPosition;
 
    USkeletalMeshComponent* mesh = nullptr;
    UStaticMeshComponent* desiredPositionMesh = nullptr;
 
    bool waypointReached = false;
    bool manualControl = false;
 
    /* For testing purposes. Hardcoded coordinates */
    TArray<FVector> WayPoints = {
        {3790, 8050, 5000},
        {11779.536955,6566.541435,5000}
    };
 
    int32 passedWaypoints = 0;
 
};