613 lines
26 KiB
C++
613 lines
26 KiB
C++
// Fill out your copyright notice in the Description page of Project Settings.
|
|
|
|
#include "TimeOfDayManager.h"
|
|
#include "../Items/SeedCarousel.h"
|
|
#include "Components/DirectionalLightComponent.h"
|
|
#include "Components/ExponentialHeightFogComponent.h"
|
|
#include "Components/SkyAtmosphereComponent.h"
|
|
#include "Components/SkyLightComponent.h"
|
|
#include "Curves/CurveFloat.h"
|
|
#include "Curves/CurveLinearColor.h"
|
|
#include "Engine/AssetManager.h"
|
|
#include "Engine/GameInstance.h"
|
|
#include "Engine/PostProcessVolume.h"
|
|
#include "Engine/StreamableManager.h"
|
|
#include "Engine/World.h"
|
|
#include "Kismet/GameplayStatics.h"
|
|
#include "Kismet/KismetMaterialLibrary.h"
|
|
#include "Materials/MaterialParameterCollection.h"
|
|
#include "ProjectEleri/Data/WeatherPresetDataAsset.h"
|
|
#include "ProjectEleri/GameEventSystem/GameEventSubsystem.h"
|
|
#include "ProjectEleri/System/MainBlueprintFunctionLibrary.h"
|
|
|
|
|
|
// Sets default values
|
|
ATimeOfDayManager::ATimeOfDayManager()
|
|
{
|
|
// Set this actor to call Tick() every frame. You can turn this off to improve performance if you don't need it.
|
|
PrimaryActorTick.bCanEverTick = true;
|
|
rotator = 0;
|
|
currentMinutes = 0;
|
|
daysPassed = 1;
|
|
currentWeekday = 1;
|
|
currentMonth = 1;
|
|
currentHours = 0;
|
|
currentYear = 100;
|
|
StartedTicking = false;
|
|
ShouldRain = false;
|
|
|
|
RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
|
|
|
|
sunLight = CreateDefaultSubobject<UDirectionalLightComponent>("SunLight");
|
|
sunLight->SetupAttachment(RootComponent);
|
|
moonLight = CreateDefaultSubobject<UDirectionalLightComponent>("MoonLight");
|
|
moonLight->SetupAttachment(RootComponent);
|
|
skyLight = CreateDefaultSubobject<USkyLightComponent>("SkyLight");
|
|
skyLight->SetupAttachment(RootComponent);
|
|
exponentialHeightFogComponent = CreateDefaultSubobject<UExponentialHeightFogComponent>("ExponentialHeightFog");
|
|
exponentialHeightFogComponent->SetupAttachment(RootComponent);
|
|
skyAtmosphereComponent = CreateDefaultSubobject<USkyAtmosphereComponent>("SkyAtmosphere");
|
|
skyAtmosphereComponent->SetupAttachment(RootComponent);
|
|
VolumetricCloudComponent = CreateDefaultSubobject<UVolumetricCloudComponent>("VolumetricCloudComponent");
|
|
VolumetricCloudComponent->SetupAttachment(RootComponent);
|
|
|
|
if (!WeatherPresetDistributionMap.IsEmpty())
|
|
{
|
|
TArray<UWeatherPresetDataAsset *> Keys;
|
|
WeatherPresetDistributionMap.GetKeys(Keys);
|
|
CurrentWeatherPreset = Keys[0];
|
|
}
|
|
}
|
|
|
|
// Called when the game starts or when spawned
|
|
void ATimeOfDayManager::BeginPlay()
|
|
{
|
|
Super::BeginPlay();
|
|
ItemDatabase = GetGameInstance()->GetSubsystem<UItemDatabase>();
|
|
|
|
if (!enableTimeOfDay)
|
|
{
|
|
return;
|
|
}
|
|
TimeTicking = true;
|
|
sunLight->SetUseTemperature(true);
|
|
|
|
OnDayPassed.Broadcast();
|
|
SetTimeOfDay(60 * 8);
|
|
NextWeatherChangeMinutes = FMath::RandRange(10.f * 60.f, 48.f * 60.f);
|
|
|
|
if (UAssetManager *AM = UAssetManager::GetIfInitialized())
|
|
{
|
|
TArray<FSoftObjectPath> SoftObjectPaths;
|
|
WeatherPresetDistributionMapPaths.GetKeys(SoftObjectPaths);
|
|
AM->GetStreamableManager().RequestAsyncLoad(SoftObjectPaths, FStreamableDelegate::CreateLambda([this]()
|
|
{
|
|
WeatherPresetDistributionMap.Empty();
|
|
for (auto WeatherObjectPath : WeatherPresetDistributionMapPaths)
|
|
{
|
|
WeatherPresetDistributionMap.Add(Cast<UWeatherPresetDataAsset>(WeatherObjectPath.Key.TryLoad()),
|
|
WeatherObjectPath.Value);
|
|
} }));
|
|
}
|
|
}
|
|
|
|
void ATimeOfDayManager::PostLoad()
|
|
{
|
|
Super::PostLoad();
|
|
|
|
VolumetricCloudMaterialInstance = UKismetMaterialLibrary::CreateDynamicMaterialInstance(this, VolumetricCloudMaterial, FName("VolMat"), EMIDCreationFlags::Transient);
|
|
VolumetricCloudComponent->SetMaterial(VolumetricCloudMaterialInstance);
|
|
}
|
|
|
|
// Called every frame
|
|
void ATimeOfDayManager::Tick(float DeltaTime)
|
|
{
|
|
Super::Tick(DeltaTime);
|
|
|
|
if (!enableTimeOfDay || !TimeTicking)
|
|
return;
|
|
|
|
AddMinutes(1.0f * DeltaTime * daySpeed);
|
|
|
|
if (NextWeatherChangeMinutes <= 0.f)
|
|
{
|
|
if (!FadingOutWeather)
|
|
{
|
|
FadingOutWeather = true;
|
|
FadingWeatherTimer = 30.f;
|
|
CurrentWeaterFadeAlpha = 1.f;
|
|
QueuedWeatherPreset = GetWeatherDistributionValue();
|
|
K2_WeatherFadeStart(QueuedWeatherPreset->bIsRain);
|
|
}
|
|
else
|
|
{
|
|
FadingWeatherTimer -= DeltaTime * daySpeed;
|
|
CurrentWeaterFadeAlpha = FadingWeatherTimer / 30.f;
|
|
K2_WeatherFadeToggle(CurrentWeaterFadeAlpha, QueuedWeatherPreset->bIsRain);
|
|
UE_LOG(LogTemp, Warning, TEXT("Weather alpha: %f"), CurrentWeaterFadeAlpha);
|
|
}
|
|
|
|
if (CurrentWeaterFadeAlpha <= 0.f)
|
|
{
|
|
K2_WeatherFadeEnd(QueuedWeatherPreset->bIsRain);
|
|
FadingOutWeather = false;
|
|
CurrentWeaterFadeAlpha = 0.f;
|
|
FadingWeatherTimer = 0.f;
|
|
NextWeatherChangeMinutes = FMath::RandRange(10.f * 60.f, 48.f * 60.f);
|
|
CurrentWeatherPreset = QueuedWeatherPreset;
|
|
QueuedWeatherPreset = nullptr;
|
|
}
|
|
}
|
|
|
|
UpdateLightning();
|
|
}
|
|
|
|
void ATimeOfDayManager::UpdateLightning()
|
|
{
|
|
// Every 4 minutes the sun rotates by 1 degree, lets calculate how much it has to rotate every minute
|
|
rotator = FloatMinutes * 0.25f;
|
|
// Offset this by 90 degrees since that is the rotation of the sun at midnight and clip it to 360
|
|
rotator += 70.0f;
|
|
if (rotator >= 360.0f)
|
|
rotator -= 360.0f;
|
|
|
|
RotateSun(rotator);
|
|
// Update enviroment lightning intensity
|
|
SetSkylightIntensity(rotator);
|
|
SetDirectionalLightIntensity(rotator);
|
|
|
|
// Update fog
|
|
if (IsValid(exponentialHeightFogComponent))
|
|
{
|
|
float CurrentFogIntensity = CurrentWeatherPreset->FogIntensityCurve->GetFloatValue(FloatMinutes);
|
|
exponentialHeightFogComponent->FogDensity =
|
|
QueuedWeatherPreset
|
|
? FMath::Lerp(QueuedWeatherPreset->FogIntensityCurve->GetFloatValue(FloatMinutes), CurrentFogIntensity,
|
|
CurrentWeaterFadeAlpha)
|
|
: CurrentFogIntensity;
|
|
exponentialHeightFogComponent->MarkRenderStateDirty();
|
|
}
|
|
|
|
// Sky atmosphere
|
|
if (IsValid(skyAtmosphereComponent))
|
|
{
|
|
FLinearColor CurrentRaylightScattering = CurrentWeatherPreset->RaylightScattering;
|
|
skyAtmosphereComponent->RayleighScattering = QueuedWeatherPreset
|
|
? FLinearColor::LerpUsingHSV(
|
|
QueuedWeatherPreset->RaylightScattering,
|
|
CurrentRaylightScattering, CurrentWeaterFadeAlpha)
|
|
: CurrentRaylightScattering;
|
|
|
|
float CurrentMieScattering = CurrentWeatherPreset->MieScatteringScale->GetFloatValue(FloatMinutes);
|
|
skyAtmosphereComponent->MieScatteringScale = QueuedWeatherPreset
|
|
? FMath::Lerp(
|
|
QueuedWeatherPreset->MieScatteringScale->GetFloatValue(FloatMinutes), CurrentMieScattering,
|
|
CurrentWeaterFadeAlpha)
|
|
: CurrentMieScattering;
|
|
skyAtmosphereComponent->MarkRenderStateDirty();
|
|
}
|
|
|
|
//Volumetric clouds
|
|
if (IsValid(VolumetricCloudComponent) && IsValid(VolumetricCloudMaterialInstance))
|
|
{
|
|
FLinearColor OutColor;
|
|
VolumetricCloudMaterialInstance->GetVectorParameterValue(FHashedMaterialParameterInfo(FName("Cloud Detail Control")), OutColor);
|
|
constexpr float LowCoverage = 0.5f;
|
|
constexpr float HighCoverage = 0.3f;
|
|
const float Alpha = QueuedWeatherPreset?
|
|
FMath::Lerp(QueuedWeatherPreset->CloudCoverage, CurrentWeatherPreset->CloudCoverage, CurrentWeaterFadeAlpha) :
|
|
CurrentWeatherPreset->CloudCoverage;
|
|
OutColor.G = FMath::Lerp(LowCoverage, HighCoverage, Alpha);
|
|
VolumetricCloudMaterialInstance->SetVectorParameterValue(FName("Cloud Detail Control"), OutColor);
|
|
}
|
|
|
|
// Update Material Parameter Collection
|
|
if (IsValid(WindMaterialParameterCollection))
|
|
{
|
|
float CurrentWindIntensity = CurrentWeatherPreset->WindIntensity;
|
|
UKismetMaterialLibrary::SetScalarParameterValue(GetWorld(), WindMaterialParameterCollection,
|
|
FName("Wind Intensity"),
|
|
QueuedWeatherPreset
|
|
? FMath::Lerp(
|
|
QueuedWeatherPreset->WindIntensity,
|
|
CurrentWindIntensity, CurrentWeaterFadeAlpha)
|
|
: CurrentWindIntensity);
|
|
}
|
|
|
|
// Update sky dome intensity
|
|
if (GeneralMaterialParameterCollection)
|
|
{
|
|
float CurrentSkyDomeIntensity = CurrentWeatherPreset->SkyDomeIntensityCurve->GetFloatValue(FloatMinutes);
|
|
UKismetMaterialLibrary::SetScalarParameterValue(GetWorld(), GeneralMaterialParameterCollection,
|
|
FName("SkyBrightness"),
|
|
QueuedWeatherPreset
|
|
? FMath::Lerp(
|
|
QueuedWeatherPreset->SkyDomeIntensityCurve->GetFloatValue(FloatMinutes), CurrentSkyDomeIntensity,
|
|
CurrentWeaterFadeAlpha)
|
|
: CurrentSkyDomeIntensity * FMath::Lerp(
|
|
1.0f, 0.25f, CurrentWeaterFadeAlpha));
|
|
|
|
FLinearColor CurrentSkyDomeTopBottomGradient = CurrentWeatherPreset->SkyDomeTopBottomGradient->GetLinearColorValue(FloatMinutes);
|
|
FLinearColor CurrentSkyDomeMiddleGradient = CurrentWeatherPreset->SkyDomeMiddleGradient->GetLinearColorValue(FloatMinutes);
|
|
UKismetMaterialLibrary::SetVectorParameterValue(GetWorld(), GeneralMaterialParameterCollection,
|
|
FName("SkyGradientTopDown"),
|
|
QueuedWeatherPreset
|
|
? FMath::Lerp(
|
|
QueuedWeatherPreset->SkyDomeTopBottomGradient->GetLinearColorValue(FloatMinutes),
|
|
CurrentSkyDomeTopBottomGradient, CurrentWeaterFadeAlpha)
|
|
: CurrentSkyDomeTopBottomGradient);
|
|
UKismetMaterialLibrary::SetVectorParameterValue(GetWorld(), GeneralMaterialParameterCollection,
|
|
FName("SkyGradientMiddle"),
|
|
QueuedWeatherPreset
|
|
? FMath::Lerp(
|
|
QueuedWeatherPreset->SkyDomeMiddleGradient->GetLinearColorValue(FloatMinutes),
|
|
CurrentSkyDomeMiddleGradient, CurrentWeaterFadeAlpha)
|
|
: CurrentSkyDomeMiddleGradient);
|
|
|
|
UKismetMaterialLibrary::SetScalarParameterValue(GetWorld(), GeneralMaterialParameterCollection,
|
|
FName("Cloud Coverage"),
|
|
QueuedWeatherPreset
|
|
? FMath::Lerp(
|
|
QueuedWeatherPreset->CloudCoverage,
|
|
CurrentWeatherPreset->CloudCoverage,
|
|
CurrentWeaterFadeAlpha)
|
|
: CurrentWeatherPreset->CloudCoverage);
|
|
|
|
// float DayAmount = 0.5f * (1 + FMath::Sin((PI * FloatMinutes) / 720.f - (PI/2.f)));
|
|
// DayAmount *= QueuedWeatherPreset ?
|
|
// FMath::Lerp(QueuedWeatherPreset->CloudsBrightnessCurve->GetFloatValue(FloatMinutes), CurrentWeatherPreset->CloudsBrightnessCurve->GetFloatValue(FloatMinutes), CurrentWeaterFadeAlpha)
|
|
// : CurrentWeatherPreset->CloudsBrightnessCurve->GetFloatValue(FloatMinutes);
|
|
// UKismetMaterialLibrary::SetScalarParameterValue(GetWorld(), GeneralMaterialParameterCollection, FName("Day Amount"), DayAmount);
|
|
}
|
|
|
|
// Update wetness
|
|
if (IsValid(GeneralMaterialParameterCollection))
|
|
{
|
|
UKismetMaterialLibrary::SetScalarParameterValue(GetWorld(), GeneralMaterialParameterCollection,
|
|
FName("Wetness"),
|
|
QueuedWeatherPreset
|
|
? FMath::Lerp(
|
|
static_cast<float>(QueuedWeatherPreset->bIsRain),
|
|
static_cast<float>(CurrentWeatherPreset->bIsRain),
|
|
CurrentWeaterFadeAlpha)
|
|
: static_cast<float>(CurrentWeatherPreset->bIsRain));
|
|
}
|
|
|
|
UpdateMajorLightning();
|
|
}
|
|
|
|
void ATimeOfDayManager::UpdateMajorLightning()
|
|
{
|
|
OnMajorLightningUpdate.Broadcast();
|
|
}
|
|
|
|
void ATimeOfDayManager::RotateSun(const float &_rotator)
|
|
{
|
|
if (!enableTimeOfDay)
|
|
return;
|
|
if (sunLight->IsValidLowLevel())
|
|
{
|
|
FVector currentRotInVectors = FVector(0.0f, CurrentWeatherPreset->SunRotationCurve->GetFloatValue(FloatMinutes),
|
|
110.0f);
|
|
FRotator currentSunRotation = FRotator(FRotator::MakeFromEuler(currentRotInVectors));
|
|
sunLight->SetWorldRotation(currentSunRotation);
|
|
}
|
|
if (moonLight->IsValidLowLevel())
|
|
{
|
|
FVector currentRotInVectors = FVector(
|
|
0.0f, CurrentWeatherPreset->MoonRotationCurve->GetFloatValue(FloatMinutes), 110.0f);
|
|
FRotator currentMoonRotation = FRotator(FRotator::MakeFromEuler(currentRotInVectors));
|
|
moonLight->SetWorldRotation(currentMoonRotation);
|
|
}
|
|
}
|
|
|
|
void ATimeOfDayManager::SetDirectionalLightIntensity(const float &_rotator)
|
|
{
|
|
if (!enableTimeOfDay)
|
|
return;
|
|
if (!CurrentWeatherPreset->SunlightCurve)
|
|
return;
|
|
|
|
float SunlightIntensity = CurrentWeatherPreset->SunlightCurve->GetFloatValue(FloatMinutes);
|
|
CurrentSunlightIntensity = QueuedWeatherPreset
|
|
? FMath::Lerp(QueuedWeatherPreset->SunlightCurve->GetFloatValue(FloatMinutes),
|
|
SunlightIntensity, CurrentWeaterFadeAlpha)
|
|
: SunlightIntensity;
|
|
float MoonlightIntensity = CurrentWeatherPreset->MoonlightCurve->GetFloatValue(FloatMinutes);
|
|
CurrentMoonlightIntensity = QueuedWeatherPreset
|
|
? FMath::Lerp(QueuedWeatherPreset->MoonlightCurve->GetFloatValue(FloatMinutes),
|
|
MoonlightIntensity, CurrentWeaterFadeAlpha)
|
|
: MoonlightIntensity;
|
|
|
|
sunLight->SetIntensity(CurrentSunlightIntensity);
|
|
moonLight->SetIntensity(CurrentMoonlightIntensity);
|
|
|
|
FPostProcessSettings Settings = MainPP->Settings;
|
|
float CurrentGiIntensity = CurrentWeatherPreset->IndirectGIIntensityCurve->GetFloatValue(FloatMinutes);
|
|
Settings.IndirectLightingIntensity = QueuedWeatherPreset
|
|
? FMath::Lerp(
|
|
QueuedWeatherPreset->IndirectGIIntensityCurve->GetFloatValue(FloatMinutes), CurrentGiIntensity,
|
|
CurrentWeaterFadeAlpha)
|
|
: CurrentGiIntensity;
|
|
MainPP->Settings = Settings;
|
|
|
|
bool bSunEnabled = CurrentSunlightIntensity > 0.0f;
|
|
sunLight->SetVisibility(bSunEnabled);
|
|
sunLight->SetCastShadows(bSunEnabled);
|
|
|
|
bool bMoonEnabled = CurrentMoonlightIntensity > 0.0f;
|
|
moonLight->SetVisibility(bMoonEnabled);
|
|
moonLight->SetCastShadows(bMoonEnabled);
|
|
}
|
|
|
|
void ATimeOfDayManager::SetSkylightIntensity(const float &_rotator)
|
|
{
|
|
if (!enableTimeOfDay)
|
|
return;
|
|
if (!CurrentWeatherPreset->SkylightCurve)
|
|
return;
|
|
|
|
float SkylightIntensity = CurrentWeatherPreset->SkylightCurve->GetFloatValue(FloatMinutes);
|
|
CurrentSkylightIntensity = QueuedWeatherPreset
|
|
? FMath::Lerp(QueuedWeatherPreset->SkylightCurve->GetFloatValue(FloatMinutes),
|
|
SkylightIntensity, CurrentWeaterFadeAlpha)
|
|
: SkylightIntensity;
|
|
skyLight->SetIntensity(CurrentSkylightIntensity);
|
|
|
|
FLinearColor CurrentEvaluatedColor = CurrentWeatherPreset->SkylightColorCurve->GetClampedLinearColorValue(FloatMinutes);
|
|
skyLight->SetLightColor(QueuedWeatherPreset
|
|
? FMath::Lerp(
|
|
QueuedWeatherPreset->SkylightColorCurve->GetClampedLinearColorValue(FloatMinutes),
|
|
CurrentEvaluatedColor, CurrentWeaterFadeAlpha)
|
|
: CurrentEvaluatedColor);
|
|
}
|
|
|
|
void ATimeOfDayManager::CheckLateHours()
|
|
{
|
|
if (!TimeTicking)
|
|
return;
|
|
|
|
if (currentHours == 0 && skipNight)
|
|
{
|
|
PassOutSleeping();
|
|
}
|
|
}
|
|
|
|
void ATimeOfDayManager::GoToSleep()
|
|
{
|
|
if (currentHours == 0 || currentHours == 1 || currentHours == 2)
|
|
{
|
|
if (enableDebugLogs)
|
|
UE_LOG(LogTemp, Warning, TEXT("--Adding minutes: %s"), *FString::FromInt(480 - currentMinutes));
|
|
AddMinutes(480 - currentMinutes);
|
|
}
|
|
else
|
|
{
|
|
if (enableDebugLogs)
|
|
UE_LOG(LogTemp, Warning, TEXT("--Adding minutes: %s"), *FString::FromInt(1860 - currentMinutes));
|
|
AddMinutes(1860 - currentMinutes);
|
|
}
|
|
}
|
|
|
|
void ATimeOfDayManager::AddMinutes(float minutes)
|
|
{
|
|
if (!TimeTicking)
|
|
return;
|
|
|
|
FloatMinutes += minutes;
|
|
|
|
currentHours = FMath::Clamp(FMath::Floor(FloatMinutes / 60.f), 0, 24);
|
|
currentMinutes = FMath::Clamp(FMath::Clamp(FloatMinutes - (currentHours * 60), 0, 60), 0, 60);
|
|
if (FloatMinutes >= 1440.f)
|
|
{
|
|
FloatMinutes = 0;
|
|
currentHours = 0;
|
|
currentMinutes = 0;
|
|
daysPassed++;
|
|
OnDayPassed.Broadcast();
|
|
currentWeekday++;
|
|
if (currentWeekday == 8)
|
|
{
|
|
currentWeekday = 1;
|
|
}
|
|
if (daysPassed == 29)
|
|
{
|
|
currentMonth++;
|
|
daysPassed = 1;
|
|
if (currentMonth > 4)
|
|
{
|
|
currentMonth = 1;
|
|
currentYear++;
|
|
}
|
|
}
|
|
}
|
|
|
|
NextWeatherChangeMinutes -= minutes;
|
|
|
|
OnMinutesAdded.Broadcast(minutes);
|
|
OnTimePassed.Broadcast(GetTimeOfDay());
|
|
}
|
|
|
|
float ATimeOfDayManager::GetMinutesPassedSoFar() const
|
|
{
|
|
return GetCurrentMinutes() +
|
|
(GetCurrentHours() * 60.f) +
|
|
(GetDaysPassed() * 60.f * 24.f) +
|
|
(GetMonth() * 60.f * 24.f * 28.f) +
|
|
(GetYear() * 60.f * 24.f * 28.f * 4.f);
|
|
}
|
|
|
|
void ATimeOfDayManager::GetDateMinusDays(int32 days, int32 &daysOut, int32 &monthsOut, int32 &yearsOut)
|
|
{
|
|
int32 currDays = GetDaysPassed() - days;
|
|
int32 currMonths = GetMonth();
|
|
int32 currYear = GetYear();
|
|
|
|
if (currDays < 1)
|
|
{
|
|
currDays = 30 - FMath::Abs(currDays);
|
|
currMonths--;
|
|
if (currMonths < 1)
|
|
{
|
|
currMonths = 4 - FMath::Abs(currMonths);
|
|
currYear--;
|
|
}
|
|
}
|
|
|
|
daysOut = currDays;
|
|
monthsOut = currMonths;
|
|
yearsOut = currYear;
|
|
}
|
|
|
|
void ATimeOfDayManager::SetTimeline(int32 minute, int32 hour, int32 day, int32 weekday, int32 month, int32 year)
|
|
{
|
|
currentMinutes = minute;
|
|
currentHours = hour;
|
|
daysPassed = day;
|
|
currentWeekday = weekday;
|
|
currentMonth = month;
|
|
currentYear = year;
|
|
}
|
|
|
|
void ATimeOfDayManager::SetTimeOfDay(float Minutes)
|
|
{
|
|
this->FloatMinutes = Minutes;
|
|
this->currentMinutes = (int32)this->FloatMinutes;
|
|
this->OnMinutesAdded.Broadcast(Minutes);
|
|
this->UpdateMajorLightning();
|
|
OnTimePassed.Broadcast(GetTimeOfDay());
|
|
}
|
|
|
|
void ATimeOfDayManager::StartTimeOfDay()
|
|
{
|
|
StartedTicking = true;
|
|
}
|
|
|
|
void ATimeOfDayManager::StopTimeOfDay()
|
|
{
|
|
StartedTicking = false;
|
|
}
|
|
|
|
void ATimeOfDayManager::ToggleTimeActive(bool bNewActive)
|
|
{
|
|
TimeTicking = bNewActive;
|
|
}
|
|
|
|
TArray<FCalendarDayData> ATimeOfDayManager::GetCalendarDataForMonth(int32 Month)
|
|
{
|
|
TArray<FCalendarDayData> Data;
|
|
UGameEventSubsystem *GameEventSubsystem = UGameEventSubsystem::GetGameEventSubsystem();
|
|
check(GameEventSubsystem);
|
|
|
|
const TArray<TObjectPtr<UGameEventDataAsset>> &CalendarEvents = GameEventSubsystem->GetCalendarEvents();
|
|
for (int32 i = 1; i <= 28; i++)
|
|
{
|
|
FCalendarDayData CalData;
|
|
CalData.Day = i;
|
|
|
|
FTimeOfDayData CompareData = FTimeOfDayData(currentYear, Month, i, currentHours, GetCurrentMinutes());
|
|
for (auto CalendarEvent : CalendarEvents)
|
|
{
|
|
const bool passCheck = CalendarEvent->StartDate.Year <= currentYear &&
|
|
CalendarEvent->StartDate.Day == i &&
|
|
((CalendarEvent->StartDate.Month == Month && CalendarEvent->EventRepeat == EEventRepeatType::YEARLY) ||
|
|
(CalendarEvent->StartDate.Day == i && (CalendarEvent->EventRepeat == EEventRepeatType::MONTHLY || CalendarEvent->EventRepeat == EEventRepeatType::WEEKLY)));
|
|
|
|
if (passCheck) {
|
|
CalData.Events.Add(CalendarEvent);
|
|
}
|
|
}
|
|
Data.Add(CalData);
|
|
}
|
|
return Data;
|
|
}
|
|
|
|
FTimeOfDaySaveData ATimeOfDayManager::GetSaveData() const
|
|
{
|
|
FTimeOfDaySaveData SaveData;
|
|
SaveData.rotator = rotator;
|
|
SaveData.CurrentWeatherFadeAlpha = CurrentWeaterFadeAlpha;
|
|
SaveData.ShouldRain = ShouldRain;
|
|
SaveData.FloatMinutes = FloatMinutes;
|
|
SaveData.currentMinutes = currentMinutes;
|
|
SaveData.currentHours = currentHours;
|
|
SaveData.daysPassed = daysPassed;
|
|
SaveData.currentWeekday = currentWeekday;
|
|
SaveData.currentMonth = currentMonth;
|
|
SaveData.currentYear = currentYear;
|
|
SaveData.Raining = Raining;
|
|
SaveData.FadingOutWeather = FadingOutWeather;
|
|
SaveData.FadingWeatherTimer = FadingWeatherTimer;
|
|
SaveData.NextWeatherChangeMinutes = NextWeatherChangeMinutes;
|
|
SaveData.CurrentWeatherType = CurrentWeatherType;
|
|
SaveData.CurrentWeatherSoftObjectPath = CurrentWeatherPreset
|
|
? FSoftObjectPath(CurrentWeatherPreset)
|
|
: FSoftObjectPath("");
|
|
SaveData.QueuedWeatherSoftObjectPath = QueuedWeatherPreset
|
|
? FSoftObjectPath(QueuedWeatherPreset)
|
|
: FSoftObjectPath("");
|
|
|
|
return SaveData;
|
|
}
|
|
|
|
void ATimeOfDayManager::LoadSaveData(const FTimeOfDaySaveData &saveData)
|
|
{
|
|
rotator = saveData.rotator;
|
|
CurrentWeaterFadeAlpha = saveData.CurrentWeatherFadeAlpha;
|
|
ShouldRain = saveData.ShouldRain;
|
|
FloatMinutes = saveData.FloatMinutes;
|
|
currentMinutes = saveData.currentMinutes;
|
|
currentHours = saveData.currentHours;
|
|
daysPassed = saveData.daysPassed;
|
|
currentWeekday = saveData.currentWeekday;
|
|
currentMonth = saveData.currentMonth;
|
|
currentYear = saveData.currentYear;
|
|
Raining = saveData.Raining;
|
|
FadingOutWeather = saveData.FadingOutWeather;
|
|
FadingWeatherTimer = saveData.FadingWeatherTimer;
|
|
NextWeatherChangeMinutes = saveData.NextWeatherChangeMinutes;
|
|
CurrentWeatherType = saveData.CurrentWeatherType;
|
|
CurrentWeatherPreset = Cast<UWeatherPresetDataAsset>(saveData.CurrentWeatherSoftObjectPath.TryLoad());
|
|
QueuedWeatherPreset = Cast<UWeatherPresetDataAsset>(saveData.CurrentWeatherSoftObjectPath.TryLoad());
|
|
}
|
|
|
|
int32 ATimeOfDayManager::GetWeatherDistributionMaxValue() const
|
|
{
|
|
float Value = 0;
|
|
TArray<UWeatherPresetDataAsset *> Keys;
|
|
WeatherPresetDistributionMap.GetKeys(Keys);
|
|
for (int32 i = 0; i < WeatherPresetDistributionMap.Num(); i++)
|
|
{
|
|
Value += WeatherPresetDistributionMap[Keys[i]];
|
|
}
|
|
return Value;
|
|
}
|
|
|
|
UWeatherPresetDataAsset *ATimeOfDayManager::GetWeatherDistributionValue() const
|
|
{
|
|
int32 RandomDistributionValue = FMath::RandRange(0, GetWeatherDistributionMaxValue());
|
|
int CurrentMinRange = 0;
|
|
TArray<UWeatherPresetDataAsset *> Keys;
|
|
WeatherPresetDistributionMap.GetKeys(Keys);
|
|
for (int32 i = 0; i < WeatherPresetDistributionMap.Num(); i++)
|
|
{
|
|
float DistributionValue = WeatherPresetDistributionMap[Keys[i]];
|
|
if (RandomDistributionValue > CurrentMinRange && RandomDistributionValue <= (CurrentMinRange + DistributionValue))
|
|
{
|
|
return Keys[i];
|
|
}
|
|
CurrentMinRange += DistributionValue;
|
|
}
|
|
return Keys[0];
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
void ATimeOfDayManager::UpdatePreviewTime()
|
|
{
|
|
CurrentWeatherPreset = PresetOverride;
|
|
FloatMinutes = (PreviewHours * 60.f) + PreviewMinutes;
|
|
currentHours = PreviewHours;
|
|
currentMinutes = PreviewMinutes;
|
|
UpdateLightning();
|
|
}
|
|
#endif |