Spectator.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 "Spectator.h"
#include "GameFramework/FloatingPawnMovement.h"
#include "GameFramework/PlayerController.h"
#include "Components/SceneComponent.h"
#include "NiagaraFunctionLibrary.h"
#include "NiagaraSystem.h"
 
#include "Agrarsense/Sensor/Overlap/OverlapSensor.h"
#include "Agrarsense/Sensor/SensorFactory.h"
#include "Agrarsense/Sensor/Sensor.h"
 
void ASpectator::BeginPlay()
{
    Super::BeginPlay();
 
    // Load and setup rain/snow fall niagara system for this spectator
    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, 150.0f), FRotator::ZeroRotator, EAttachLocation::KeepRelativeOffset, true);
 
        ASensor::HideComponentForAllCameras(Cast<UPrimitiveComponent>(NiagaraComponent));
    }
 
    // Disable niagara component
    SetNiagaraComponentVisibility(false);
 
    FVector RelativePosition = FVector(0.0f, 0.0f, 0.0f);
    float OverlapBoundsSize = 15.0f;
 
    // Create OverlapSensor
    FOverlapSensorParameters Params;
    Params.OwningActor = this;
    Params.Size = FVector(OverlapBoundsSize, OverlapBoundsSize, OverlapBoundsSize);
    Params.RelativePosition = RelativePosition;
    Params.AllChannels = true;
    FString OverlapSensorID = "spectator/overlap";
    OverlapSensor = USensorFactory::SpawnOverlapSensor(GetActorTransform(), Params, OverlapSensorID, "overlap", this);
}
 
void ASpectator::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);
 
    if (NiagaraComponent)
    {
        NiagaraComponent->UnregisterComponent();
        NiagaraComponent->DestroyComponent();
        NiagaraComponent = nullptr;
    }
 
    if (OverlapSensor) 
    {
        OverlapSensor->Destroy();
        OverlapSensor = nullptr;
    }
 
    Target.Reset();
}
 
void ASpectator::TeleportSpectator(const FTransform& Transform)
{
    if (!IsPlayerControlled())
    {
        return;
    }
 
    // Detach from any Actor and enable inputs.
    StopFollowingAnyActor(true);
 
    FVector TargetLocation = Transform.GetLocation();
    FVector Direction = GetActorLocation() - TargetLocation;
    Direction.Normalize();
 
    // 20 units away from the target so we are not top if it..
    FVector NewLocation = TargetLocation + Direction * 20.0f;
 
    FRotator NewRotation = (TargetLocation - NewLocation).ToOrientationRotator();
 
    SetActorLocationAndRotation(NewLocation, NewRotation);
 
    // Set the player controller rotation to match the incoming Transform angle,
    // This actually sets the camera angle.
    APlayerController* PlayerController = Cast<APlayerController>(GetController());
    if (PlayerController)
    {
        PlayerController->SetControlRotation(Transform.Rotator());
    }
}
 
void ASpectator::TeleportToActorLocation(const AActor* Actor)
{
    if (Actor)
    {
        FTransform Transform = Actor->GetActorTransform();
        TeleportSpectator(Transform);
    }
}
 
void ASpectator::FollowActor(AActor* Actor, bool DisableInputs, const float DistanceToActor, const float HeightOffset)
{
    Target = Actor;
 
    if (!Target.IsValid())
    {
        return;
    }
 
    // Detach from any previous target
    DetachFromActor(FDetachmentTransformRules::KeepRelativeTransform);
 
    // Set the offset to position the spectator slightly above and behind the actor
    FVector Offset = FVector(0.0f, 0.0f, HeightOffset);
 
    FVector TargetActorLocation = Actor->GetActorLocation();
 
    FVector DirectionToActor = TargetActorLocation - GetActorLocation();
    DirectionToActor.Normalize();
 
    // Face the camera slightly down toward the actor
    APlayerController* PlayerController = Cast<APlayerController>(GetController());
    if (PlayerController)
    {
        if (DisableInputs)
        {
            DisableInput(PlayerController);
        }
        FRotator NewRotation = DirectionToActor.ToOrientationRotator();
        PlayerController->SetControlRotation(NewRotation);
    }
 
    // Calculate the new location to be closer behind the actor
    FVector NewLocation = TargetActorLocation + DirectionToActor * -DistanceToActor + Offset;
 
    // Attach to the new target actor's root component with the offset
    USceneComponent* Root = Actor->GetRootComponent();
    if (Root)
    {
        AttachToComponent(Root, FAttachmentTransformRules::KeepRelativeTransform);
        SetActorLocation(NewLocation);
    }
 
    OnFollowTargetChanged.Broadcast(true, Target.Get());
}
 
void ASpectator::TeleportToFollowLocation(FVector TargetLocation, const float DistanceToLocation, const float HeightOffset)
{
    // Set the offset to position the spectator slightly above and behind the actor
    FVector Offset = FVector(0.0f, 0.0f, HeightOffset);
 
    FVector DirectionToActor = TargetLocation - GetActorLocation();
    DirectionToActor.Normalize();
 
    // Face the camera slightly down toward the actor
    APlayerController* PlayerController = Cast<APlayerController>(GetController());
    if (PlayerController)
    {
        FRotator NewRotation = DirectionToActor.ToOrientationRotator();
        PlayerController->SetControlRotation(NewRotation);
    }
 
    // Calculate the new location to be closer behind the actor
    FVector NewLocation = TargetLocation + DirectionToActor * -DistanceToLocation + Offset;
 
    SetActorLocation(NewLocation);
}
 
void ASpectator::TeleportToActorFollowLocation(AActor* Actor, const float DistanceToActor, const float HeightOffset)
{
    if (!IsValid(Actor))
    {
        return;
    }
 
    FVector TargetLocation = Actor->GetActorLocation();
 
    TeleportToFollowLocation(TargetLocation, DistanceToActor, HeightOffset);
}
 
void ASpectator::StopFollowingAnyActor(bool EnableInputs)
{
    // Detach from any previous target
    DetachFromActor(FDetachmentTransformRules::KeepRelativeTransform);
 
    Target.Reset();
 
    if (EnableInputs)
    {
        APlayerController* PlayerController = Cast<APlayerController>(GetController());
 
        if (PlayerController)
        {
            EnableInput(PlayerController);
        }
    }
 
    OnFollowTargetChanged.Broadcast(false, Target.Get());
}
 
void ASpectator::SetNiagaraComponentVisibility(bool Visible)
{
    if (NiagaraComponent)
    {
        NiagaraComponent->SetVisibility(Visible);
    }
}
 
void ASpectator::SetMaxSpeed(float MaxSpeed)
{
    UFloatingPawnMovement* FloatingMovement = GetFloatingPawnMovement();
    if (FloatingMovement)
    {
        FloatingMovement->MaxSpeed = MaxSpeed;
    }
}
 
float ASpectator::GetMaxSpeed()
{
    UFloatingPawnMovement* FloatingMovement = GetFloatingPawnMovement();
    if (FloatingMovement)
    {
        return FloatingMovement->MaxSpeed;
    }
 
    // Else return default value of 1500.0f (set in BP_spectator blueprint)
    return 1500.0f;
}
 
UFloatingPawnMovement* ASpectator::GetFloatingPawnMovement()
{
    return Cast<UFloatingPawnMovement>(GetMovementComponent());
}
 
 
void ASpectator::TeleportToLevelTeleportLocation(FLevelTeleportLocation TeleportLocation)
{
 
    if (!IsPlayerControlled())
    {
        return;
    }
 
    FTransform Transform = TeleportLocation.TeleportLocationTransform;
 
    // Detach from any Actor and enable inputs.
    StopFollowingAnyActor(true);
 
    SetActorLocationAndRotation(Transform.GetLocation(), Transform.GetRotation().Rotator());
 
    // Set the player controller rotation to match the incoming Transform angle,
    // This actually sets the camera angle.
    APlayerController* PlayerController = Cast<APlayerController>(GetController());
    if (PlayerController)
    {
        PlayerController->SetControlRotation(Transform.Rotator());
    }
}