Vehicle.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/Pawn.h"
#include "Engine/World.h"
 
#include "Agrarsense/Utils/EnumUtilities.h"
#include "Agrarsense/Vehicle/VehicleTypes.h"
#include "Agrarsense/ActorInterfaces/ActorInformation.h"
#include "Agrarsense/ActorInterfaces/Interactable.h"
#include "Agrarsense/ActorInterfaces/Destroyable.h"
#include "Agrarsense/Components/PointComponent.h"
 
#include "Vehicle.generated.h"
 
class UNiagaraComponent;
class USensorsManagerComponent;
class ACollisionSensor;
class ATranformSensor;
class AOverlapSensor;
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FVehicleGarageChangedDelegate, bool, IsVehicleInGarage);
 
/*
* Base class for all vehicles
*/
UCLASS()
class AGRARSENSE_API AVehicle : public APawn, public IInteractable, public IDestroyable, public IActorInformation
{
    GENERATED_BODY()
 
public:
 
    AVehicle();
 
    UFUNCTION(BlueprintCallable)
    virtual EVehicleTypes GetVehicleType() const
    {
        return EVehicleTypes::NONE;
    }
 
    UFUNCTION(BlueprintPure)
    virtual FString GetTopicName()
    {
        return FString(TEXT("Undefined"));
    }
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCallable)
    void TogglePhysics(bool isOn);
 
 
    UFUNCTION(BlueprintNativeEvent, BlueprintCallable)
    void TeleportVehicleTo(FVector NewLocation, FRotator NewRotation);
 
    virtual void TeleportVehicleTo_Implementation(FVector NewLocation, FRotator NewRotation);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCallable)
    void ResetCamera();
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCallable)
    void ToggleLights(bool isOn);
 
    UFUNCTION(BlueprintCallable)
    void SetVisualizeVehicleOverlapArea(bool Visible);
 
    UFUNCTION(BlueprintCallable)
    FString ExportToJsonFile(const FString& FileName);
 
    UFUNCTION(BlueprintCallable)
    void SetVehicleIsInGarage(bool VehicleIsInGarage)
    {
        VehicleInGarage = VehicleIsInGarage;
        OnVehicleGarageChanged.Broadcast(VehicleInGarage);
    }
 
    UFUNCTION(BlueprintPure)
    bool IsVehicleInGarage() const
    {
        return VehicleInGarage;
    }
 
    UFUNCTION(BlueprintCallable)
    USensorsManagerComponent* GetSensorsManager() const
    {
        return SensorsManager;
    }
 
    UFUNCTION(BlueprintPure)
    ACollisionSensor* GetCollisionSensor() const
    {
        return CollisionSensor;
    }
 
    UFUNCTION(BlueprintPure)
    ATransformSensor* GetTransformSensor() const
    {
        return TransformSensor;
    }
 
    UFUNCTION(BlueprintPure)
    AOverlapSensor* GetOverlapSensor() const
    {
        return OverlapSensor;
    }
 
    
    UFUNCTION(BlueprintPure)
    FTransform GetMovedFromGarageTransform() const
    {
        return MovedFromGarageTransform;
    }
 
    UFUNCTION(BlueprintCallable)
    void SetCurrentTransformToMovedFromGarageTransform()
    {
        MovedFromGarageTransform = GetTransform();
    }
 
    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 Vehicle = UEnumUtilities::ConvertVehicleTypeToString(GetVehicleType());
        const FString ID = GetActorID_Implementation();
        const FString Name = GetActorName_Implementation();
        const FTransform VehicleTransform = GetActorTransform();
        const FVector Location = VehicleTransform.GetLocation();
        const FRotator Rotation = VehicleTransform.Rotator();
        FString Information = FString::Printf(TEXT("Vehicle: %s, Name: %s, ID: %s, Location: %s, Rotation: %s"), *Vehicle, *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));
    }
 
    virtual void PossessedBy(AController* NewController) override;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Interactable")
    FText InteractableName;
 
    UPROPERTY(BlueprintAssignable)
    FVehicleGarageChangedDelegate OnVehicleGarageChanged;
 
 
protected:
 
    virtual void BeginPlay() override;
 
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
    /*
    * Manages sensors attached to this vehicle
    */
    UPROPERTY(Category = Vehicle, VisibleAnywhere, BlueprintReadOnly)
    TObjectPtr<USensorsManagerComponent> SensorsManager;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    ACollisionSensor* CollisionSensor = nullptr;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    ATransformSensor* TransformSensor = nullptr;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    AOverlapSensor* OverlapSensor = nullptr;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadWrite)
    UNiagaraComponent* NiagaraComponent = nullptr;
 
    UPROPERTY(VisibleAnywhere)
    FString ActorName;
 
    UPROPERTY(VisibleAnywhere)
    FString ActorID;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    FTransform OriginalCameraTransform;
 
private:
 
    bool VehicleInGarage = false;
 
    FTransform MovedFromGarageTransform;
};