TimeAndWeatherManagerEntity.c

Go to the documentation of this file.

class TimeAndWeatherManagerEntityClass: BaseTimeAndWeatherManagerEntityClass
{
}
 
//~ Script invokers
void SCR_TimeAndWeatherManager_OnWeatherStatePreview(bool previewEnabled, string weatherState);
typedef func SCR_TimeAndWeatherManager_OnWeatherStatePreview;
 
void SCR_TimeAndWeatherManager_OnWindPreview(bool previewEnabled, float windSpeed, float windDirectionDegrees);
typedef func SCR_TimeAndWeatherManager_OnWindPreview;
 
void SCR_TimeAndWeatherManager_OnDateTimePreview(bool previewEnabled, int year, int month, int day, float timeOfTheDay);
typedef func SCR_TimeAndWeatherManager_OnDateTimePreview;
 
void ScriptInvokerOnWindOverrideDataChangedMethod(notnull TimeAndWeatherManagerEntity manager, bool currentState, float currentSpeed, float currentDirection);
typedef func ScriptInvokerOnWindOverrideDataChangedMethod;
typedef ScriptInvokerBase<ScriptInvokerOnWindOverrideDataChangedMethod> ScriptInvokerOnWindOverrideDataChanged;
 
void ScriptInvokerOnWeatherChangedMethod(notnull TimeAndWeatherManagerEntity manager, int currentStateId, int nextStateId, bool transitioning);
typedef func ScriptInvokerOnWeatherChangedMethod;
typedef ScriptInvokerBase<ScriptInvokerOnWeatherChangedMethod> ScriptInvokerOnWeatherChanged;


class TimeAndWeatherManagerEntity : BaseTimeAndWeatherManagerEntity
{   
    [Attribute(desc: "An ordered array of daytime info. Starting just after midnight and ending at midnight, the daytime must be ordered!")]
    protected ref array<ref SCR_DayTimeInfoBase> m_aOrderedDaytimeInfo;
    
    [Attribute(desc: "An ordered array of winddirection info, starting at north and having set steps between each wind direction. (default 45)")]
    protected ref array<ref SCR_WindDirectionInfo> m_OrderedWindDirectionInfo;
    
    [Attribute(desc: "An array of monephase naming in order from New moon to Full moon. Check GetMoonPhaseNameForDate before changing this array!")]
    protected ref array<ref SCR_MoonPhaseInfo> m_aMoonPhasesInfo;
    
    [Attribute(desc: "Ordered days of the weeks, Monday (Start), Tuesday, Wednesday, ect. to Sunday (Last)")]
    protected ref array<LocalizedString> m_aOrderedDaysOfWeek;
 
    protected int m_iDelayedPlayerChangingWind = -1;
    protected float m_fDelayedWindSpeedOverride = -1;
    protected float m_fDelayedWindDirectionOverride = -1;
    protected bool m_bListiningToWindOverrideDelay = false;
    
    //~ ScriptInvokers
    protected ref ScriptInvokerBase<SCR_TimeAndWeatherManager_OnWeatherStatePreview> m_OnWeatherStatePreview;
    protected ref ScriptInvokerBase<SCR_TimeAndWeatherManager_OnWindPreview> m_OnWindPreview;
    protected ref ScriptInvokerBase<SCR_TimeAndWeatherManager_OnDateTimePreview> m_OnDateTimePreview;
    protected ref ScriptInvokerOnWindOverrideDataChanged m_OnWindOverrideDataChanged;
    protected ref ScriptInvokerOnWeatherChanged m_OnWeatherChanged;
    
    //Replicated
    protected bool m_bWeatherIsLooping = false;
    
    [RplProp(onRplName: "OnWindOverrideStateChanged")]
    protected bool m_bDelayedWindOverride;
 
    //------------------------------------------------------------------------------------------------
    ScriptInvokerOnWindOverrideDataChanged GetOnWindOverrideDataChanged()
    {
        if (!m_OnWindOverrideDataChanged)
            m_OnWindOverrideDataChanged = new ScriptInvokerOnWindOverrideDataChanged();
 
        return m_OnWindOverrideDataChanged;
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptInvokerOnWeatherChanged GetOnWeatherChanged()
    {
        if (!m_OnWeatherChanged)
            m_OnWeatherChanged = new ScriptInvokerOnWeatherChanged();
 
        return m_OnWeatherChanged;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void OnWindOverrideStateChanged()
    {
        if (m_OnWindOverrideDataChanged)
            m_OnWindOverrideDataChanged.Invoke(this, m_bDelayedWindOverride, GetWindSpeed(), GetWindDirection());
    }
 
    //------------------------------------------------------------------------------------------------
    override protected void EOnInit(IEntity owner)
    {
        RplComponent rplComp = SCR_EntityHelper.GetEntityRplComponent(owner);
        if (!rplComp || rplComp.Role() != RplRole.Authority)
            return;
 
        SCR_WeatherTransitionCallback cb = new SCR_WeatherTransitionCallback(this);
        GetTransitionManager().AddTransitionCallbacks(cb);
    }
 
    //------------------------------------------------------------------------------------------------
    void OnWeatherChanged_S(bool transitioning = true)
    {
        int currentStateId = GetCurrentWeatherState().GetStateID();
        int nextStateId = GetTransitionManager().GetNextState().GetStateID();
        RpcDo_OnWeatherChanged(currentStateId, nextStateId, transitioning);
        Rpc(RpcDo_OnWeatherChanged, currentStateId, nextStateId, transitioning);
    }
 
    //------------------------------------------------------------------------------------------------
    [RplRpc(RplChannel.Reliable, RplRcver.Broadcast)]
    protected void RpcDo_OnWeatherChanged(int currentStateId, int nextStateId, bool transitioning)
    {
        if (m_OnWeatherChanged)
            m_OnWeatherChanged.Invoke(this, currentStateId, nextStateId, transitioning);
    }
 
    //------------------------------------------------------------------------------------------------
    bool IsAutomatedWindDisabled()
    {
        return m_bDelayedWindOverride;
    }
 
    //------------------------------------------------------------------------------------------------
    bool SetWeatherStatePreview(bool preview, string stateName = "")
    {
        BaseWeatherStateTransitionManager weatherStateTransitionManager = GetTransitionManager();
        if (!weatherStateTransitionManager)
            return false;
        
        if (!weatherStateTransitionManager.SetStatePreview(preview, stateName))
            return false;
        
        //Script invoker
        if (m_OnWeatherStatePreview)
            m_OnWeatherStatePreview.Invoke(preview, stateName);
        
        return true;
    }
    
    //------------------------------------------------------------------------------------------------
    bool SetWindPreview(bool preview, float windSpeed = -1, float windAngleDegrees = -1)
    {
        BaseWeatherStateTransitionManager weatherStateTransitionManager = GetTransitionManager();
        if (!weatherStateTransitionManager)
            return false;
        
        if (!weatherStateTransitionManager.SetWindPreview(preview, windSpeed, windAngleDegrees))
            return false;
        
        //Script invoker
        if (m_OnWindPreview)
            m_OnWindPreview.Invoke(preview, windSpeed, windAngleDegrees);
        
        return true;
    }
    
    //------------------------------------------------------------------------------------------------
    bool SetDateTimePreview(bool preview, int year = -1, int month = -1, int day = -1, float timeOfTheDay = -1)
    {
        BaseWeatherStateTransitionManager weatherStateTransitionManager = GetTransitionManager();
        if (!weatherStateTransitionManager)
            return false;
        
        if (!weatherStateTransitionManager.SetDateTimePreview(preview, year, month, day, timeOfTheDay))
            return false;
        
        //Script ScriptInvoker
        if (m_OnDateTimePreview)
            m_OnDateTimePreview.Invoke(preview, year, month, day, timeOfTheDay);
        
        return true;
    }
    
    //------------------------------------------------------------------------------------------------
    bool IsSunSet()
    {
        return IsSunSet(GetTimeOfTheDay());
    }
    
    //------------------------------------------------------------------------------------------------
    bool IsSunSet(float timeToCheck)
    {
        float sunSetTime, sunRiseTime;
        
        //~ The sun never sets
        if (!GetSunsetHour(sunSetTime))
            return false;
        
        //~ The sun never rises
        if (!GetSunriseHour(sunRiseTime))
            return true;
        
        //~ Returns if given time is >= than sunset or smaller than sunrise time
        return (timeToCheck >= sunSetTime || timeToCheck < sunRiseTime);
    }
    
    //------------------------------------------------------------------------------------------------
    string GetWeekDayString()
    {       
        int weekdayIndex = GetWeekDay();
        
        if (weekdayIndex < 0 || weekdayIndex > m_aOrderedDaysOfWeek.Count())
            return string.Empty;
        
        return m_aOrderedDaysOfWeek[weekdayIndex];
    }
    
    //------------------------------------------------------------------------------------------------
    string GetWeekDayStringForDate(int year, int month, int day)
    {
        int weekdayIndex = GetWeekDayForDate(year, month, day);
        
        if (weekdayIndex < 0 || weekdayIndex > m_aOrderedDaysOfWeek.Count())
            return string.Empty;
        
         return m_aOrderedDaysOfWeek[weekdayIndex];
    }
    
    
    //------------------------------------------------------------------------------------------------
    void SetCurrentWeatherLooping(bool setLooping, int playerChangedLooping = 0)
    {
        ForceWeatherTo(setLooping, playerThatChangedWeather: playerChangedLooping);
    }
    
    //------------------------------------------------------------------------------------------------
    void ForceWeatherTo(bool setLooping, string weatherID = string.Empty, float transitionDuration = 0, float stateDuration = 0.001, int playerThatChangedWeather = 0)
    {
        if (!Replication.IsServer())
        {
            Print("'ForceWeatherTo' was called in 'TimeAndWeatherManagerEntity' but only server has authority to change weather!", LogLevel.WARNING);
            return;
        }
        
        BaseWeatherStateTransitionManager transitionManager = GetTransitionManager();   
        if (!transitionManager)
        {
            Print("'ForceWeatherTo' was called in 'TimeAndWeatherManagerEntity' but TransitionManager was not found!", LogLevel.WARNING);
            return;
        }
        
        if (weatherID.IsEmpty())
        {
            WeatherState currentWeather = transitionManager.GetCurrentState();
            weatherID = currentWeather.GetStateName();
        }
            
        WeatherStateTransitionNode transitionNode = transitionManager.CreateStateTransition(weatherID, transitionDuration, stateDuration);
        if (!transitionNode)
        {
            Print("'ForceWeatherTo' in 'TimeAndWeatherManagerEntity' could not create a new WeatherStateTransitionNode", LogLevel.WARNING);
            return;
        }
        
        transitionNode.SetLooping(setLooping);
        
        //~ Remove Preview if any
        if (transitionManager.IsPreviewingState())
            SetWeatherStatePreview(false);
        
        transitionManager.EnqueueStateTransition(transitionNode, false);
        transitionManager.RequestStateTransitionImmediately(transitionNode);
        
        //~ Send to clients if weather is looping or not
        if (setLooping != m_bWeatherIsLooping)
        {
            UpdateWeatherLooping(setLooping);
            Rpc(UpdateWeatherLooping, setLooping);
        }
        
        //~ Send notification if player ID was given
        if (playerThatChangedWeather > 0)
        {
            if (!setLooping)
            {
                SCR_NotificationsComponent.SendToUnlimitedEditorPlayers(ENotification.EDITOR_ATTRIBUTES_WEATHER_AUTO, playerThatChangedWeather);
            }
            else 
            {
                BaseGameMode gameMode = GetGame().GetGameMode();
                if (gameMode)
                {
                    SCR_NotificationSenderComponent notificationSender = SCR_NotificationSenderComponent.Cast(gameMode.FindComponent(SCR_NotificationSenderComponent));
                    
                    if (notificationSender)
                        notificationSender.OnWeatherChangedNotification(playerThatChangedWeather);
                }
            }
        }
    }
    
    //------------------------------------------------------------------------------------------------
    [RplRpc(RplChannel.Reliable, RplRcver.Broadcast)]
    protected void UpdateWeatherLooping(bool isLooping)
    {   
        m_bWeatherIsLooping = isLooping;
    }
    
    //------------------------------------------------------------------------------------------------
    bool IsWeatherLooping()
    {
        return m_bWeatherIsLooping;
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_MoonPhaseUIInfo GetCurrentMoonPhaseInfoForDate()
    {
        int day, month, year;
        GetDate(year, month, day);
        return GetMoonPhaseInfoForDate(year, month, day, GetTimeOfTheDay(), GetTimeZoneOffset(), GetDSTOffset(), GetCurrentLatitude());
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_MoonPhaseUIInfo GetMoonPhaseInfoForDate(int year, int month, int day, float timeOfTheDay24, float timezone, float dstOffset, float Latitude)
    {
        if (m_aMoonPhasesInfo.IsEmpty())
        {
            Print("Could not get moon phase name as m_aMoonPhasesInfo is empty!", LogLevel.ERROR);
            return null;
        }
        
        float moonPhaseAmount = GetMoonPhaseForDate(year, month, day, timeOfTheDay24, timezone, dstOffset);     
        
        int nextPhaseYearCheck = year;
        int nextPhaseMonthCheck = month;
        int nextPhaseDayCheck = day + 1;
        
        //Calculate if the next day is a valid date
        if (!CheckValidDate(nextPhaseYearCheck, nextPhaseMonthCheck, nextPhaseDayCheck))
        {
            if (nextPhaseMonthCheck != 12)
            {
                nextPhaseMonthCheck += 1;
            }   
            else
            {
                nextPhaseMonthCheck = 1;
                nextPhaseYearCheck += 1;
            }
            
            nextPhaseDayCheck = 1;
        }
        
        //Check the next days moon phase
        float nextPhaseAmount = GetMoonPhaseForDate(nextPhaseYearCheck, nextPhaseMonthCheck, nextPhaseDayCheck, timeOfTheDay24, timezone, dstOffset);
        EMoonPhaseEnums beforeOrAfterFullMoon;
        
        //Check if current moonphase is before or after full moon by checking if next days moonphase amount is higher or lower then current moon phase amount
        if (nextPhaseAmount > moonPhaseAmount)
            beforeOrAfterFullMoon = EMoonPhaseEnums.BEFORE_FULL_MOON;
        else 
            beforeOrAfterFullMoon = EMoonPhaseEnums.AFTER_FULL_MOON;
            
        int count = m_aMoonPhasesInfo.Count();
        
        SCR_MoonPhaseUIInfo uiInfo;
        
        for(int i = 0; i < count; i++)
        {
            if (i == count -1)
            {
                uiInfo = m_aMoonPhasesInfo[i].GetUIInfo();
                break;
            }
 
            if (m_aMoonPhasesInfo[i].IsMoonPhase(moonPhaseAmount, beforeOrAfterFullMoon))
            {
                uiInfo = m_aMoonPhasesInfo[i].GetUIInfo();
                break;
            }
                
        }
        
        if (uiInfo)
            uiInfo.SetMoonphaseImageRotation(Latitude >= 0);
        
        return uiInfo;
    }
    
    //------------------------------------------------------------------------------------------------
    // Sets the current weather.
    // Only issuable by the authority.
    // Automatically broadcast to all clients.
    // \param hours Current weather as a normalized value <0.0, 1.0>
    // \param immediateChange Whether change should be applied immediately, forcing recomputation. This should be true only in case of editor and similar items.
    // \return Returns true when command is issued successfully, false otherwise.
    //proto native bool SetCurrentWeather(float weather01, bool immediateChange = false);
    
    //------------------------------------------------------------------------------------------------
    // Retrieves the current weather.
    // \return Current weather as a normalized value <0.0, 1.0>
    //proto native float GetCurrentWeather();
    
    //------------------------------------------------------------------------------------------------
    // Sets the current preset.
    // Only issuable by the authority.
    // Automatically broadcast to all clients.
    // \param hours Current preset as a normalized value <0.0, 1.0>
    // \param immediateChange Whether change should be applied immediately, forcing recomputation. This should be true only in case of editor and similar items.
    // \return Returns true when command is issued successfully, false otherwise.
    //proto native bool SetCurrentPreset(float preset01, bool immediateChange = false);
    
    //------------------------------------------------------------------------------------------------
    // Retrieves the current preset.
    // \return Current preset as a normalized value <0.0, 1.0>
    // proto native float GetCurrentPreset();
 
    
    //------------------------------------------------------------------------------------------------
    TimeContainer GetTime()
    {
        ref TimeContainer cont = new TimeContainer();
        GetHoursMinutesSeconds(cont.m_iHours, cont.m_iMinutes, cont.m_iSeconds);
        return cont;
    }
    
    //------------------------------------------------------------------------------------------------
    protected void CreateDayTimeInfoArray(int year = -1, int month = -1, int day = -1)
    {
        foreach (SCR_DayTimeInfoBase dayTimeInfo: m_aOrderedDaytimeInfo)
            dayTimeInfo.Clear();
        
        foreach (SCR_DayTimeInfoBase dayTimeInfo: m_aOrderedDaytimeInfo)
            dayTimeInfo.SetDayTime(m_aOrderedDaytimeInfo, this, year, month, day);
    }
    
    //------------------------------------------------------------------------------------------------
    int GetCurrentDayTimeUIInfo(out SCR_UIInfo uiInfo)
    {
        CreateDayTimeInfoArray();
        return GetDayTimeUIInfo(GetTimeOfTheDay(), uiInfo);     
    }
    
    //------------------------------------------------------------------------------------------------
    EDayTimeEnums GetCurrentDayTimeUIInfoAndPhase(out SCR_UIInfo uiInfo)
    {
        CreateDayTimeInfoArray();
        EDayTimeEnums dayTimePhase;
        return GetDayTimeUIInfo(GetTimeOfTheDay(), uiInfo, dayTimePhase);       
    }
    
    //------------------------------------------------------------------------------------------------
    int GetDayTimeUIInfo(float TimeOfDay, out SCR_UIInfo uiInfo, out EDayTimeEnums dayTimePhase = -1, int year = -1, int month = -1, int day = -1)
    {
        CreateDayTimeInfoArray(year, month, day);
        
        int count = m_aOrderedDaytimeInfo.Count();
        
        //If before early morning but after midnight
        if (TimeOfDay < m_aOrderedDaytimeInfo[0].GetDayTime())
        {
            uiInfo = m_aOrderedDaytimeInfo[count -1].GetDayTimeUIInfo();
            dayTimePhase =  m_aOrderedDaytimeInfo[count -1].GetDaytimeEnum();
            return count -1;
        }
        
        for (int i = 0; i < count -1; i++)
        {
            if (TimeOfDay > m_aOrderedDaytimeInfo[i].GetDayTime() && TimeOfDay < m_aOrderedDaytimeInfo[i +1].GetDayTime())
            {
                uiInfo = m_aOrderedDaytimeInfo[i].GetDayTimeUIInfo();
                dayTimePhase =  m_aOrderedDaytimeInfo[i].GetDaytimeEnum();
                return i;
            } 
        }
        
        //Just before Midnight
        uiInfo = m_aOrderedDaytimeInfo[count -2].GetDayTimeUIInfo();
        dayTimePhase =  m_aOrderedDaytimeInfo[count -2].GetDaytimeEnum();
        return count -2;
    }
    
    //------------------------------------------------------------------------------------------------
    int GetDayTimeInfoArray(out notnull array<SCR_DayTimeInfoBase> dayTimeInfoArray, int year = -1, int month = -1, int day = -1)
    {
        CreateDayTimeInfoArray(year, month, day);
        
        dayTimeInfoArray.Clear();
        
        foreach (SCR_DayTimeInfoBase info: m_aOrderedDaytimeInfo)
            dayTimeInfoArray.Insert(info);
        
        return dayTimeInfoArray.Count();
    }
    
 
    //------------------------------------------------------------------------------------------------
    int GetOrderedWindDirectionInfoArray(notnull array<SCR_WindDirectionInfo> orderedWindDirectionInfo)
    {
        foreach (SCR_WindDirectionInfo windInfo: m_OrderedWindDirectionInfo)
            orderedWindDirectionInfo.Insert(windInfo);
        
        return m_OrderedWindDirectionInfo.Count();
    }
    
 
    //------------------------------------------------------------------------------------------------
    bool GetWindDirectionInfoFromIndex(int index, out SCR_WindDirectionInfo windDirectionInfo)
    {
        if (m_OrderedWindDirectionInfo.IsEmpty() || index < 0 || index >= m_OrderedWindDirectionInfo.Count())
            return false;
        
        windDirectionInfo = m_OrderedWindDirectionInfo[index];
        return true;
    }
    
 
    //------------------------------------------------------------------------------------------------
    bool GetWindDirectionInfoFromFloat(float windDirectionFloat, out int index, out SCR_WindDirectionInfo windDirectionInfo)
    {
        if (m_OrderedWindDirectionInfo.IsEmpty() || m_OrderedWindDirectionInfo.Count() < 2)
            return false;
        
        int count = m_OrderedWindDirectionInfo.Count();
        float checkRange = (m_OrderedWindDirectionInfo[1].GetWindDirectionValue() - m_OrderedWindDirectionInfo[0].GetWindDirectionValue()) / 2;
        
        for (int i = 0; i < count; i++)
        {
            float firstCheck = m_OrderedWindDirectionInfo[i].GetWindDirectionValue() - checkRange;
            float secondCheck = m_OrderedWindDirectionInfo[i].GetWindDirectionValue() + checkRange;
    
            if (firstCheck < 0)
            {           
                firstCheck = firstCheck + 360;  
                if ((windDirectionFloat <= m_OrderedWindDirectionInfo[i].GetWindDirectionValue() || windDirectionFloat >= firstCheck) || (windDirectionFloat < secondCheck))
                {
                    index = i;
                    windDirectionInfo = m_OrderedWindDirectionInfo[i];
                    return true;
                }
                
            }
            else if (secondCheck > 360)
            {
                secondCheck = secondCheck - 360;
                if ((windDirectionFloat >= firstCheck) && (windDirectionFloat > m_OrderedWindDirectionInfo[i].GetWindDirectionValue() || windDirectionFloat <= secondCheck))
                {
                    index = i;
                    windDirectionInfo = m_OrderedWindDirectionInfo[i];
                    return true;
                }
            }
            else 
            {
                if (windDirectionFloat >= firstCheck && windDirectionFloat < secondCheck)
                {
                    index = i;
                    windDirectionInfo = m_OrderedWindDirectionInfo[i];
                    return true;
                }
            }
        }
        return false;
    }

 
    //------------------------------------------------------------------------------------------------
    void DelayedSetWindOverride(bool overrideWind, int playerChangingWind = -1)
    {
        m_bDelayedWindOverride = overrideWind;
        
        if (playerChangingWind > -1)
            m_iDelayedPlayerChangingWind = playerChangingWind;
        
        StartListeningToWindApplyDelay();
    }
    
 
    //------------------------------------------------------------------------------------------------
    void DelayedOverrideWindSpeed(float windSpeed, int playerChangingWind = -1)
    {
        m_fDelayedWindSpeedOverride = windSpeed;
        
        if (playerChangingWind > -1)
            m_iDelayedPlayerChangingWind = playerChangingWind;
        
        StartListeningToWindApplyDelay();
    }
    
 
    //------------------------------------------------------------------------------------------------
    void DelayedOverrideWindDirection(float windDirection, int playerChangingWind = -1)
    {
        m_fDelayedWindDirectionOverride = windDirection;
        
        if (playerChangingWind > -1)
            m_iDelayedPlayerChangingWind = playerChangingWind;
        
        StartListeningToWindApplyDelay();
    }
    
    //Start listening to the frame delay to execute all wind changed in one go
    protected void StartListeningToWindApplyDelay()
    {
        if (m_bListiningToWindOverrideDelay)
            return;
        
        m_bListiningToWindOverrideDelay = true;
        GetGame().GetCallqueue().CallLater(DelayedApplyWindOverride, 1);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void DelayedApplyWindOverride()
    {
        //Set wind to auto
        if (!m_bDelayedWindOverride)
        {
            SetWindSpeedOverride(false);
            SetWindDirectionOverride(false);
        }
        //Override wind
        else 
        {
            if (m_fDelayedWindSpeedOverride == -1)
                m_fDelayedWindSpeedOverride = GetWindSpeed();
            
            SetWindSpeedOverride(true, m_fDelayedWindSpeedOverride);
            
            if (m_fDelayedWindDirectionOverride == -1)
                m_fDelayedWindDirectionOverride =  GetWindDirection();
            
            SetWindDirectionOverride(true, m_fDelayedWindDirectionOverride);    
        }
 
        int changingPlayerId = m_iDelayedPlayerChangingWind;
        ClearDelayedWindOverrideVars();
        RpcDo_OnWindDataUpdated(m_bDelayedWindOverride, changingPlayerId);
        Rpc(RpcDo_OnWindDataUpdated, m_bDelayedWindOverride, changingPlayerId);
    }
 
    //------------------------------------------------------------------------------------------------
    [RplRpc(RplChannel.Reliable, RplRcver.Broadcast)]
    protected void RpcDo_OnWindDataUpdated(bool currentState, int changingPlayerId)
    {
        float speed = GetWindSpeed();
        float direction = GetWindDirection();
        m_bDelayedWindOverride = currentState;
        if (m_OnWindOverrideDataChanged)
            m_OnWindOverrideDataChanged.Invoke(this, m_bDelayedWindOverride, speed, direction);
 
        if (changingPlayerId < 0)
            return;
 
        if (m_bDelayedWindOverride)
        {
            int windDirectionIndex;
            GetWindDirectionInfoFromFloat(direction, windDirectionIndex, null);
            SCR_NotificationsComponent.SendLocalUnlimitedEditor(ENotification.EDITOR_ATTRIBUTES_WIND_CHANGED, changingPlayerId, speed * 1000, windDirectionIndex);
        }
        else
        {
            SCR_NotificationsComponent.SendLocalUnlimitedEditor(ENotification.EDITOR_ATTRIBUTES_WIND_DEFAULT, changingPlayerId);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    protected void ClearDelayedWindOverrideVars()
    {
        m_bListiningToWindOverrideDelay = false;
        m_bDelayedWindOverride = IsWindSpeedOverridden() || IsWindDirectionOverridden();
        m_iDelayedPlayerChangingWind = -1;
        m_fDelayedWindSpeedOverride = -1;
        m_fDelayedWindDirectionOverride = -1;
    }
    
 
    //------------------------------------------------------------------------------------------------
    bool SetTime(TimeContainer cont)
    {
        return SetHoursMinutesSeconds(cont.m_iHours, cont.m_iMinutes, cont.m_iSeconds);
    }
    
    //------------------------------------------------------------------------------------------------
 
    //------------------------------------------------------------------------------------------------
    ScriptInvokerBase<SCR_TimeAndWeatherManager_OnWeatherStatePreview> GetOnWeatherStatePreview()
    {
        if (!m_OnWeatherStatePreview)
            m_OnWeatherStatePreview = new ScriptInvokerBase<SCR_TimeAndWeatherManager_OnWeatherStatePreview>();
    
        return m_OnWeatherStatePreview;
    }
    
    //------------------------------------------------------------------------------------------------
    ScriptInvokerBase<SCR_TimeAndWeatherManager_OnWindPreview> GetOnWindPreview()
    {
        if (!m_OnWindPreview)
            m_OnWindPreview = new ScriptInvokerBase<SCR_TimeAndWeatherManager_OnWindPreview>();
    
        return m_OnWindPreview;
    }
    
    //------------------------------------------------------------------------------------------------
 
    //------------------------------------------------------------------------------------------------
    ScriptInvokerBase<SCR_TimeAndWeatherManager_OnDateTimePreview> GetOnDateTimePreview()
    {
        if (!m_OnDateTimePreview)
            m_OnDateTimePreview = new ScriptInvokerBase<SCR_TimeAndWeatherManager_OnDateTimePreview>();
    
        return m_OnDateTimePreview;
    }
    
    //======================================== RPL ========================================\\
 
    //------------------------------------------------------------------------------------------------
    override bool RplSave(ScriptBitWriter writer)
    {   
        writer.WriteBool(m_bWeatherIsLooping); 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    override bool RplLoad(ScriptBitReader reader)
    {
        int isLooping;
        
        reader.ReadBool(isLooping);
 
        
        UpdateWeatherLooping(isLooping);
        
        return true;
    }
    
     //proto native bool SetWeatherState(string stateName, bool setToStartVariant = true);
     
    //proto native bool SetWeatherVariant(string variantName);

    //proto native bool SetWeatherStateAndVariant(string stateName, string variantName);
    
    //proto native WeatherTransitionRequestResponse RequestWeatherStateTransition(string stateName, float durationHrs = 0);
    
    //proto native WeatherTransitionRequestResponse RequestWeatherVariantTransition(string variantName, float durationHrs = 0);
}

class TimeContainer
{
    int m_iHours;
    int m_iMinutes;
    int m_iSeconds;
    
 
    //------------------------------------------------------------------------------------------------
    // constructor
    void TimeContainer(int hours = 0, int minutes = 0, int seconds = 0)
    {
        m_iHours = hours;
        m_iMinutes = minutes;
        m_iSeconds = seconds;
    }
    
    /*
        Creates new time container from hours, minutes and seconds.
    */
 
    //------------------------------------------------------------------------------------------------
    static TimeContainer FromHoursMinutesSeconds(int hours, int minutes, int seconds)
    {
        return new TimeContainer(hours, minutes, seconds);
    }
    
    /*
        Creates new time container from time of  the day <0.0, 0.24>
    */
 
    //------------------------------------------------------------------------------------------------
    static TimeContainer FromTimeOfTheDay(float hours24)
    {
        int h, m, s;
        TimeAndWeatherManagerEntity.TimeToHoursMinutesSeconds(hours24, h, m, s);
        return new TimeContainer(h, m, s);
    }
    
    /*
        Converts the content of this container into in-game time as a fraction of day <0.0, 0.24>.
    */
 
    //------------------------------------------------------------------------------------------------
    float ToTimeOfTheDay()
    {
        return TimeAndWeatherManagerEntity.HoursMinutesSecondsToTime(m_iHours, m_iMinutes, m_iSeconds);
    }
}
 
[BaseContainerProps(), SCR_BaseContainerCustomTitleEnum(EDayTimeEnums, "m_dayTimeEnum")]
class SCR_DayTimeInfoBase
{
    [Attribute("0", UIWidgets.ComboBox, "Day Time Enum", "", ParamEnumArray.FromEnum(EDayTimeEnums))]
    protected EDayTimeEnums m_DayTimeEnum;
        
    [Attribute()]
    protected ref SCR_UIInfo m_UIInfo;
    
    protected float m_fTimeOfDay = -1;
    
    //------------------------------------------------------------------------------------------------
    SCR_UIInfo GetDayTimeUIInfo()
    {
        return m_UIInfo;
    }
    
    //------------------------------------------------------------------------------------------------
    EDayTimeEnums GetDaytimeEnum()
    {
        return m_DayTimeEnum;
    }
    
    //------------------------------------------------------------------------------------------------
    float GetDayTime()
    {
        return m_fTimeOfDay;
    }
 
    //------------------------------------------------------------------------------------------------
    void Clear()
    {
        m_fTimeOfDay = -1;
    }
 
    //------------------------------------------------------------------------------------------------
    float GetDayTime(notnull array<ref SCR_DayTimeInfoBase> daytimeInfo, TimeAndWeatherManagerEntity timeAndWeatherEntity)
    {
        if (m_fTimeOfDay < 0)
            SetDayTime(daytimeInfo, timeAndWeatherEntity);
        
        return m_fTimeOfDay;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetDayTime(notnull array<ref SCR_DayTimeInfoBase> daytimeInfo, TimeAndWeatherManagerEntity timeAndWeatherEntity, int year = -1, int month = -1, int day = -1)
    {
        Print(string.Format("%1 Uses the SCR_DayTimeInfoBase use one of the inherited classes instead!", typename.EnumToString(EDayTimeEnums, m_DayTimeEnum)), LogLevel.WARNING);
    }
}
 
[BaseContainerProps(), SCR_BaseContainerCustomTitleEnum(EDayTimeEnums, "m_dayTimeEnum")]
class SCR_DayTimeInfoStatic: SCR_DayTimeInfoBase
{
    [Attribute(desc: "Hour which this daytime starts, is a value of 0 to 24.0")]
    protected int m_iHour;
 
    //------------------------------------------------------------------------------------------------
    override void SetDayTime(notnull array<ref SCR_DayTimeInfoBase> daytimeInfo, TimeAndWeatherManagerEntity timeAndWeatherEntity, int year = -1, int month = -1, int day = -1)
    {
        if (m_fTimeOfDay > -1)
            return;
        
        m_fTimeOfDay = m_iHour;
    }
}
 
[BaseContainerProps(), SCR_BaseContainerCustomTitleEnum(EDayTimeEnums, "m_dayTimeEnum")]
class SCR_DayTimeInfoAuto: SCR_DayTimeInfoBase
{
    //------------------------------------------------------------------------------------------------
    override void SetDayTime(notnull array<ref SCR_DayTimeInfoBase> daytimeInfo, TimeAndWeatherManagerEntity timeAndWeatherEntity, int year = -1, int month = -1, int day = -1)
    {
        if (m_fTimeOfDay > -1)
            return;
        
        if (year < 0)
        {
            timeAndWeatherEntity.GetDate(year, month, day);
        }
        
        bool hasSunSetandRise;
        
        switch (m_DayTimeEnum)
        {
            //~Todo: Needs to get sunset/sun rise of given date
            case EDayTimeEnums.DAYTIME_DAWN:
            {   
                hasSunSetandRise = timeAndWeatherEntity.GetSunriseHourForDate(year, month, day, timeAndWeatherEntity.GetCurrentLatitude(), timeAndWeatherEntity.GetCurrentLongitude(), timeAndWeatherEntity.GetTimeZoneOffset(),  timeAndWeatherEntity.GetDSTOffset(),  m_fTimeOfDay);
                
                //If has no sun rise
                if (!hasSunSetandRise)
                    m_fTimeOfDay = 5;
 
                return;
            }
            //~Todo: Get sunset time
            case EDayTimeEnums.DAYTIME_DUSK:
            {   
                hasSunSetandRise = timeAndWeatherEntity.GetSunsetHourForDate(year, month, day, timeAndWeatherEntity.GetCurrentLatitude(), timeAndWeatherEntity.GetCurrentLongitude(), timeAndWeatherEntity.GetTimeZoneOffset(),  timeAndWeatherEntity.GetDSTOffset(),  m_fTimeOfDay);
                
                //If has no sun set
                if (!hasSunSetandRise)
                    m_fTimeOfDay = 19;
                
                return;
            }
        }
            
        Print(string.Format("%1 is not supported with autoTime!", typename.EnumToString(EDayTimeEnums, m_DayTimeEnum)), LogLevel.WARNING);
    }
}
 
[BaseContainerProps(), SCR_BaseContainerCustomTitleEnum(EDayTimeEnums, "m_dayTimeEnum")]
class SCR_DayTimeInfoBetween: SCR_DayTimeInfoBase
{
    [Attribute("0", UIWidgets.ComboBox, "Day Time X", "", ParamEnumArray.FromEnum(EDayTimeEnums))]
    protected EDayTimeEnums m_DaytimeAfter;
    
    [Attribute("0", UIWidgets.ComboBox, "Day Time Y", "", ParamEnumArray.FromEnum(EDayTimeEnums))]
    protected EDayTimeEnums m_DaytimeBefore;
 
    //------------------------------------------------------------------------------------------------
    override void SetDayTime(notnull array<ref SCR_DayTimeInfoBase> daytimeInfo, TimeAndWeatherManagerEntity timeAndWeatherEntity, int year = -1, int month = -1, int day = -1)
    {
        if (m_DayTimeEnum == m_DaytimeAfter || m_DayTimeEnum == m_DaytimeBefore)
        {   
            Print(string.Format("SCR_DayTimeInfoBetween %1 has a reference to itself!", typename.EnumToString(EDayTimeEnums, m_DayTimeEnum)), LogLevel.WARNING);    
            return;
        }
        
        if (m_fTimeOfDay > -1)
            return;
        
        float dayTimeAfterSeconds, DayTimeBeforeSeconds;
        bool dayTimeAfterSet = false;
        bool dayTimeBeforeSet = false;
        
        foreach (SCR_DayTimeInfoBase daytime: daytimeInfo)
        {
            if (daytime.GetDaytimeEnum() == m_DaytimeAfter)
            {
                dayTimeAfterSeconds = daytime.GetDayTime(daytimeInfo, timeAndWeatherEntity);
                dayTimeAfterSet = true;
                
                if (dayTimeAfterSeconds == 24)
                    dayTimeAfterSeconds = 0;
                
                if (dayTimeAfterSet && dayTimeBeforeSet)
                    break;
            }
            else if (daytime.GetDaytimeEnum() == m_DaytimeBefore)
            {
                DayTimeBeforeSeconds = daytime.GetDayTime(daytimeInfo, timeAndWeatherEntity);
                dayTimeBeforeSet = true;
                
                if (DayTimeBeforeSeconds == 0)
                    DayTimeBeforeSeconds = 24;
                
                if (dayTimeAfterSet && dayTimeBeforeSet)
                    break;
            }
        }
        
        if (dayTimeAfterSeconds < 0 || !dayTimeAfterSet)
        {
            Print(string.Format("Could not set %1 as %2 daytime after was not correctly found! This might be because %2 is also depened on %1 or that it doesn't exist in the array!", typename.EnumToString(EDayTimeEnums, m_DayTimeEnum), typename.EnumToString(EDayTimeEnums, m_DaytimeAfter)), LogLevel.WARNING);
            m_fTimeOfDay = 0;
            return;
        }
            
        if (DayTimeBeforeSeconds < 0 || !dayTimeBeforeSet)
        {
            Print(string.Format("Could not set %1 as %2 daytime before was not correctly found! This might be because %2 is also depened on %1 or that it doesn't exist in the array!", typename.EnumToString(EDayTimeEnums, m_DayTimeEnum), typename.EnumToString(EDayTimeEnums, m_DaytimeBefore)), LogLevel.WARNING);  
            m_fTimeOfDay = 0;
            return;
        }
        
        m_fTimeOfDay = (dayTimeAfterSeconds + DayTimeBeforeSeconds) / 2;
    }
}
 
[BaseContainerProps(), SCR_BaseContainerCustomTitleUIInfo("m_UIInfo")]
class SCR_WindDirectionInfo
{
    [Attribute()]
    ref SCR_UIInfo m_UIInfo;
    
    [Attribute()]
    protected int m_iWindDirection;
    
    //------------------------------------------------------------------------------------------------
    SCR_UIInfo GetUIInfo()
    {
        return m_UIInfo;
    }
    
    //------------------------------------------------------------------------------------------------
    int GetWindDirectionValue()
    {
        return m_iWindDirection;
    }
}
 
[BaseContainerProps(), SCR_BaseContainerCustomTitleUIInfo("m_UIInfo")]
class SCR_MoonPhaseInfo
{
    [Attribute()]
    ref SCR_MoonPhaseUIInfo m_UIInfo;
    
    [Attribute(desc: "IsMoonPhase will return true if moonPhaseAmount is equal or greater then m_fPhaseEqualOrGreater and less then m_fPhaseLessThen")]
    protected float m_fPhaseEqualOrGreater;
    
    [Attribute(desc: "IsMoonPhase will return true if moonPhaseAmount is equal or greater then m_fPhaseEqualOrGreater and less then m_fPhaseLessThen")]
    protected float m_fPhaseLessThen;
    
    [Attribute("0", UIWidgets.ComboBox, "Before Or AfterFull Moon", "", ParamEnumArray.FromEnum(EMoonPhaseEnums))]
    protected EMoonPhaseEnums m_iBeforeOrAfterFullMoon;
    
    //------------------------------------------------------------------------------------------------
    SCR_MoonPhaseUIInfo GetUIInfo()
    {
        return m_UIInfo;
    }
    
    //------------------------------------------------------------------------------------------------
    bool IsMoonPhase(float moonPhaseAmount, EMoonPhaseEnums beforeOrAfterFullMoon)
    {
        if (m_iBeforeOrAfterFullMoon != EMoonPhaseEnums.IGNORE && beforeOrAfterFullMoon != EMoonPhaseEnums.IGNORE)
        {
            if (m_iBeforeOrAfterFullMoon != beforeOrAfterFullMoon)
                return false;
        }
        
        return moonPhaseAmount >= m_fPhaseEqualOrGreater && moonPhaseAmount < m_fPhaseLessThen;
    }
}
 
enum EMoonPhaseEnums
{
    IGNORE,
    BEFORE_FULL_MOON,
    AFTER_FULL_MOON
}
 
enum EDayTimeEnums
{
    DAYTIME_DAWN,
    DAYTIME_MORNING,
    DAYTIME_AFTERNOON,
    DAYTIME_DUSK,
    DAYTIME_EVENING,
    DAYTIME_NIGHT
}