Граф наследования:SakhalData:

Защищенные члены
override void	CalculateWind (int newWeather, bool suddenChange, out float magnitude, out float direction)

override void	CalculateVolFog (float lerpValue, float windMagnitude, float changeTime)

override float	GetAgentSpawnChance (eAgents agent)

override float	GetColdAreaToolDamageModifier ()

bool	LogWeatherData ()

Защищенные данные
const int	CLEAR_WEATHER = 1
	DEPRECATED (see WorldDataWeatherConstants)

const int	CLOUDY_WEATHER = 2

const int	BAD_WEATHER = 3

Закрытые члены
override void	Init ()

override void	InitYieldBank ()

override void	SetupWeatherSettings ()

override void	SetupLiquidTemperatures ()

override bool	WeatherOnBeforeChange (EWeatherPhenomenon type, float actual, float change, float time)

Закрытые члены унаследованные от WorldData
void	WorldData ()

void	Init ()

float	GetApproxSunriseTime (float monthday)

float	GetApproxSunsetTime (float monthday)

int	GetDaytime ()

float	CalcBaseEnvironmentTemperature (float monthday, float daytime)

void	UpdateBaseEnvTemperature (float timeslice)

void	UpdateWeatherEffects (Weather weather, float timeslice)
	Updates local weather effects.

float	ComputeSnowflakeScale (Weather weather)
	Returns the desired snowflake scale based on weather simulation state.

float	GetBaseEnvTemperature ()

float	GetBaseEnvTemperatureAtObject (notnull Object object)

float	GetBaseEnvTemperatureAtPosition (vector pos)

float	GetBaseEnvTemperatureExact (int month, int day, int hour, int minute)

float	GetLiquidTypeEnviroTemperature (int liquidType)

bool	WeatherOnBeforeChange (EWeatherPhenomenon type, float actual, float change, float time)

array< vector >	GetArtyFiringPos ()

float	GetAgentSpawnChance (eAgents agent)

float	GetColdAreaToolDamageModifier ()

void	BaseTempDebug (int month, int day)

int	GetPollution ()

float	GetWindCoef ()

float	GetUniversalTemperatureSourceCapModifier ()

void	CalculateWind (int newWeather, bool suddenChange, out float magnitude, out float direction)

void	CalculateVolFog (float lerpValue, float windMagnitude, float changeTime)

void	CreateYieldBank ()

void	InitYieldBank ()
	override this to properly register world-specific yields

void	SetupWeatherSettings ()

void	SetupLiquidTemperatures ()

CatchYieldBank	GetCatchYieldBank ()

TStringArray	GetDefaultPRAPaths ()

float	GetDayTemperature ()

float	GetNightTemperature ()

override void	Init ()

override void	SetupWeatherSettings ()

override bool	WeatherOnBeforeChange (EWeatherPhenomenon type, float actual, float change, float time)

override void	CalculateWind (int newWeather, bool suddenChange, out float magnitude, out float direction)

override void	CalculateVolFog (float lerpValue, float windMagnitude, float changeTime)

bool	LogWeatherData ()

Закрытые данные
const float	SPAWN_CHANCE_CHOLERA = 20

const float	COLD_AREA_TOOL_DMG_MODIF = 1.2

Закрытые данные унаследованные от WorldData
float	SUDDENCHANGE_TIME_MULTIPLIER = 0.2
	how many % of environment temperature can be lowered by clouds

float	SUDDENCHANGE_LENGTH_MULTIPLIER = 0.4

float	WIND_MAGNITUDE_TIME_MULTIPLIER = 0.1

float	WIND_DIRECTION_TIME_MULTIPLIER = 0.05

Weather	m_Weather

float	m_EnvironmentTemperature

bool	m_EnTempUpdated

float	m_Timer

float	m_MaxTemps [12]

float	m_MinTemps [12]

float	m_Sunrise_Jan

float	m_Sunset_Jan

float	m_Sunrise_Jul

float	m_Sunset_Jul

ref array< vector >	m_FiringPos

bool	m_Pollution

ref CatchYieldBank	m_YieldBank

ref WorldDataWeatherSettings	m_WeatherDefaultSettings

ref WorldDataLiquidSettings	m_LiquidSettings

ref TStringArray	m_DefaultPlayerRestrictedAreas

int	m_BadWeatherChance
	weather related

int	m_ClearWeatherChance

bool	m_IsSuddenChange

float	m_WorldWindCoef

float	m_UniversalTemperatureSourceCapModifier

int	m_SameWeatherCnt = 0

int	m_StepValue = 5

int	m_Chance = 50

int	m_ChoosenWeather = 1

int	m_LastWeather = 0

float	m_DayTemperature = 10

float	m_NightTemperature = 6

const int	CLEAR_WEATHER = 1
	DEPRECATED (see WorldDataWeatherConstants)

const int	CLOUDY_WEATHER = 2

const int	BAD_WEATHER = 3

const int	OVERCAST_MIN_TIME = 600
	DEPRECATED (see WorldDataWeatherSettings)

const int	OVERCAST_MAX_TIME = 900

const float	RAIN_THRESHOLD = 0.6

const int	RAIN_TIME_MIN = 60

const int	RAIN_TIME_MAX = 120

const float	STORM_THRESHOLD = 0.9

int	m_clearWeatherChance = m_ClearWeatherChance

int	m_badWeatherChance = m_BadWeatherChance

int	m_sameWeatherCnt = m_SameWeatherCnt

int	m_stepValue = m_StepValue

int	m_chance = m_Chance

int	m_choosenWeather = m_ChoosenWeather

int	m_lastWeather = m_LastWeather

Дополнительные унаследованные члены
Закрытые статические данные унаследованные от WorldData
static const ref array< vector >	CHERNARUS_ARTY_STRIKE_POS

Подробное описание

Методы

◆ CalculateVolFog()

override void CalculateVolFog	(	float	lerpValue,
		float	windMagnitude,
		float	changeTime )

inlineprotected

    {               
        float maxVolFogDistanceDensity = Math.Lerp( 0, 0.35, Easing.EaseInQuart(lerpValue) );
        float minVolFogDistanceDensity = Math.Lerp(0.001, 0.01, m_Weather.GetOvercast().GetActual());
        
        if (minVolFogDistanceDensity > maxVolFogDistanceDensity)
            maxVolFogDistanceDensity = minVolFogDistanceDensity;
        
        float volFogDistanceDensity = Math.Lerp( minVolFogDistanceDensity, maxVolFogDistanceDensity, windMagnitude/m_Weather.GetWindMaximumSpeed() );
        m_Weather.SetDynVolFogDistanceDensity(volFogDistanceDensity, changeTime);
    }

Перекрестные ссылки Easing::EaseInQuart(), Weather::GetOvercast(), Weather::GetWindMaximumSpeed(), Math::Lerp(), WorldData::m_Weather и Weather::SetDynVolFogDistanceDensity().

Используется в CalculateWind(), Init() и WeatherOnBeforeChange().

◆ CalculateWind()

override void CalculateWind	(	int	newWeather,
		bool	suddenChange,
		out float	magnitude,
		out float	direction )

inlineprotected

    {
        magnitude = 5;
        direction = 0;      
        
        float windChance = Math.RandomIntInclusive( 0, 100 );
        
        if ( newWeather == WorldDataWeatherConstants.CLEAR_WEATHER )
        {
            if ( windChance < 15 )                      
            {
                magnitude = Math.RandomFloatInclusive( 2 , 4 );
                direction = Math.RandomFloatInclusive( -0.35 , 0.35);
            }
            else if ( windChance < 90 ) 
            {
                magnitude = Math.RandomFloatInclusive( 3 , 6 );
                direction = Math.RandomFloatInclusive( 0 , 2.2);
            }
            else
            {
                magnitude = Math.RandomFloatInclusive( 8 , 15 );
                direction = Math.RandomFloatInclusive( -3.0 , -2.25);
            }
        }       
        else if ( newWeather == WorldDataWeatherConstants.CLOUDY_WEATHER )
        {           
            if ( windChance < 45 )                      
            {
                magnitude = Math.RandomFloatInclusive( 5 , 10 );
                direction = Math.RandomFloatInclusive( 1.0 , 1.25);
            }
            else if ( windChance < 90 ) 
            {
                magnitude = Math.RandomFloatInclusive( 8 , 14 );
                direction = Math.RandomFloatInclusive( -1.8, -1.4);
            }
            else
            {
                magnitude = Math.RandomFloatInclusive( 2 , 4 );
                direction = Math.RandomFloatInclusive( -1.0 , -0.4);
            }
        }       
        else
        {
            if ( suddenChange || m_Weather.GetOvercast().GetForecast() > 0.85 )
            {
                magnitude = Math.RandomFloatInclusive( 18 , 20 );
                direction = Math.RandomFloatInclusive( 2.25 , 3.14);
            }
            else if ( windChance < 45 )                     
            {
                magnitude = Math.RandomFloatInclusive( 6 , 12 );
                direction = Math.RandomFloatInclusive( -1.8 , -1.4);
            }
            else if ( windChance < 90 ) 
            {
                magnitude = Math.RandomFloatInclusive( 8 , 20 );
                direction = Math.RandomFloatInclusive( 1.6 , 2.0);
            }
            else
            {
                magnitude = Math.RandomFloatInclusive( 4 , 10 );
                direction = Math.RandomFloatInclusive( 1.5, 1.75 );
            }           
        }       
        
        CalculateVolFog(m_Weather.GetSnowfall().GetForecast(), magnitude, 60);
    }

Перекрестные ссылки CalculateVolFog(), Weather::GetOvercast(), Weather::GetSnowfall(), WorldData::m_Weather, Math::RandomFloatInclusive() и Math::RandomIntInclusive().

Используется в WeatherOnBeforeChange().

◆ GetAgentSpawnChance()

override float GetAgentSpawnChance ( eAgents agent )

inlineprotected

    {
        if (agent == eAgents.CHOLERA)
            return SPAWN_CHANCE_CHOLERA;
        
        return 0;
    }

Перекрестные ссылки SPAWN_CHANCE_CHOLERA.

◆ GetColdAreaToolDamageModifier()

override float GetColdAreaToolDamageModifier ( )

inlineprotected

    {
        return COLD_AREA_TOOL_DMG_MODIF;
    }

Перекрестные ссылки COLD_AREA_TOOL_DMG_MODIF.

◆ Init()

override void Init ( )

inlineprivate

    {       
        super.Init();
        
        // new temperature curve settings
        m_Sunrise_Jan = 8.41;
        m_Sunset_Jan = 15.58;
        m_Sunrise_Jul = 3.75;
        m_Sunset_Jul = 20.25;
 
        int tempIdx;
        m_MinTemps = {-6.5, -9.5, -6.5, -9.5, 2, 6, 9, 10, 6, 1, -5, -10}; //{-13, -11, -7, -3, 2, 6, 9, 10, 6, 1, -5, -10} original values
        if (CfgGameplayHandler.GetEnvironmentMinTemps() && CfgGameplayHandler.GetEnvironmentMinTemps().Count() == 12)
        {
            for (tempIdx = 0; tempIdx < CfgGameplayHandler.GetEnvironmentMinTemps().Count(); tempIdx++)
            {
                m_MinTemps[tempIdx] = CfgGameplayHandler.GetEnvironmentMinTemps().Get(tempIdx);
            }
        }
 
        m_MaxTemps = {-3, -5, -3, -5, 9, 14, 16, 17, 14, 8, 1, -3}; //{-6, -4, -1, 3, 9, 14, 16, 17, 14, 8, 1, -3} original values
        if (CfgGameplayHandler.GetEnvironmentMaxTemps() && CfgGameplayHandler.GetEnvironmentMaxTemps().Count() == 12)
        {
            for (tempIdx = 0; tempIdx < CfgGameplayHandler.GetEnvironmentMaxTemps().Count(); tempIdx++)
            {
                m_MaxTemps[tempIdx] = CfgGameplayHandler.GetEnvironmentMaxTemps().Get(tempIdx);
            }
        }
        m_Pollution = m_Pollution | EPollution.HEAVYMETAL;
        
        m_TemperatureInsideBuildingsModifier    = -1.0;
        
        m_UniversalTemperatureSourceCapModifier = -3.0;
        
        m_ClearWeatherChance    = m_WeatherDefaultSettings.m_ClearWeatherChance;
        m_BadWeatherChance      = m_WeatherDefaultSettings.m_BadWeatherChance;
        
        if (GetGame().IsServer() || !GetGame().IsMultiplayer()) 
        {
            m_Weather.SetDynVolFogHeightDensity( 1, 0 );
            m_Weather.SetDynVolFogHeightBias( 0, 0 );
            m_Weather.GetFog().Set(0,0,1000);
            m_Weather.GetFog().SetLimits(0,0);
            m_Weather.GetOvercast().SetLimits(0.07, 1);
            
            if (GetGame().IsMultiplayer()) 
            {
                m_Weather.GetOvercast().Set(Math.RandomFloat(0,0.75),0,5); //forcing a random weather at a clean server start and an instant change for overcast
                CalculateVolFog(m_Weather.GetSnowfall().GetActual(),m_Weather.GetWindSpeed(),0);
            }
            
            m_DefaultPlayerRestrictedAreas = {"pra/warheadstorage.json"};
        }
        
        
    }

Перекрестные ссылки CalculateVolFog(), Count, CfgGameplayHandler::GetEnvironmentMaxTemps(), CfgGameplayHandler::GetEnvironmentMinTemps(), Weather::GetFog(), GetGame(), Weather::GetOvercast(), Weather::GetSnowfall(), Weather::GetWindSpeed(), WorldData::m_BadWeatherChance, WorldData::m_ClearWeatherChance, WorldData::m_DefaultPlayerRestrictedAreas, WorldData::m_MaxTemps, WorldData::m_MinTemps, WorldData::m_Pollution, WorldData::m_Sunrise_Jan, WorldData::m_Sunrise_Jul, WorldData::m_Sunset_Jan, WorldData::m_Sunset_Jul, WorldData::m_UniversalTemperatureSourceCapModifier, WorldData::m_Weather, WorldData::m_WeatherDefaultSettings, Math::RandomFloat(), Weather::SetDynVolFogHeightBias() и Weather::SetDynVolFogHeightDensity().

◆ InitYieldBank()

override void InitYieldBank ( )

inlineprivate

    {
        super.InitYieldBank();
        
        m_YieldBank.ClearAllRegisteredItems();
        
        //fishies
        m_YieldBank.RegisterYieldItem(new YieldItemWalleyePollock(24));
        m_YieldBank.RegisterYieldItem(new YieldItemSteelheadTrout(12));
        
        m_YieldBank.RegisterYieldItem(new YieldItemShrimp(1));
        
        //fishy junk
        m_YieldBank.RegisterYieldItem(new YieldItemJunk(1,"Wellies_Brown"));
        m_YieldBank.RegisterYieldItem(new YieldItemJunk(1,"Wellies_Grey"));
        m_YieldBank.RegisterYieldItem(new YieldItemJunk(1,"Wellies_Green"));
        m_YieldBank.RegisterYieldItem(new YieldItemJunk(1,"Wellies_Black"));
        m_YieldBank.RegisterYieldItem(new YieldItemJunkEmpty(1,"Pot"));
        
        //non-fishies
        m_YieldBank.RegisterYieldItem(new YieldItemDeadRabbit(1));
        m_YieldBank.RegisterYieldItem(new YieldItemDeadFox(1));
        //m_YieldBank.RegisterYieldItem(new YieldItemGenericSmallAnimal(1,"Animal_UrsusArctos",AnimalCatchingConstants.MASK_ENVIRO_FOREST,AnimalCatchingConstants.MASK_METHOD_LANDTRAP_MEATBAIT));
    }

Перекрестные ссылки WorldData::m_YieldBank и YieldItemJunk().

◆ LogWeatherData()

bool LogWeatherData ( )

inlineprotected

    {
        #ifdef WEATHER_DATA_LOGGING
        return true;
        #endif
        return false;
    }

◆ SetupLiquidTemperatures()

override void SetupLiquidTemperatures ( )

inlineprivate

    {
        
        m_LiquidSettings = new WorldDataLiquidSettings();
        
        m_LiquidSettings.m_Temperatures[LIQUID_SALTWATER]   = -0.5;
        m_LiquidSettings.m_Temperatures[LIQUID_WATER]       = 2.0;
        m_LiquidSettings.m_Temperatures[LIQUID_STILLWATER]  = 2.0;
        m_LiquidSettings.m_Temperatures[LIQUID_RIVERWATER]  = 2.0;
        m_LiquidSettings.m_Temperatures[LIQUID_FRESHWATER]  = 2.0;
        m_LiquidSettings.m_Temperatures[LIQUID_CLEANWATER]  = 5.0;
        m_LiquidSettings.m_Temperatures[LIQUID_SNOW]        = -5.0;
        m_LiquidSettings.m_Temperatures[LIQUID_HOTWATER]    = 90.0;
    }

Перекрестные ссылки LIQUID_CLEANWATER, LIQUID_FRESHWATER, LIQUID_HOTWATER, LIQUID_RIVERWATER, LIQUID_SALTWATER, LIQUID_SNOW, LIQUID_STILLWATER, LIQUID_WATER и WorldData::m_LiquidSettings.

◆ SetupWeatherSettings()

override void SetupWeatherSettings ( )

inlineprivate

    {
        super.SetupWeatherSettings();
        
        m_WeatherDefaultSettings.m_GlobalSuddenChance       = 95;   // works if the randomization value is bigger than this. we do not want to decrease the clear sky chance
        m_WeatherDefaultSettings.m_ClearWeatherChance       = 20;
        m_WeatherDefaultSettings.m_BadWeatherChance         = 65;
        m_WeatherDefaultSettings.m_BadWeatherSuddenChance   = 15;
    }

Перекрестные ссылки WorldData::m_WeatherDefaultSettings.

◆ WeatherOnBeforeChange()

override bool WeatherOnBeforeChange	(	EWeatherPhenomenon	type,
		float	actual,
		float	change,
		float	time )

inlineprivate

    {   
        #ifdef WEATHER_DATA_LOGGING 
        if ( !dayInit )
        {
            GetGame().GetWorld().GetDate(startYear, startMonth, startDay, startHour, startMinute);
            dayInit = true;
        }
        #endif
            
        float phmnTime  = 120;
        float phmnLength = 10;
        float phmnValue = 0;
                
        m_Weather.GetRain().SetLimits(0, 0);//since we decided that it will not rain in sakhal...
        
        m_Weather.GetOvercast().SetLimits(0.07, 1);
        m_Weather.GetSnowfall().SetLimits(0, 1);
        m_Weather.SetSnowfallThresholds( m_WeatherDefaultSettings.m_SnowfallThreshold, 1.0, 60 );
        m_Weather.GetSnowfall().SetForecastChangeLimits(0, 1);
        
        m_Weather.SetStorm( 1.0, m_WeatherDefaultSettings.m_ThundersnowThreshold, 45 );
        
        m_Weather.SetWindMaximumSpeed( 20 );
        m_Weather.GetWindMagnitude().SetForecastChangeLimits( 0, 20 );
        
        m_Weather.GetFog().SetLimits(0,0);
 
        switch (type)
        {
            //-----------------------------------------------------------------------------------------------------------------------------
            case EWeatherPhenomenon.OVERCAST:
            {
                float windDirection, windMag;
                
                #ifdef WEATHER_DATA_LOGGING 
                overcastChangeCount++;
                #endif
                //went something goes wrong choose some default random weather  
                phmnValue = Math.RandomFloatInclusive( 0.2, 0.7 );
                phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_OvercastMinTime, m_WeatherDefaultSettings.m_OvercastMaxTime );
                phmnLength = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_OvercastMinLength, m_WeatherDefaultSettings.m_OvercastMaxLength ); 
            
                //----              
                //--
                if ( m_LastWeather == WorldDataWeatherConstants.CLEAR_WEATHER )
                {
                    m_ClearWeatherChance -= ( m_StepValue * m_SameWeatherCnt);                  //decrease the chance of the same weather
                }
 
                if ( m_LastWeather == WorldDataWeatherConstants.CLOUDY_WEATHER )
                {
                    m_ClearWeatherChance += ( m_StepValue * m_SameWeatherCnt);                  //increase the chance of the better weather
                }
            
                if ( m_LastWeather == WorldDataWeatherConstants.BAD_WEATHER )
                {
                    m_ClearWeatherChance += m_StepValue;                                        //increase the chance of the better weather slightly
                    m_BadWeatherChance += (( m_StepValue * m_SameWeatherCnt ) + m_StepValue );  //decrease the chance of the same weather rapidly
                }
            
                //----
                //calculate next weather
                
                m_Chance = Math.RandomIntInclusive( 0, 100 );
                if ( m_Chance > m_WeatherDefaultSettings.m_GlobalSuddenChance && !m_IsSuddenChange) //checks if previous weather was a sudden change
                {   
                    #ifdef WEATHER_DATA_LOGGING 
                    directSuddenChangeCount++;
                    #endif
                    
                    m_IsSuddenChange = true;
                    m_ChoosenWeather = WorldDataWeatherConstants.BAD_WEATHER;
                    if ( m_LastWeather == WorldDataWeatherConstants.BAD_WEATHER )
                        m_SameWeatherCnt ++;
                }
                else if ( m_Chance < m_ClearWeatherChance )
                {               
                    m_ChoosenWeather = WorldDataWeatherConstants.CLEAR_WEATHER;
                    m_IsSuddenChange = false;
                        
                    if ( m_LastWeather == WorldDataWeatherConstants.CLEAR_WEATHER )
                        m_SameWeatherCnt ++;
                }
                else if ( m_Chance > m_BadWeatherChance )
                {
                    m_ChoosenWeather = WorldDataWeatherConstants.BAD_WEATHER;   
                    
                    if ( m_LastWeather == WorldDataWeatherConstants.BAD_WEATHER )
                        m_SameWeatherCnt ++;
                
                    if ( m_IsSuddenChange )
                    {
                        m_IsSuddenChange = false;
                        
                        #ifdef WEATHER_DATA_LOGGING
                        badWeatherCount++;
                        #endif
                    }
                    else
                    {
                        if ( Math.RandomIntInclusive( 0, 100 ) < m_WeatherDefaultSettings.m_BadWeatherSuddenChance )
                        {
                            m_IsSuddenChange = true;
                            
                            #ifdef WEATHER_DATA_LOGGING
                            badWeatherSuddenChangeCount++;
                            #endif
                        }
                        else
                        {
                            #ifdef WEATHER_DATA_LOGGING
                            badWeatherCount++;
                            #endif
                        }
                    }
                }
                else
                {                       
                    m_ChoosenWeather = WorldDataWeatherConstants.CLOUDY_WEATHER;
                    m_IsSuddenChange = false;
                    if ( m_LastWeather == WorldDataWeatherConstants.CLOUDY_WEATHER )
                        m_SameWeatherCnt ++;
                }
 
                if ( m_ChoosenWeather != m_LastWeather )
                    m_SameWeatherCnt = 0;
 
                m_ClearWeatherChance = m_WeatherDefaultSettings.m_ClearWeatherChance;
                m_BadWeatherChance = m_WeatherDefaultSettings.m_BadWeatherChance;
 
                //----
                //set choosen weather           
                if ( m_ChoosenWeather == WorldDataWeatherConstants.CLEAR_WEATHER  )
                {
                    m_LastWeather = WorldDataWeatherConstants.CLEAR_WEATHER;
                    #ifdef WEATHER_DATA_LOGGING
                    clearWeatherCount++;
                    #endif
                    phmnValue = Math.RandomFloatInclusive( 0.07, 0.3 );
                    phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_OvercastMinTime, m_WeatherDefaultSettings.m_OvercastMaxTime );
                    phmnLength = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_OvercastMinLength, m_WeatherDefaultSettings.m_OvercastMaxLength );
                }
 
                if ( m_ChoosenWeather == CLOUDY_WEATHER )
                {
                    #ifdef WEATHER_DATA_LOGGING
                    cloudyWeatherCount++;
                    #endif
                    m_LastWeather = CLOUDY_WEATHER;
 
                    phmnValue = Math.RandomFloatInclusive( 0.3, 0.6 );
                    phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_OvercastMinTime, m_WeatherDefaultSettings.m_OvercastMaxTime );
                    phmnLength = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_OvercastMinLength, m_WeatherDefaultSettings.m_OvercastMaxLength );
                }
            
                if ( m_ChoosenWeather == WorldDataWeatherConstants.BAD_WEATHER )
                {
                    m_LastWeather = WorldDataWeatherConstants.BAD_WEATHER;
 
                    phmnValue = Math.RandomFloatInclusive( 0.6, 1.0 );
                    phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_OvercastMinTime, m_WeatherDefaultSettings.m_OvercastMaxTime );
                    phmnLength = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_OvercastMinLength, m_WeatherDefaultSettings.m_OvercastMaxLength );
                    
                    if ( m_IsSuddenChange )
                    {
                        phmnTime *= SUDDENCHANGE_TIME_MULTIPLIER;
                        phmnLength *= SUDDENCHANGE_LENGTH_MULTIPLIER;
                    }
                    
                    #ifdef WEATHER_DATA_LOGGING
                    if ( phmnValue > m_WeatherDefaultSettings.m_ThundersnowThreshold )
                    {
                        if ( m_IsSuddenChange )
                        {
                            suddenThundersnowCount++;
                            if ( m_Chance < m_WeatherDefaultSettings.m_GlobalSuddenChance )
                            {
                                directSuddenChangeCount--;
                            }
                            else
                            {
                                badWeatherSuddenChangeCount--;
                            }                               
                        }
                        else
                        {
                            thundersnowCount++;
                            badWeatherCount--;
                        }
                    }
                    #endif
                                    
                }
 
                m_Weather.GetOvercast().Set( phmnValue, phmnTime, phmnLength );
                
                //we want to control wind with the overcast calculation and change with it.
                CalculateWind( m_ChoosenWeather, m_IsSuddenChange, windMag, windDirection );
                m_Weather.GetWindMagnitude().Set( windMag, phmnTime * WIND_MAGNITUDE_TIME_MULTIPLIER , phmnTime - (phmnTime * WIND_MAGNITUDE_TIME_MULTIPLIER) + phmnLength + 1000 );
                m_Weather.GetWindDirection().Set( windDirection, phmnTime * WIND_DIRECTION_TIME_MULTIPLIER , phmnTime - (phmnTime * WIND_DIRECTION_TIME_MULTIPLIER) + phmnLength + 1000 );
                
                if( m_IsSuddenChange )
                {
                    m_Weather.GetSnowfall().Set(Math.RandomFloatInclusive( 0.4, 0.8 ), phmnTime, 0); //forces to snow in the suddenchange.
                }
                
                Debug.WeatherLog(string.Format("Sakhal::Weather::Overcast:: (%1) overcast: %2", g_Game.GetDayTime(), actual));
                Debug.WeatherLog(string.Format("Sakhal::Weather::Overcast::Snow:: (%1) %2", g_Game.GetDayTime(), m_Weather.GetRain().GetActual()));
            
                #ifdef WEATHER_DATA_LOGGING
                int testYear = 0;
                int testMonth = 0;
                int testDay = 0;
                int testHour = 0;
                int testMinute = 0;
                GetGame().GetWorld().GetDate(testYear, testMonth, testDay, testHour, testMinute);
                    
                if ( testDay - startDay > currentDay && testHour - startHour >= 0 && testMinute - startMinute >= 0 )
                {
                    FileHandle file = OpenFile("$profile:OvercastCountsSakhal" + (currentDay + 1) + ".log", FileMode.WRITE);
                    FPrintln(file, "================================================================");
                    FPrintln(file," ================== Day " + (currentDay + 1) + " ================== ");
                    FPrintln(file, "================================================================");
                    FPrintln(file, "Overcast Change Count: " + overcastChangeCount);
                    FPrintln(file, "Bad Weather Change Count: " + badWeatherCount);
                    FPrintln(file, "Bad Weather Sudden Change Count: " + badWeatherSuddenChangeCount);
                    FPrintln(file, "Global Sudden Change Count: " + directSuddenChangeCount);                   
                    FPrintln(file, "Thunder Snow Count: " + thundersnowCount);
                    FPrintln(file, "Sudden Thundersnow Count: " + suddenThundersnowCount);                  
                    FPrintln(file, "Cloudy Weather Count: " + cloudyWeatherCount);
                    FPrintln(file, "Clear Weather Count: " + clearWeatherCount);
                
                    currentDay++;
                    CloseFile(file);
                    if ( currentDay == daysToRun )
                    {
                        g_Game.RequestExit(IDC_MAIN_QUIT);
                    }
                
                    overcastChangeCount = 0;
                    directSuddenChangeCount = 0;
                    badWeatherSuddenChangeCount = 0;
                    thundersnowCount = 0;
                    suddenThundersnowCount = 0;
                    badWeatherCount = 0;
                    cloudyWeatherCount = 0;
                    clearWeatherCount = 0;              
                }           
                #endif
            
            
                return true;
            }
            //-----------------------------------------------------------------------------------------------------------------------------
            case EWeatherPhenomenon.SNOWFALL:
            {
                float actualOvercast = m_Weather.GetOvercast().GetActual();
                
                m_Chance = Math.RandomIntInclusive( 0, 100 );
                phmnValue = 0.2;
                phmnTime = 90;
                phmnLength = 20;
            
                if ( actualOvercast <= m_WeatherDefaultSettings.m_SnowfallThreshold )
                {
                    m_Weather.GetSnowfall().Set( 0.0, m_WeatherDefaultSettings.m_SnowfallTimeMin, m_WeatherDefaultSettings.m_SnowfallTimeMin );
                    CalculateVolFog(0.0, m_Weather.GetWindMagnitude().GetForecast(), phmnTime);
                    
                    Debug.WeatherLog(string.Format("Sakhal::Weather::Snow::ForceEnd:: (%1) %2 -> 0", g_Game.GetDayTime(), actual));
                    return true;
                }
            
                if ( actualOvercast > m_WeatherDefaultSettings.m_ThundersnowThreshold )
                {
                    phmnValue = Math.RandomFloatInclusive( 0.8, 1.0 );
                    phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallTimeMin, m_WeatherDefaultSettings.m_SnowfallTimeMax ) * 0.5;
                    phmnLength = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallLengthMin, m_WeatherDefaultSettings.m_SnowfallLengthMax ) * 1.2;
 
                    m_Weather.GetSnowfall().Set( phmnValue, phmnTime, phmnLength );
                    
                    CalculateVolFog(phmnValue, m_Weather.GetWindMagnitude().GetForecast(), phmnTime);
                    Debug.WeatherLog(string.Format("Sakhal::Weather::Snow::ForceStorm:: (%1) %2 -> %3", g_Game.GetDayTime(), actual, phmnValue));
                    return true;
                }
 
                if ( actualOvercast == m_Weather.GetOvercast().GetForecast() && m_Weather.GetSnowfall().GetActual() >= 0.8 && m_Weather.GetWindSpeed() >= 10 ) //if overcast is not changing and there was high snowfall
                {
                    phmnValue = Math.RandomFloatInclusive( 0.2, 0.4 );
                    phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallTimeMin, m_WeatherDefaultSettings.m_SnowfallTimeMax ) * 0.5;
                    phmnLength = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallLengthMin, m_WeatherDefaultSettings.m_SnowfallLengthMax ) * 1.2;
                    
                    m_Weather.GetWindMagnitude().Set(m_Weather.GetWindMagnitude().GetActual() * 0.2, phmnTime , phmnLength); // next change will be happen in phenomenon change and reset the wind speed
                    m_Weather.GetSnowfall().Set( phmnValue, phmnTime, phmnLength );
                    
                    CalculateVolFog(phmnValue, m_Weather.GetWindMagnitude().GetForecast(), phmnTime);
                    Debug.WeatherLog(string.Format("Sakhal::Weather::Snow::ForceStorm:: (%1) %2 -> %3", g_Game.GetDayTime(), actual, phmnValue));
                    return true;
                }
 
                if ( actualOvercast < 0.6 ) //snowfall treshold to 0.6 overcast, snowfall in this bracket does not increase wetness
                {
                    if ( m_Chance < 40 )
                    {
                        phmnValue = Math.RandomFloatInclusive( 0.02, 0.4 );
                        phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallTimeMin, m_WeatherDefaultSettings.m_SnowfallTimeMax );
                        phmnLength = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallLengthMin, m_WeatherDefaultSettings.m_SnowfallLengthMax ) * 1.2;
                    }
                    else //also have the chance to not have snow at all
                    {
                        phmnValue = 0;
                        phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallTimeMin, m_WeatherDefaultSettings.m_SnowfallTimeMax );
                        phmnLength = Math.RandomIntInclusive(m_WeatherDefaultSettings.m_SnowfallLengthMin, m_WeatherDefaultSettings.m_SnowfallLengthMax) * 2;
                    }           
                }
                else if ( actualOvercast < 0.75 ) //0.6 to 0.75 overcast
                {
                    if ( m_Chance < 30 )
                    {
                        phmnValue = Math.RandomFloatInclusive( 0.5, 0.8 );
                        phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallTimeMin, m_WeatherDefaultSettings.m_SnowfallTimeMax );
                        phmnLength = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallLengthMin, m_WeatherDefaultSettings.m_SnowfallLengthMax );
                    }
                    else if ( m_Chance < 60 )
                    {
                        phmnValue = Math.RandomFloat( 0.3, 0.5 ); //0.5 snowfall starts to increase wetness
                        phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallTimeMin, m_WeatherDefaultSettings.m_SnowfallTimeMax );
                        phmnLength = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallLengthMin, m_WeatherDefaultSettings.m_SnowfallLengthMax );
                    }
                    else if ( m_Chance < 75 )
                    {
                        phmnValue = Math.RandomFloatInclusive( 0.02, 0.3 );
                        phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallTimeMin, m_WeatherDefaultSettings.m_SnowfallTimeMax );
                        phmnLength = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallLengthMin, m_WeatherDefaultSettings.m_SnowfallLengthMax );
                    }
                    else //also have the chance to not have snow at all
                    {
                        if ( m_IsSuddenChange )
                        {
                            phmnValue = Math.RandomFloat( 0.3, 0.5 ); //0.5 snowfall starts to increase wetness
                            phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallTimeMin, m_WeatherDefaultSettings.m_SnowfallTimeMax );
                            phmnLength = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallLengthMin, m_WeatherDefaultSettings.m_SnowfallLengthMax );                         
                        }
                        else
                        {
                            phmnValue = 0;
                            phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallTimeMin, m_WeatherDefaultSettings.m_SnowfallTimeMax );
                            phmnLength = Math.RandomIntInclusive(m_WeatherDefaultSettings.m_SnowfallLengthMin, m_WeatherDefaultSettings.m_SnowfallLengthMax) * 1.2;
                        }
                    }
                }
                else //0.75 to thunderstorm threshold overcast
                {
                    if ( m_Chance < 35 )
                    {
                        phmnValue = Math.RandomFloatInclusive( 0.7, 1.0 );
                        phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_SnowfallTimeMin, m_WeatherDefaultSettings.m_SnowfallTimeMax );
                        phmnLength = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallLengthMin, m_WeatherDefaultSettings.m_SnowfallLengthMax );
                    }
                    else if ( m_Chance < 75 )
                    {
                        phmnValue = Math.RandomFloatInclusive( 0.5, 0.7 );
                        phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_SnowfallTimeMin, m_WeatherDefaultSettings.m_SnowfallTimeMax );
                        phmnLength = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallLengthMin, m_WeatherDefaultSettings.m_SnowfallLengthMax ) ;
                    }
                    else if ( m_Chance < 85 )
                    {
                        phmnValue = Math.RandomFloat( 0.2, 0.5 ); //0.5 snowfall starts to increase wetness
                        phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_SnowfallTimeMin, m_WeatherDefaultSettings.m_SnowfallTimeMax );
                        phmnLength = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallLengthMin, m_WeatherDefaultSettings.m_SnowfallLengthMax );
                    }
                    else
                    {
                        if ( m_IsSuddenChange )
                        {
                            phmnValue = Math.RandomFloat( 0.5, 0.7 ); //0.5 snowfall starts to increase wetness
                            phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallTimeMin, m_WeatherDefaultSettings.m_SnowfallTimeMax );
                            phmnLength = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_SnowfallLengthMin, m_WeatherDefaultSettings.m_SnowfallLengthMax );                         
                        }
                        else
                        {
                            phmnValue = Math.RandomFloat( 0.02, 0.1 );
                            phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_SnowfallTimeMin, m_WeatherDefaultSettings.m_SnowfallTimeMax );
                            phmnLength = Math.RandomIntInclusive(m_WeatherDefaultSettings.m_SnowfallLengthMin, m_WeatherDefaultSettings.m_SnowfallLengthMax) * 1.2;
                        }
                    }
                }
        
                m_Weather.GetSnowfall().Set( phmnValue, phmnTime, phmnLength );
                CalculateVolFog(phmnValue, m_Weather.GetWindMagnitude().GetForecast(), phmnTime);
 
                Debug.WeatherLog(string.Format("Sakhal::Weather::Snow:: (%1) %2", g_Game.GetDayTime(), actual));
 
                return true;
            }
            //-----------------------------------------------------------------------------------------------------------------------------
            case EWeatherPhenomenon.FOG:
            {   
                m_Weather.GetFog().Set(0,0,100000);
                
                return true;
                
                /*float fogMin = 0.0;
                float fogMax = 0.15;
                float fogTime = 1800.0;
                
                if ( m_Weather.GetWindSpeed() >= 10 )
                {
                    m_Weather.GetFog().Set( 0, 300, 0);
                    Debug.WeatherLog(string.Format("Sakhal::Weather::Fog:: (%1) %2", g_Game.GetDayTime(), actual));
                
                    return true;
                }                       
                
                if ( m_Weather.GetOvercast().GetActual() < 0.3 )
                {
                    fogMin = 0.0;
                    fogMax = 0.1;
                    fogTime = 600.0;
                }
                else if ( m_Weather.GetOvercast().GetActual() > 0.6 )
                {
                    fogMin = 0.1;
                    fogMax = 0.3;
                    fogTime = 600.0;
                }
                else
                {
                    fogMin = 0.0;
                    fogMax = 0.15;
                    fogTime = 600.0;
                }
                
                m_Weather.GetFog().Set( Math.RandomFloatInclusive( fogMin, fogMax ), fogTime, 0);
                Debug.WeatherLog(string.Format("Sakhal::Weather::Fog:: (%1) %2", g_Game.GetDayTime(), actual));
 
                return true;*/
            }
            //-----------------------------------------------------------------------------------------------------------------------------
            case EWeatherPhenomenon.WIND_MAGNITUDE:
            {
                phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_SnowfallTimeMin, m_WeatherDefaultSettings.m_SnowfallTimeMax );
                m_Weather.GetWindMagnitude().Set(m_Weather.GetWindMagnitude().GetActual() / 0.2, phmnTime , m_WeatherDefaultSettings.m_OvercastMaxTime + 1000); // next change will be happen with the overcast or snowfall change
                CalculateVolFog(m_Weather.GetSnowfall().GetForecast(), m_Weather.GetWindMagnitude().GetForecast(), phmnTime);
                
            return true;
            }
        }
 
        return false;
    }

Перекрестные ссылки CalculateVolFog(), CalculateWind(), CloseFile(), CLOUDY_WEATHER, FPrintln(), g_Game, Weather::GetFog(), GetGame(), Weather::GetOvercast(), Weather::GetRain(), Weather::GetSnowfall(), Weather::GetWindDirection(), Weather::GetWindMagnitude(), Weather::GetWindSpeed(), IDC_MAIN_QUIT, WorldData::m_BadWeatherChance, WorldData::m_Chance, WorldData::m_ChoosenWeather, WorldData::m_ClearWeatherChance, WorldData::m_IsSuddenChange, WorldData::m_LastWeather, WorldData::m_SameWeatherCnt, WorldData::m_StepValue, WorldData::m_Weather, WorldData::m_WeatherDefaultSettings, OpenFile(), Math::RandomFloat(), Math::RandomFloatInclusive(), Math::RandomInt(), Math::RandomIntInclusive(), Weather::SetSnowfallThresholds(), Weather::SetStorm(), Weather::SetWindMaximumSpeed(), WorldData::SUDDENCHANGE_LENGTH_MULTIPLIER, WorldData::SUDDENCHANGE_TIME_MULTIPLIER, Debug::WeatherLog(), WorldData::WIND_DIRECTION_TIME_MULTIPLIER и WorldData::WIND_MAGNITUDE_TIME_MULTIPLIER.

Поля

◆ BAD_WEATHER

const int BAD_WEATHER = 3

protected

◆ CLEAR_WEATHER

const int CLEAR_WEATHER = 1

protected

DEPRECATED (see WorldDataWeatherConstants)

◆ CLOUDY_WEATHER

const int CLOUDY_WEATHER = 2

protected

Используется в WeatherOnBeforeChange().

◆ COLD_AREA_TOOL_DMG_MODIF

const float COLD_AREA_TOOL_DMG_MODIF = 1.2

private

Используется в GetColdAreaToolDamageModifier().

◆ SPAWN_CHANCE_CHOLERA

const float SPAWN_CHANCE_CHOLERA = 20

private

Используется в GetAgentSpawnChance().

Объявления и описания членов класса находятся в файле:

D:/Ishodniki/scripts/4_World/Classes/Worlds/Sakhal.c

Защищенные члены

Защищенные данные

Закрытые члены

Закрытые данные

Дополнительные унаследованные члены

Подробное описание

Методы

◆ CalculateVolFog()

◆ CalculateWind()

◆ GetAgentSpawnChance()

◆ GetColdAreaToolDamageModifier()

◆ Init()

◆ InitYieldBank()

◆ LogWeatherData()

◆ SetupLiquidTemperatures()

◆ SetupWeatherSettings()

◆ WeatherOnBeforeChange()

Поля

◆ BAD_WEATHER

◆ CLEAR_WEATHER

◆ CLOUDY_WEATHER

◆ COLD_AREA_TOOL_DMG_MODIF

◆ SPAWN_CHANCE_CHOLERA