Vehicle.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 "Agrarsense/Vehicle/Vehicle.h"
 
#include "Agrarsense/Sensor/SensorsManagerComponent.h"
#include "Agrarsense/Sensor/Collision/CollisionSensor.h"
#include "Agrarsense/Sensor/Transform/TransformSensor.h"
#include "Agrarsense/Sensor/Overlap/OverlapSensor.h"
#include "Agrarsense/Sensor/SensorFactory.h"
#include "Agrarsense/JSON/SimulatorJsonExporter.h"
 
#include "Kismet/GameplayStatics.h"
#include "NiagaraFunctionLibrary.h"
#include "NiagaraComponent.h"
#include "NiagaraSystem.h"
 
AVehicle::AVehicle()
{
    PrimaryActorTick.bCanEverTick = false;
    SensorsManager = CreateDefaultSubobject<USensorsManagerComponent>(TEXT("SensorsManagerComp"));
    InteractableName = NSLOCTEXT("Agrarsense", "VehicleInteractableName", "Vehicle");
}
 
void AVehicle::BeginPlay()
{
    Super::BeginPlay();
 
    TogglePhysics(true);
 
    // Spawn Transform and Collision sensors for each vehicle
    FTransform transform = GetTransform();
 
    // Create Collision sensor
    FString VehicleCollisionSensorID = ActorID + "/collision";
    CollisionSensor = USensorFactory::SpawnCollisionSensor(transform, this, VehicleCollisionSensorID, "collision", true);
 
    // Create Transform sensor
    FString VehicleTransformSensorID = ActorID + "/transform";
    TransformSensor = USensorFactory::SpawnTransformSensor(transform, this, VehicleTransformSensorID, "transform", true);
 
    float NiagaraComponentHeight = 500.0f;
    float OverlapBoundsSize = 5000.0f;
 
    if (GetVehicleType() == EVehicleTypes::Drone)
    {
        // Adjust certain variables if vehicle is a drone
        OverlapBoundsSize = 2500.0f;
        NiagaraComponentHeight = 200.0f;
    }
 
    FVector RelativePosition = FVector(0.0f, 0.0f, 0.0f);
    if (GetVehicleType() == EVehicleTypes::Forwarder)
    {
        // TODO make better solution for this.
        RelativePosition = FVector(150.0f, -120.0f, 250.0f);
    }
 
    // Create OverlapSensor
    FOverlapSensorParameters Params;
    Params.OwningActor = this;
    Params.Size = FVector(OverlapBoundsSize, OverlapBoundsSize, OverlapBoundsSize);
    Params.RelativePosition = RelativePosition;
    FString OverlapSensorID = ActorID + "/overlap";
    OverlapSensor = USensorFactory::SpawnOverlapSensor(transform, Params, OverlapSensorID, "overlap");
 
    // Load and setup rain/snow fall niagara system
    UNiagaraSystem* NiagaraSystem = LoadObject<UNiagaraSystem>(nullptr, TEXT("/Game/Agrarsense/Particles/WaterAndSnow/NS_Particles.NS_Particles"));
    if (NiagaraSystem)
    {
        NiagaraComponent = UNiagaraFunctionLibrary::SpawnSystemAttached(NiagaraSystem, this->GetRootComponent(),
            FName("NiagaraEmitterSocketName"),
            FVector(0.0, 0.0, NiagaraComponentHeight), FRotator::ZeroRotator, EAttachLocation::KeepRelativeOffset, true);
    }
}
 
void AVehicle::PossessedBy(AController* NewController)
{
    Super::PossessedBy(NewController);
 
    ResetCamera();
}
 
void AVehicle::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);
 
    if (TransformSensor)
    {
        TransformSensor->Destroy();
        TransformSensor = nullptr;
    }
 
    if (CollisionSensor)
    {
        CollisionSensor->Destroy();
        CollisionSensor = nullptr;
    }
 
    if (OverlapSensor)
    {
        OverlapSensor->Destroy();
        OverlapSensor = nullptr;
    }
 
    // Destroy attached sensors when vehicle is destroyed
    if (IsValid(SensorsManager) && EndPlayReason == EEndPlayReason::Destroyed)
    {
        SensorsManager->DestroyAllSensors();
    }
 
    if (NiagaraComponent)
    {
        NiagaraComponent->UnregisterComponent();
        NiagaraComponent->DestroyComponent();
        NiagaraComponent = nullptr;
    }
 
    // Destroy all remaining Actors that are attached to this vehicle, if any
    TArray<AActor*> AttachedActors;
    GetAttachedActors(AttachedActors);
    for (AActor* Actor : AttachedActors)
    {
        if (Actor)
        {
            Actor->Destroy();
        }
    }
}
 
void AVehicle::TeleportVehicleTo_Implementation(FVector NewLocation, FRotator NewRotation)
{
    SetActorLocationAndRotation(NewLocation, NewRotation, false, nullptr, ETeleportType::TeleportPhysics);
}
 
void AVehicle::SetVisualizeVehicleOverlapArea(bool Visible)
{
    if (OverlapSensor)
    {
        OverlapSensor->SetVisualizeOverlapArea(Visible);
    }
}
 
FString AVehicle::ExportToJsonFile(const FString& FileName)
{
    bool OverrideTransform = IsVehicleInGarage();
 
    FTransform TransformToUse = GetActorTransform();
 
    if (OverrideTransform)
    {
        TransformToUse = MovedFromGarageTransform;
    }
 
    return USimulatorJsonExporter::ExportVehicleAndSensorsToJSON(FileName, this, OverrideTransform, TransformToUse);
}