Weather.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/Weather/Weather.h"
 
#include "Agrarsense/ROS/ROSHandler.h"
#include "Agrarsense/Game/AgrarsenseStatics.h"
#include "Agrarsense/JSON/SimulatorJsonExporter.h"
 
#include "ROSIntegration/Classes/ROSIntegrationGameInstance.h"
#include "RI/Topic.h"
 
#include "Async/Async.h"
 
AWeather::AWeather(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer)
{
    PrimaryActorTick.bCanEverTick = false;
}
 
void AWeather::BeginPlay()
{
    Super::BeginPlay();
 
    CurrentWeather = Default;
 
    UWorld* World = GetWorld();
 
    UROSHandler* RosHandler = UAgrarsenseStatics::GetROSHandle(World);
    if (RosHandler)
    {
        RosHandler->OnROSStateChanged.AddUniqueDynamic(this, &AWeather::ROSBridgeStateChanged);
    }
 
    RosInstance = Cast<UROSIntegrationGameInstance>(World->GetGameInstance());
    if (RosInstance)
    {
        ROSConnected = RosInstance->IsROSConnected();
    }
 
    Message = MakeShared<ROSMessages::std_msgs::String>();
 
    InitializeROSTopic();
}
 
void AWeather::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);
 
    UROSHandler* RosHandler = UAgrarsenseStatics::GetROSHandle(GetWorld());
    if (RosHandler)
    {
        RosHandler->OnROSStateChanged.AddUniqueDynamic(this, &AWeather::ROSBridgeStateChanged);
    }
 
    Message.Reset();
    DestroyTopic();
    RosInstance = nullptr;
}
 
void AWeather::ResetWeather()
{
    CurrentWeather = Default;
    UpdateWeather(CurrentWeather, true);
}
 
ESeason AWeather::GetCurrentSeason()
{
    return GetSeasonForMonth(CurrentWeather.Month);
}
 
ESeason AWeather::GetSeasonForMonth(const int32 Month)
{
    switch (Month)
    {
    case 0:
    case 1:
    case 2:
    case 3:
    case 12:
        return ESeason::Winter;
 
    case 4:
    case 5:
        return ESeason::Spring;
 
    case 6:
    case 7:
    case 8:
        return ESeason::Summer;
 
    case 9:
    case 10:
    case 11:
        return ESeason::Autumn;
 
    default:
        return ESeason::Summer;
    }
}
 
void AWeather::UpdateWeather(const FWeatherParameters& InWeather, bool updateToROS)
{
    CurrentWeather = InWeather;
 
    if (updateToROS)
    {
        AsyncTask(ENamedThreads::AnyThread, [this]()
        {
            // Send weather parameters to ROS, we don't care if this message will be frame or two behind,
            // as long as it doesn't block the game thread.
            SendWeatherData(CurrentWeather);
        });
    }
 
    // Broadcast event that weather has been changed
    OnWeatherChanged.Broadcast(CurrentWeather);
}
 
FString AWeather::ExportToJSON(const FString& FileName)
{
    return USimulatorJsonExporter::ExportWeatherToJSON(FileName, CurrentWeather);
}
 
void AWeather::InitializeROSTopic()
{
    if (WeatherTopic || !RosInstance || !ROSConnected)
    {
        return;
    }
 
    // Else create Weather ROS topic
    WeatherTopic = NewObject<UTopic>(UTopic::StaticClass());
    const FString TopicName = "/agrarsense/out/weather/";
    WeatherTopic->Init(RosInstance->ROSIntegrationCore, TopicName, TEXT("std_msgs/String"));
    WeatherTopic->Advertise();
 
#if WITH_EDITOR
    UE_LOG(LogTemp, Warning, TEXT("Weather.cpp: Created ROS topic. Topic name: %s"), *TopicName);
#endif
}
 
void AWeather::SendWeatherData(FWeatherParameters Parameters)
{
    if (WeatherTopic && ROSConnected && Message.IsValid())
    {
        Message->_Data = Parameters.ToStringHumanReadable();
        WeatherTopic->Publish(Message);
    }
}
 
void AWeather::DestroyTopic()
{
    if (WeatherTopic)
    {
        WeatherTopic->Unadvertise();
        WeatherTopic->Unsubscribe();
        WeatherTopic->MarkAsDisconnected();
        WeatherTopic->ConditionalBeginDestroy();
        WeatherTopic = nullptr;
    }
}
 
void AWeather::ROSBridgeStateChanged(EROSState ROSState)
{
    switch (ROSState)
    {
    case EROSState::Connected:
        ROSConnected = true;
        InitializeROSTopic();
        break;
 
    case EROSState::Disconnected:
        ROSConnected = false;
        DestroyTopic();
        break;
    }
}