AgrarsenseGameModeBase.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 "AgrarsenseGameModeBase.h"
#include "AgrarsensePaths.h"
#include "Agrarsense/Settings/AgrarsenseSettings.h"
#include "Agrarsense/InstancedRendering/InstancedRendererManager.h"
#include "Agrarsense/Sensor/Lidar/LidarManager.h"
#include "Agrarsense/Weather/Weather.h"
#include "Agrarsense/ROS/ROSCommands.h"
#include "Agrarsense/ROS/ROSHandler.h"
#include "Agrarsense/ROS/InfoTopic/InfoTopic.h"
#include "Agrarsense/Spectator/Spectator.h"
#include "Agrarsense/ActorInterfaces/ActorInformation.h"
#include "Agrarsense/Tagger/Tagger.h"
#include "Agrarsense/Logging/SimulatorLog.h"
#include "Agrarsense/Widgets/DragAndDropWidget.h"
 
#include "Kismet/GameplayStatics.h"
#include "Kismet/KismetSystemLibrary.h"
#include "Engine/World.h"
#include "Engine.h"
#include "TimerManager.h"
 
#include "ROSIntegration/Classes/ROSIntegrationGameInstance.h"
 
bool AAgrarsenseGameModeBase::AttemptToLaunchROSBridge = true;
bool AAgrarsenseGameModeBase::StartMessageLogged = false;
bool AAgrarsenseGameModeBase::MapChanged = false;
 
AAgrarsenseGameModeBase::AAgrarsenseGameModeBase(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer)
{
    PrimaryActorTick.bCanEverTick = false;
}
 
void AAgrarsenseGameModeBase::InitGame(const FString& MapName, const FString& Options, FString& ErrorMessage)
{
    Super::InitGame(MapName, Options, ErrorMessage);
 
    SpawnNeededActorsInitGame();
}
 
void AAgrarsenseGameModeBase::BeginPlay()
{
    Super::BeginPlay();
 
    SpawnNeededActorsBeginPlay();
 
    ParseMapChangeLaunchArgument();
}
 
void AAgrarsenseGameModeBase::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);
 
    if (EndPlayReason == EEndPlayReason::Type::Quit || EndPlayReason == EEndPlayReason::Type::EndPlayInEditor)
    {
        UInfoTopic::Destroy();
 
        if (ROSCommands)
        {
            ROSCommands->Destroy();
        }
 
        SimulatorLog::Log("Simulator shutting down. Goodbye.");
        SimulatorLog::Shutdown();
    }
 
#if WITH_EDITOR
    if (EndPlayReason == EEndPlayReason::Type::EndPlayInEditor)
    {
        EditorEndPlayCleanup();
    }
#endif
}
 
#if WITH_EDITOR
void AAgrarsenseGameModeBase::EditorEndPlayCleanup()
{
    // TODO: this is not good approach.
    // Clear certain static variables at Unreal Editor EndPlay.
    // This is not relevant for packaged builds as most of this data 
    // is meant to be kept in memory as long as the Simulator is running.
    IActorInformation::ClearTMapEditor();
    UAgrarsensePaths::DataPathForThisRun = "";
    AttemptToLaunchROSBridge = true;
    StartMessageLogged = false;
    MapChanged = false;
}
#endif
 
void AAgrarsenseGameModeBase::ParseMapChangeLaunchArgument()
{
    if (MapChanged)
    {
        // If map has already been changed, don't change it again.
        return;
    }
 
    // Map names and their actual paths to check against
    const TMap<FString, FString> MapLaunchArgs = {
        { "-vindeln",       "/Game/Agrarsense/Maps/Vindeln/Vindeln" },
        { "-vindeln_dev",   "/Game/Agrarsense/Maps/Vindeln/Vindeln_Dev" },
        { "-rovaniemi",     "/Game/Agrarsense/Maps/RovaniemiForest/RovaniemiForest" },
        { "-rovaniemi_dev", "/Game/Agrarsense/Maps/RovaniemiForest/RovaniemiForest_Dev" },
        { "-playground",    "/Game/Agrarsense/Maps/Playground" }
    };
 
    const FString CommandLine = FCommandLine::Get();
    FString MapName;
 
    for (const auto& Pair : MapLaunchArgs)
    {
        if (FParse::Param(*CommandLine, *Pair.Key))
        {
            MapChanged = true;
            MapName = Pair.Value;
            break;
        }
    }
 
    if (MapChanged)
    {
        // Chage map with minor delay.
        FTimerHandle Handle;
        GetWorld()->GetTimerManager().SetTimer(Handle, FTimerDelegate::CreateLambda([this, MapName]
            {
                if (IsValid(this))
                {
                    UGameplayStatics::OpenLevel(GetWorld(), *MapName);
                }
            }), 0.300f, false);
    }
}
 
void AAgrarsenseGameModeBase::SpawnNeededActorsInitGame()
{
    if (!StartMessageLogged)
    {
        SimulatorLog::Create();
        SimulatorLog::Log("Simulator starting.");
        StartMessageLogged = true;
    }
 
    UWorld* World = GetWorld();
 
    // Setup Agrarsense settings
    UAgrarsenseSettings* Settings = UAgrarsenseSettings::GetAgrarsenseSettings();
    if (Settings) 
    {
        Settings->Setup(World);
    }
 
    UROSIntegrationGameInstance* RosInstance = Cast<UROSIntegrationGameInstance>(World->GetGameInstance());
    bool ROSConnected = RosInstance->IsROSConnected();
 
    // Create UROSHandle UObject
    if (!ROSHandle)
    {
        ROSHandle = NewObject<UROSHandler>();
 
        if (ROSHandle) 
        {
            ROSHandle->Setup(ROSConnected);
            if (RosInstance->bConnectToROS && !ROSConnected && AttemptToLaunchROSBridge)
            {
                ROSHandle->LaunchROSBridge();
 
                // Only try to attempt once.
                // Otherwise if ROS is not connected, simulator attempts to launch ROS Bridge 
                // process each time map is changed.
                AttemptToLaunchROSBridge = false;
            }
        }
    }
 
    // Spawn Lidar Mananger. This actor should always exists in the scene.
    // This actor only ticks when there is Lidar sensor(s) in the world.
    if (LidarManagerClass && !LidarManager)
    {
        LidarManager = World->SpawnActor<ALidarManager>(LidarManagerClass);
    }
    else
    {
        UE_LOG(LogTemp, Error, TEXT("Missing LidarManager class or it already exists."));
    }
 
    if (!SimulationLevelManager)
    {
        // Try to find from the world, if not found, spawn a new one
        AActor* simulationLevelManagerActor = UGameplayStatics::GetActorOfClass(World, (TSubclassOf<AActor>)SimulationLevelManagerClass);
        if (IsValid(simulationLevelManagerActor))
        {
            SimulationLevelManager = Cast<ASimulationLevelManager>(simulationLevelManagerActor);
        }
        else
        {
            SimulationLevelManager = World->SpawnActor<ASimulationLevelManager>(SimulationLevelManagerClass);
        }
    }
 
    if (!Weather) 
    {
        // Try to find AWeather (BP_Weather) from the level.
        TArray<AActor*> WeatherActors;
        UGameplayStatics::GetAllActorsOfClass(World, AWeather::StaticClass(), WeatherActors);
        if (!WeatherActors.IsEmpty())
        {
            Weather = Cast<AWeather>(WeatherActors[0]);
 
#if WITH_EDITOR
            if (WeatherActors.Num() >= 2)
            {
                UE_LOG(LogTemp, Warning, TEXT("AAgrarsenseGameModeBase.cpp: Level has multiple Weather blueprints. Make sure to only use one."));
            }
#endif
        }
    }
 
    if (!InstancedRenderer) 
    {
        TArray<AActor*> InstancedRendererActors;
        UGameplayStatics::GetAllActorsOfClass(World, AInstancedRendererManager::StaticClass(), InstancedRendererActors);
        if (!InstancedRendererActors.IsEmpty()) 
        {
            InstancedRenderer = Cast<AInstancedRendererManager>(InstancedRendererActors[0]);
        }
        else 
        {
            InstancedRenderer = World->SpawnActor<AInstancedRendererManager>();
        }
    }
}
 
void AAgrarsenseGameModeBase::SpawnNeededActorsBeginPlay()
{
    UWorld* World = GetWorld();
 
    // Spawn developer tools widget (Ctrl + F9 to open)
    // this cannot be spawned in InitGame!
    if (DeveloperTools)
    {
        auto developerToolsWidget = CreateWidget<UUserWidget>(World, DeveloperTools);
        developerToolsWidget->AddToViewport(10);
    }
#if WITH_EDITOR
    else
    {
        UE_LOG(LogTemp, Error, TEXT("Missing DeveloperTools class! Please open AgrarsenseGameMode in Unreal and add it."));
    }
#endif
 
    if (!ROSCommands)
    {
        ROSCommands = NewObject<UROSCommands>();
        ROSCommands->Init();
    }
 
    UInfoTopic::Init();
 
    if (!Spectator) 
    {
        // try to get Spectator actor
        TArray<AActor*> Spectators;
        UGameplayStatics::GetAllActorsOfClass(World, ASpectator::StaticClass(), Spectators);
        if (!Spectators.IsEmpty())
        {
            Spectator = Cast<ASpectator>(Spectators[0]);
 
#if WITH_EDITOR
            if (Spectators.Num() >= 2)
            {
                UE_LOG(LogTemp, Warning, TEXT("AAgrarsenseGameModeBase.cpp: Level has multiple Spectator blueprints. Make sure to only use one."));
            }
#endif
        }
    }
 
    if (!Tagger) 
    {
        // Destroy all existing Tagger if there's any, there should only be one.
        TArray<AActor*> Taggers;
        UGameplayStatics::GetAllActorsOfClass(World, ATagger::StaticClass(), Taggers);
        for (AActor* TaggerActor : Taggers)
        {
            if (TaggerActor)
            {
                TaggerActor->Destroy();
            }
        }
        Taggers.Empty();
        Tagger = World->SpawnActor<ATagger>();
    }
 
    if (World && GEngine && GEngine->GameViewport)
    {
        // Create and add a drag-and-drop overlay widget to the main viewport (Spectator).
        // Note: All widgets block the drag-and-drop interaction.
        // To ensure smooth usage, try dragging the file into an area without any visible widgets.
        // If the cursor shows a cancel icon, it indicates a hidden widget is obstructing the view.
        TSharedPtr<SDragAndDropWidget> OverlayWidget = SNew(SDragAndDropWidget);
        GEngine->GameViewport->AddViewportWidgetContent(OverlayWidget.ToSharedRef());
    }
}