WeatherOnBeforeChange() [2/2]

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

inlineprotected

См. определение в файле ChernarusPlus.c строка 91

    {       
        #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;
 
        m_Weather.SetStorm( 1.0, m_WeatherDefaultSettings.m_StormThreshold, 45 );
 
        m_Weather.SetRainThresholds( m_WeatherDefaultSettings.m_RainThreshold, 1.0, 60 );
        m_Weather.SetWindMaximumSpeed( 20 );
        
        if (m_Weather.GetDynVolFogHeightBias() < m_WeatherDefaultSettings.m_DefaultHeigthBias)
        {
            m_Weather.SetDynVolFogHeightBias(m_WeatherDefaultSettings.m_DefaultHeigthBias);
        }
 
        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.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 );             
            
                //----
                //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
                }
            
                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
                }
            
                //----
                if ( m_Chance < m_ClearWeatherChance )
                {
                    m_ChoosenWeather = WorldDataWeatherConstants.CLEAR_WEATHER;
                    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 ++;
                }
                else
                {
                    m_ChoosenWeather = WorldDataWeatherConstants.CLOUDY_WEATHER;
                    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.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;
                    #ifdef WEATHER_DATA_LOGGING
                    badWeatherCount++;
                    #endif
 
                    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 );
                }
 
                m_Weather.GetOvercast().Set( phmnValue, phmnTime, phmnLength );
                
                CalculateWind( m_ChoosenWeather, false, 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);
 
                Debug.WeatherLog(string.Format("Chernarus::Weather::Overcast:: (%1) overcast: %2", g_Game.GetDayTime(), actual));
                Debug.WeatherLog(string.Format("Chernarus::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:OvercastCountsCharnarus" + (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, "Cloudy Weather Count: " + cloudyWeatherCount);
                    FPrintln(file, "Clear Weather Count: " + clearWeatherCount);
                
                    currentDay++;                   
                    CloseFile(file);
                    if ( currentDay == daysToRun )
                    {
                        g_Game.RequestExit(IDC_MAIN_QUIT);
                    }
                
                    overcastChangeCount = 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("Chernarus::Weather::Rain::ForceEnd:: (%1) %2 -> 0", g_Game.GetDayTime(), actual));
                    return true;
                }
            
                if ( actualOvercast > m_WeatherDefaultSettings.m_StormThreshold )
                {
                    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("Chernarus::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 = 0;
                    }
                    else if ( m_Chance < 60 )
                    {
                        phmnValue = Math.RandomFloatInclusive( 0.2, 0.5 );
                        phmnTime = Math.RandomInt( m_WeatherDefaultSettings.m_RainTimeMin, m_WeatherDefaultSettings.m_RainTimeMax );
                        phmnLength = 0;
                    }
                    else if ( m_Chance < 80 )
                    {
                        phmnValue = Math.RandomFloatInclusive( 0.0, 0.2 );
                        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 = m_WeatherDefaultSettings.m_RainLengthMax;
                    }
                }
                else
                {
                    if ( m_Chance < 25 )
                    {
                        phmnValue = Math.RandomFloatInclusive( 0.5, 0.7 );
                        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 < 75 )
                    {
                        phmnValue = Math.RandomFloatInclusive( 0.4, 0.6 );
                        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 = m_WeatherDefaultSettings.m_RainLengthMax;
                    }
                }
        
                m_Weather.GetRain().Set( phmnValue, phmnTime, phmnLength );
 
                Debug.WeatherLog(string.Format("Chernarus::Weather::Rain:: (%1) %2", g_Game.GetDayTime(), actual));
 
                return true;
            }
            //-----------------------------------------------------------------------------------------------------------------------------
            case EWeatherPhenomenon.FOG:
            {
                float fogMin = 0.0;
                float fogMax = 0.15;
                float fogTime = 1800.0;
 
                float fogyMorning = Math.RandomFloatInclusive( 0.0, 1.0 );
 
                if ( fogyMorning > 0.85 )
                {
                    if ( (g_Game.GetDayTime() > 4 && g_Game.GetDayTime() < 7 ) )
                    {
                        fogMin = 0.10;
                        fogMax = 0.35;
                        fogTime = 300;
                    }
                }
 
                if ( m_Weather.GetOvercast().GetActual() < 0.3 )
                {
                    fogMin = 0.0;
                    fogMax = 0.08;
                    fogTime = 900.0;
                }
 
                m_Weather.GetFog().Set( Math.RandomFloatInclusive( fogMin, fogMax ), fogTime, 0);
                
                Debug.WeatherLog(string.Format("Chernarus::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, World::GetDate(), GetGame(), CGame::GetWorld(), IDC_MAIN_QUIT, m_BadWeatherChance, m_Chance, m_ChoosenWeather, m_ClearWeatherChance, m_LastWeather, m_SameWeatherCnt, m_StepValue, m_Weather, m_WeatherDefaultSettings, OpenFile(), Math::RandomFloatInclusive(), Math::RandomInt(), Math::RandomIntInclusive(), Debug::WeatherLog(), WIND_DIRECTION_TIME_MULTIPLIER и WIND_MAGNITUDE_TIME_MULTIPLIER.