Класс EnochData

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

Защищенные члены
override void	Init ()
override void	InitYieldBank ()
override void	SetupWeatherSettings ()
override void	SetupLiquidTemperatures ()
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 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.85
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

Статические защищенные данные
static const ref array< vector >	LIVONIA_ARTY_STRIKE_POS

Дополнительные унаследованные члены
Закрытые члены унаследованные от 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 ()
Закрытые данные унаследованные от 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 distanceDensity, heigthDensity, heightBias;
        int year, month, day, hour, minute;
        GetGame().GetWorld().GetDate(year, month, day, hour, minute);
                
        if ( hour < 6 && hour >= 3 )
        {
            heightBias = m_Weather.GetDynVolFogHeightBias();
            
            if ( heightBias == m_WeatherDefaultSettings.m_DefaultHeigthBias ) //verify if the foggy morning check has been done
            {
                bool foggyMorning = Math.RandomIntInclusive(0,1);
                
                if (foggyMorning)
                {
                    heightBias = Math.RandomInt(m_WeatherDefaultSettings.m_FoggyMorningHeigthBiasLowLimit, m_WeatherDefaultSettings.m_DefaultHeigthBias);                   
                }
                else
                {
                    heightBias = m_WeatherDefaultSettings.m_FoggyMorningHeigthBiasLowLimit - 1;
                }               
            }
            
            if (heightBias == m_WeatherDefaultSettings.m_FoggyMorningHeigthBiasLowLimit - 1) //not foggy morning
            {
                distanceDensity = Math.Lerp( 0.01, 0.03, lerpValue ) * Math.Clamp(1 - (windMagnitude / m_Weather.GetWindMaximumSpeed()), 0.1, 1);   
                heigthDensity = Math.Lerp( 0.9, 1, lerpValue);
            }
            else //foggy morning
            {
                distanceDensity = Math.Lerp( 0.5, 0.1, lerpValue ) * Math.Clamp(1 - (windMagnitude / m_Weather.GetWindMaximumSpeed()), 0.1, 1); 
                heigthDensity = Math.Lerp( 0.2, 1, lerpValue);
            }
        }
        else if ( hour < 18 && hour >= 6 )
        {
            distanceDensity = Math.Lerp( 0.01, 0.05, lerpValue ) * Math.Clamp(1 - (windMagnitude / m_Weather.GetWindMaximumSpeed()), 0.1, 1);   
            heigthDensity = Math.Lerp( 0.9, 1, lerpValue);
            heightBias = m_WeatherDefaultSettings.m_DefaultHeigthBias;
        }
        else
        {
            distanceDensity = Math.Lerp( 0.01, 0.03, lerpValue ) * Math.Clamp(1 - (windMagnitude / m_Weather.GetWindMaximumSpeed()), 0.1, 1);   
            heigthDensity = Math.Lerp( 0.9, 1, lerpValue);
            heightBias = m_WeatherDefaultSettings.m_DefaultHeigthBias;
        }
                
        m_Weather.SetDynVolFogDistanceDensity(distanceDensity, changeTime);
        m_Weather.SetDynVolFogHeightDensity(heigthDensity, changeTime);
        m_Weather.SetDynVolFogHeightBias(heightBias, changeTime);
    }

Перекрестные ссылки Math::Clamp(), Weather::GetDynVolFogHeightBias(), GetGame(), Weather::GetWindMaximumSpeed(), Math::Lerp(), WorldData::m_Weather, WorldData::m_WeatherDefaultSettings, Math::RandomInt(), Math::RandomIntInclusive(), Weather::SetDynVolFogDistanceDensity(), Weather::SetDynVolFogHeightBias() и Weather::SetDynVolFogHeightDensity().

Используется в 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 < 10 )                      
            {
                magnitude = Math.RandomFloatInclusive( 2 , 4 );
                direction = Math.RandomFloatInclusive( -2.3 , -1.8);
            }
            else if ( windChance < 50 ) 
            {
                magnitude = Math.RandomFloatInclusive( 4 , 8 );
                direction = Math.RandomFloatInclusive( -3.14 , -2.3);
            }
            else
            {
                magnitude = Math.RandomFloatInclusive( 6 , 12 );
                direction = Math.RandomFloatInclusive( 2.3 , 3.14);
            }
            
        }       
        else if ( newWeather == WorldDataWeatherConstants.CLOUDY_WEATHER )
        {           
            if ( windChance < 45 )                      
            {
                magnitude = Math.RandomFloatInclusive( 5 , 10 );
                direction = Math.RandomFloatInclusive( -1.8 , -1.0);
            }
            else if ( windChance < 90 ) 
            {
                magnitude = Math.RandomFloatInclusive( 8 , 12 );
                direction = Math.RandomFloatInclusive( -1.0, -0.7);
            }
            else
            {
                magnitude = Math.RandomFloatInclusive( 10 , 14 );
                direction = Math.RandomFloatInclusive( -2.4 , -1.8);
            }
        }       
        else
        {
            if ( suddenChange || m_Weather.GetOvercast().GetActual() > m_WeatherDefaultSettings.m_StormThreshold || m_Weather.GetOvercast().GetForecast() - m_Weather.GetOvercast().GetActual() >= 0.4 )
            {
                magnitude = Math.RandomFloatInclusive( 17 , 20 );
                direction = Math.RandomFloatInclusive( -0.2 , 1.0);
            }
            else if ( windChance < 45 )                     
            {
                magnitude = Math.RandomFloatInclusive( 6 , 12 );
                direction = Math.RandomFloatInclusive( -0.6, 0);
            }
            else if ( windChance < 90 ) 
            {
                magnitude = Math.RandomFloatInclusive( 7 , 10 );
                direction = Math.RandomFloatInclusive( 1.3 , 1.9);
            }
            else
            {
                magnitude = Math.RandomFloatInclusive( 4 , 8 );
                direction = Math.RandomFloatInclusive( -1.8, -1.3 );
            }           
        }
    }

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

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

Init()

override void Init ( )

inlineprotected

    {
        super.Init();
 
        // new temperature curve settings
        m_Sunrise_Jan = 8.4;
        m_Sunset_Jan = 15.63;
        m_Sunrise_Jul = 3.65;
        m_Sunset_Jul = 20.35;
 
        int tempIdx;
        m_MinTemps = {-7,-7.4,-4.1,1.5,7,11.3,20.4,19.1,18,5.3,0.8,-3.6}; //{-7,-7.4,-4.1,1.5,7,11.3,13.4,13.1,9.3,5.3,0.8,-3.6} original values, due to altitude of the map, changed the values drastically
        if (CfgGameplayHandler.GetEnvironmentMinTemps() && CfgGameplayHandler.GetEnvironmentMinTemps().Count() == 12)
        {
            for (tempIdx = 0; tempIdx < CfgGameplayHandler.GetEnvironmentMinTemps().Count(); tempIdx++)
            {
                m_MinTemps[tempIdx] = CfgGameplayHandler.GetEnvironmentMinTemps().Get(tempIdx);
            }
        }
 
        m_MaxTemps = {-2.5,-2.1,2.3,9,15.5,19.4,25,22,21,10.5,4.2,0.1}; //{-2.5,-2.1,2.3,9,15.5,19.4,20.9,20.4,16,10.5,4.2,0.1} 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_FiringPos = LIVONIA_ARTY_STRIKE_POS;
        
        m_CloudsTemperatureEffectModifier = -5.0;
        m_WorldWindCoef = 0.3;
        m_TemperaturePerHeightReductionModifier = 0.01;
        
        m_UniversalTemperatureSourceCapModifier = 1.0;          
        
        if (GetGame().IsServer() || !GetGame().IsMultiplayer())
        {
            m_Weather.SetDynVolFogHeightBias(m_WeatherDefaultSettings.m_DefaultHeigthBias);
        
            if (GetGame().IsMultiplayer())
        
            {
                float startingOvercast = Math.RandomFloat(0.2,0.75);
                m_Weather.GetOvercast().Set(startingOvercast,0,5); //forcing a random weather at a clean server start and an instant change for overcast
                CalculateVolFog(startingOvercast, m_Weather.GetWindSpeed(), 0);         
            }
        }
        
 
    }

Перекрестные ссылки CalculateVolFog(), Count, CfgGameplayHandler::GetEnvironmentMaxTemps(), CfgGameplayHandler::GetEnvironmentMinTemps(), GetGame(), Weather::GetOvercast(), Weather::GetWindSpeed(), LIVONIA_ARTY_STRIKE_POS, WorldData::m_CloudsTemperatureEffectModifier, WorldData::m_FiringPos, WorldData::m_MaxTemps, WorldData::m_MinTemps, WorldData::m_Sunrise_Jan, WorldData::m_Sunrise_Jul, WorldData::m_Sunset_Jan, WorldData::m_Sunset_Jul, WorldData::m_TemperaturePerHeightReductionModifier, WorldData::m_UniversalTemperatureSourceCapModifier, WorldData::m_Weather, WorldData::m_WeatherDefaultSettings, WorldData::m_WorldWindCoef, Math::RandomFloat() и Weather::SetDynVolFogHeightBias().

InitYieldBank()

override void InitYieldBank ( )

inlineprotected

    {
        super.InitYieldBank();
        
        m_YieldBank.ClearAllRegisteredItems();
        
        //fishies
        m_YieldBank.RegisterYieldItem(new YieldItemCarp(15));
        m_YieldBank.RegisterYieldItem(new YieldItemMackerel(15));
        m_YieldBank.RegisterYieldItem(new YieldItemSardines(15));
        m_YieldBank.RegisterYieldItem(new YieldItemBitterlings(15));
        
        //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(4));
        m_YieldBank.RegisterYieldItem(new YieldItemDeadRooster(1));
        m_YieldBank.RegisterYieldItem(new YieldItemDeadChicken_White(1));
        m_YieldBank.RegisterYieldItem(new YieldItemDeadChicken_Spotted(1));
        m_YieldBank.RegisterYieldItem(new YieldItemDeadChicken_Brown(1));
        m_YieldBank.RegisterYieldItem(new YieldItemDeadFox(2));
    }

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

LogWeatherData()

bool LogWeatherData ( )

inlineprotected

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

SetupLiquidTemperatures()

override void SetupLiquidTemperatures ( )

inlineprotected

    {
        m_LiquidSettings = new WorldDataLiquidSettings();
        
        m_LiquidSettings.m_Temperatures[LIQUID_SALTWATER]   = 25;
        m_LiquidSettings.m_Temperatures[LIQUID_WATER]       = 25.0;
        m_LiquidSettings.m_Temperatures[LIQUID_STILLWATER]  = 25.0;
        m_LiquidSettings.m_Temperatures[LIQUID_RIVERWATER]  = 20.0;
        m_LiquidSettings.m_Temperatures[LIQUID_FRESHWATER]  = 20.0;
        m_LiquidSettings.m_Temperatures[LIQUID_CLEANWATER]  = 15.0;
    }

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

SetupWeatherSettings()

override void SetupWeatherSettings ( )

inlineprotected

    {
        super.SetupWeatherSettings();
        
        m_WeatherDefaultSettings.m_ClearWeatherChance       = 50;
        m_WeatherDefaultSettings.m_BadWeatherChance         = 75;
        m_WeatherDefaultSettings.m_BadWeatherSuddenChance   = 0;
    }

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

WeatherOnBeforeChange()

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

inlineprotected

    {
        #ifdef WEATHER_DATA_LOGGING 
        if ( !dayInit )
        {
            GetGame().GetWorld().GetDate(startYear, startMonth, startDay, startHour, startMinute);
            dayInit = true;
        }
        #endif
        
        float phmnTime = 5;
        float phmnLength = 10;
        float phmnValue = 0;
        
        int year, month, day, hour, minute;
        GetGame().GetWorld().GetDate(year, month, day, hour, minute);
 
        m_Weather.SetStorm( 1.0, m_WeatherDefaultSettings.m_StormThreshold, 20 );
 
        m_Weather.SetRainThresholds( m_WeatherDefaultSettings.m_RainThreshold, 1.0, 60 );
        m_Weather.SetWindMaximumSpeed( 20 );
        
        switch (type)
        {
            //-----------------------------------------------------------------------------------------------------------------------------
            case EWeatherPhenomenon.OVERCAST:
            {
                #ifdef WEATHER_DATA_LOGGING 
                overcastChangeCount++;
                #endif
                
                float windDirection, windMag;
            
                //went something goes wrong choose some default random weather  
                phmnValue = Math.RandomFloatInclusive( 0.1, 0.4 );
                phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_OvercastMinTime, m_WeatherDefaultSettings.m_OvercastMaxTime );
                phmnLength = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_OvercastMinLength, m_WeatherDefaultSettings.m_OvercastMaxLength ); 
            
                //----
                //calculate next weather
                m_Chance = Math.RandomIntInclusive( 0, 100 );
                
                //--
                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
                    m_BadWeatherChance -= ( m_StepValue * m_SameWeatherCnt);
                }
            
                if ( m_LastWeather == WorldDataWeatherConstants.BAD_WEATHER )
                {
                    m_ClearWeatherChance += m_StepValue;                                        //increase the chance of the better weather slightly
                    m_BadWeatherChance += ( m_StepValue * m_SameWeatherCnt );                   //decrease the chance of the same weather
                }
            
                //----
                if ( m_Chance > m_WeatherDefaultSettings.m_GlobalSuddenChance && !m_IsSuddenChange) //checks if previous weather was a sudden change
                {                       
                    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;
                    m_IsSuddenChange = false;
                    if ( m_LastWeather == WorldDataWeatherConstants.BAD_WEATHER )
                        m_SameWeatherCnt ++;
                }
                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.0, 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 == WorldDataWeatherConstants.CLOUDY_WEATHER )
                {
                    m_LastWeather = WorldDataWeatherConstants.CLOUDY_WEATHER;
                    #ifdef WEATHER_DATA_LOGGING
                    cloudyWeatherCount++;
                    #endif
 
                    phmnValue = Math.RandomFloatInclusive( 0.3, 0.7 );
                    phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_OvercastMinTime, m_WeatherDefaultSettings.m_OvercastMaxTime );
                    phmnLength = Math.RandomIntInclusive( 0, m_WeatherDefaultSettings.m_OvercastMinLength );
                }
            
                if ( m_ChoosenWeather == WorldDataWeatherConstants.BAD_WEATHER )
                {
                    m_LastWeather = WorldDataWeatherConstants.BAD_WEATHER;
 
                    phmnValue = Math.RandomFloatInclusive( 0.7, 1.0 );
                    phmnTime = Math.RandomIntInclusive( m_WeatherDefaultSettings.m_OvercastMinTime, m_WeatherDefaultSettings.m_OvercastMaxTime );
                    phmnLength = Math.RandomIntInclusive( 0, m_WeatherDefaultSettings.m_OvercastMinLength );
                    
                    #ifdef WEATHER_DATA_LOGGING
                    badWeatherCount++;
                    #endif
                    
                    if ( m_IsSuddenChange )
                    {
                        #ifdef WEATHER_DATA_LOGGING
                        suddenChangeCount++;
                        badWeatherCount--;
                        #endif
                        
                        phmnTime *= SUDDENCHANGE_TIME_MULTIPLIER;
                        phmnLength *= SUDDENCHANGE_LENGTH_MULTIPLIER;
                    }
                    
                    #ifdef WEATHER_DATA_LOGGING
                    if ( phmnValue > m_WeatherDefaultSettings.m_StormThreshold )
                    {                       
                        if ( m_IsSuddenChange )
                        {
                            suddenChangeCount--;
                            suddenStormCount++;                                                                                 
                        }
                        else
                        {   stormCount++;
                            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 * (1 - WIND_MAGNITUDE_TIME_MULTIPLIER) ); // magnitude change happens during the overcast change, after overcast change finishes wind will decrease a bit
                m_Weather.GetWindDirection().Set( windDirection, phmnTime * WIND_DIRECTION_TIME_MULTIPLIER , phmnTime - (phmnTime * WIND_DIRECTION_TIME_MULTIPLIER) + phmnLength + 1000 );
            
                CalculateVolFog(phmnValue, windMag, phmnTime);
            
                if( m_IsSuddenChange )
                {
                    m_Weather.GetRain().Set(Math.RandomFloatInclusive( 0.4, 0.8 ), phmnTime, 0); //forces to rain in the suddenchange.
                }
 
                Debug.WeatherLog(string.Format("Enoch::Weather::Overcast:: (%1) overcast: %2", g_Game.GetDayTime(), actual));
                Debug.WeatherLog(string.Format("Enoch::Weather::Overcast::Rain:: (%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:OvercastCountsLivonia" + (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, "Sudden Change Count: " + suddenChangeCount);                    
                    FPrintln(file, "Storm Count: " + stormCount);
                    FPrintln(file, "Sudden Storm Count: " + suddenStormCount);                  
                    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;
                    suddenChangeCount = 0;
                    stormCount = 0;
                    suddenStormCount = 0;
                    badWeatherCount = 0;
                    cloudyWeatherCount = 0;
                    clearWeatherCount = 0;              
                }           
                #endif
                
                return true;
            }
            //-----------------------------------------------------------------------------------------------------------------------------
            case EWeatherPhenomenon.RAIN:
            {
                float actualOvercast = m_Weather.GetOvercast().GetActual();
 
                m_Chance = Math.RandomIntInclusive( 0, 100 );   
                phmnValue = 0.2;
                phmnTime = 90;
                phmnLength = 30;
            
                if ( actualOvercast <= m_WeatherDefaultSettings.m_RainThreshold)
                {
                    m_Weather.GetRain().Set( 0.0, m_WeatherDefaultSettings.m_RainTimeMin, m_WeatherDefaultSettings.m_RainTimeMax );
                    Debug.WeatherLog (string.Format("Enoch::Weather::Rain::ForceEnd:: (%1) %2 -> 0", g_Game.GetDayTime(), actual));
                    return true;
                }
 
                if ( actualOvercast > m_WeatherDefaultSettings.m_StormThreshold )
                {
                    if( m_Weather.GetOvercast().GetActual() > m_Weather.GetOvercast().GetForecast() ) //ensure to have a pause to rain after the storm
                    {
                        phmnValue = 0;
                        phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_RainTimeMin, m_WeatherDefaultSettings.m_RainTimeMax ) * 2;
                        phmnLength =  Math.RandomInt( m_WeatherDefaultSettings.m_CalmAfterStormTimeMin, m_WeatherDefaultSettings.m_CalmAfterStormTimeMax );
                    }
                    else
                    {
                        phmnValue = Math.RandomFloatInclusive( 0.8, 1.0 );
                        phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_RainTimeMin, m_WeatherDefaultSettings.m_RainTimeMax );
                        phmnLength = 0;
                    }
                    
                    m_Weather.GetRain().Set( phmnValue, phmnTime, phmnLength ); 
                    Debug.WeatherLog(string.Format("Enoch::Weather::Rain::ForceStorm:: (%1) %2 -> %3", g_Game.GetDayTime(), actual, phmnValue));
                    return true;
                }
 
                //make a differnce in "normal rain"
                if ( actualOvercast < 0.75 )
                {
                    if ( m_Chance < 30 )
                    {
                        phmnValue = Math.RandomFloatInclusive( 0.1, 0.3 );
                        phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_RainTimeMin, m_WeatherDefaultSettings.m_RainTimeMax );
                        phmnLength = Math.RandomInt( m_WeatherDefaultSettings.m_RainLengthMin, m_WeatherDefaultSettings.m_RainLengthMax );
                    }
                    else if ( m_Chance < 60 )
                    {
                        phmnValue = Math.RandomFloatInclusive( 0.2, 0.4 );
                        phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_RainTimeMin, m_WeatherDefaultSettings.m_RainTimeMax );
                        phmnLength = Math.RandomInt( m_WeatherDefaultSettings.m_RainLengthMin, m_WeatherDefaultSettings.m_RainLengthMax );
                    }
                    else if ( m_Chance < 85 )
                    {
                        phmnValue = Math.RandomFloatInclusive( 0.05, 0.2 );
                        phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_RainTimeMin, m_WeatherDefaultSettings.m_RainTimeMax );
                        phmnLength = Math.RandomInt( m_WeatherDefaultSettings.m_RainLengthMin, m_WeatherDefaultSettings.m_RainLengthMax );
                    }
                    else //also have the chance to not have rain at all
                    {
                        phmnValue = 0;
                        phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_RainTimeMin, m_WeatherDefaultSettings.m_RainTimeMax );
                        phmnLength = Math.RandomInt( m_WeatherDefaultSettings.m_RainLengthMin, m_WeatherDefaultSettings.m_RainLengthMax ) * 4;
                    }
                }
                else //overcast between storm threshold and 0.75
                {
                    if ( m_Chance < 15 )
                    {
                        phmnValue = Math.RandomFloatInclusive( 0.4, 0.6 );
                        phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_RainTimeMin, m_WeatherDefaultSettings.m_RainTimeMax );
                        phmnLength = 0;
                    }
                    else if ( m_Chance < 50 )
                    {
                        phmnValue = Math.RandomFloatInclusive( 0.2, 0.4 );
                        phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_RainTimeMin, m_WeatherDefaultSettings.m_RainTimeMax );
                        phmnLength = 0;
                    }
                    else if ( m_Chance < 90 )
                    {
                        phmnValue = Math.RandomFloatInclusive( 0.6, 0.8 );
                        phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_RainTimeMin, m_WeatherDefaultSettings.m_RainTimeMax );
                        phmnLength = 0;
                    }
                    else //also have the chance to not have rain at all
                    {
                        phmnValue = 0;
                        phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_RainTimeMin, m_WeatherDefaultSettings.m_RainTimeMax );
                        phmnLength = Math.RandomInt( m_WeatherDefaultSettings.m_RainLengthMin, m_WeatherDefaultSettings.m_RainLengthMax ) * 4;
                    }
                }
 
                m_Weather.GetRain().Set( phmnValue, phmnTime, phmnLength );
 
                Debug.WeatherLog(string.Format("Enoch::Weather::Rain:: (%1) %2", g_Game.GetDayTime(), actual));
                return true;
            }
            //-----------------------------------------------------------------------------------------------------------------------------
            case EWeatherPhenomenon.FOG:
            {
                if (( hour >= 2 ) && ( hour <= 5 ))
                {
                    m_Weather.GetFog().Set( 0.13, 900, 0 );
                } 
                else 
                {
                    m_Weather.GetFog().Set( 0.01, 900, 0 );
                }
            
                Debug.WeatherLog(string.Format("Enoch::Weather::Fog:: (%1) %2", g_Game.GetDayTime(), actual));
 
                return true;
            }
            //-----------------------------------------------------------------------------------------------------------------------------
            case EWeatherPhenomenon.WIND_MAGNITUDE:
            {
                phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_RainTimeMin, m_WeatherDefaultSettings.m_RainTimeMax );
                m_Weather.GetWindMagnitude().Set(m_Weather.GetWindMagnitude().GetActual() * 0.75, phmnTime , m_WeatherDefaultSettings.m_OvercastMaxLength); // next change will be happen with the overcast change
            
            return true;
            }
        }
        return false;
    }

Перекрестные ссылки CalculateVolFog(), CalculateWind(), CloseFile(), FPrintln(), g_Game, Weather::GetFog(), GetGame(), Weather::GetOvercast(), Weather::GetRain(), Weather::GetWindDirection(), Weather::GetWindMagnitude(), 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::RandomFloatInclusive(), Math::RandomInt(), Math::RandomIntInclusive(), Weather::SetRainThresholds(), 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

LIVONIA_ARTY_STRIKE_POS

const ref array<vector> LIVONIA_ARTY_STRIKE_POS

staticprotected

Инициализатор

= 
    { 
        "7440.00 417.00 -500.00",
        "-500.00 276.00 5473.00",
        "-500.00 265.00 9852.00",
        "4953.00 240.00 13300.00",
        "9620.00 188.00 13300.00",
        "13300.00 204.00 10322.00",
        "13300.00 288.00 6204.00",
        "13300.00 296.00 -500.00"
    }

    { 
        "7440.00 417.00 -500.00",
        "-500.00 276.00 5473.00",
        "-500.00 265.00 9852.00",
        "4953.00 240.00 13300.00",
        "9620.00 188.00 13300.00",
        "13300.00 204.00 10322.00",
        "13300.00 288.00 6204.00",
        "13300.00 296.00 -500.00"
    };

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

m_badWeatherChance

int m_badWeatherChance = m_BadWeatherChance

protected

m_chance

int m_chance = m_Chance

protected

m_choosenWeather

int m_choosenWeather = m_ChoosenWeather

protected

m_clearWeatherChance

int m_clearWeatherChance = m_ClearWeatherChance

protected

m_lastWeather

int m_lastWeather = m_LastWeather

protected

m_sameWeatherCnt

int m_sameWeatherCnt = m_SameWeatherCnt

protected

m_stepValue

int m_stepValue = m_StepValue

protected

OVERCAST_MAX_TIME

const int OVERCAST_MAX_TIME = 900

protected

OVERCAST_MIN_TIME

const int OVERCAST_MIN_TIME = 600

protected

DEPRECATED (see WorldDataWeatherSettings)

RAIN_THRESHOLD

const float RAIN_THRESHOLD = 0.6

protected

RAIN_TIME_MAX

const int RAIN_TIME_MAX = 120

protected

RAIN_TIME_MIN

const int RAIN_TIME_MIN = 60

protected

STORM_THRESHOLD

const float STORM_THRESHOLD = 0.85

protected

---

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

• D:/Ishodniki/scripts/4_World/Classes/Worlds/Enoch.c