Enoch.c

Go to the documentation of this file.

class EnochData extends WorldData
{
  const float RAIN_THRESHOLD = 0.6;
  const float STORM_THRESHOLD = 0.85;
 
  const int OVERCAST_MIN_TIME = 600;
  const int OVERCAST_MAX_TIME = 900;
 
  const int RAIN_TIME_MIN = 60;
  const int RAIN_TIME_MAX = 120;
 
  const int CLEAR_WEATHER = 1;
  const int CLOUDY_WEATHER = 2;
  const int BAD_WEATHER = 3;
 
  const int CLEAR_WEATHER_CHANCE = 50;
  const int BAD_WEATHER_CHANCE = 75;
 
  protected int m_clearWeatherChance = CLEAR_WEATHER_CHANCE;
  //protected int m_badCloudyChance = 80;
  protected int m_badWeatherChance = BAD_WEATHER_CHANCE;
 
  protected int m_stepValue = 5;
 
  protected int m_sameWeatherCnt = 0;
  protected int m_chance = 50;
 
  protected int m_choosenWeather = 1;
  protected int m_lastWeather = 0;
 
  protected static const ref array<vector> LIVONIA_ARTY_STRIKE_POS = {
    "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"
  };
 
  override void Init()
  {
    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, 13.4, 13.1, 9.3, 5.3, 0.8, -3.6};
    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, 20.9, 20.4, 16, 10.5, 4.2, 0.1};
    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;
  }
 
  override bool WeatherOnBeforeChange(EWeatherPhenomenon type, float actual, float change, float time)
  {
    int phmnTime = 5;
    int phmnLength = 10;
    float phmnValue = 0;
 
    m_Weather.SetStorm(1.0, STORM_THRESHOLD, 20);
 
    m_Weather.SetRainThresholds(0.0, 1.0, 60);
    m_Weather.SetWindMaximumSpeed(20);
    m_Weather.SetWindFunctionParams(0.1, 1.0, 20);
 
    switch (type)
    {
    //-----------------------------------------------------------------------------------------------------------------------------
    case EWeatherPhenomenon.OVERCAST:
 
      //went something goes wrong choose some default random weather
      phmnValue = Math.RandomFloatInclusive(0.1, 0.4);
      phmnTime = Math.RandomIntInclusive(OVERCAST_MIN_TIME, OVERCAST_MAX_TIME);
      phmnLength = Math.RandomIntInclusive(OVERCAST_MIN_TIME, OVERCAST_MAX_TIME);
 
      //----
      //calculate next weather
      m_chance = Math.RandomIntInclusive(0, 100);
 
      //--
      if (m_lastWeather == CLEAR_WEATHER)
      {
        m_clearWeatherChance -= (m_stepValue * m_sameWeatherCnt); //decrease the chance of the same weather
      }
 
      if (m_lastWeather == CLOUDY_WEATHER)
      {
        m_clearWeatherChance += (m_stepValue * m_sameWeatherCnt); //increase the chance of the better weather
        m_badWeatherChance -= (m_stepValue * m_sameWeatherCnt);
      }
 
      if (m_lastWeather == 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_clearWeatherChance)
      {
        m_choosenWeather = CLEAR_WEATHER;
        if (m_lastWeather == CLEAR_WEATHER)
          m_sameWeatherCnt ++;
      }
      else if (m_chance > m_badWeatherChance)
      {
        m_choosenWeather = BAD_WEATHER;
        if (m_lastWeather == BAD_WEATHER)
          m_sameWeatherCnt ++;
      }
      else
      {
        m_choosenWeather = CLOUDY_WEATHER;
        if (m_lastWeather == CLOUDY_WEATHER)
          m_sameWeatherCnt ++;
      }
 
      if (m_choosenWeather != m_lastWeather)
        m_sameWeatherCnt = 0;
 
      m_clearWeatherChance = CLEAR_WEATHER_CHANCE;
      m_badWeatherChance = BAD_WEATHER_CHANCE;
 
      //----
      //set choosen weather
      if (m_choosenWeather == CLEAR_WEATHER)
      {
        m_lastWeather = CLEAR_WEATHER;
 
        phmnValue = Math.RandomFloatInclusive(0.0, 0.3);
        phmnTime = Math.RandomIntInclusive(OVERCAST_MIN_TIME, OVERCAST_MAX_TIME);
        phmnLength = Math.RandomIntInclusive(OVERCAST_MIN_TIME, OVERCAST_MAX_TIME);
      }
 
      if (m_choosenWeather == CLOUDY_WEATHER)
      {
        m_lastWeather = CLOUDY_WEATHER;
 
        phmnValue = Math.RandomFloatInclusive(0.3, 0.7);
        phmnTime = Math.RandomIntInclusive(OVERCAST_MIN_TIME, OVERCAST_MAX_TIME);
        phmnLength = Math.RandomIntInclusive(0, OVERCAST_MIN_TIME);
      }
 
      if (m_choosenWeather == BAD_WEATHER)
      {
        m_lastWeather = BAD_WEATHER;
 
        phmnValue = Math.RandomFloatInclusive(0.7, 1.0);
        phmnTime = Math.RandomIntInclusive(OVERCAST_MIN_TIME, OVERCAST_MAX_TIME);
        phmnLength = Math.RandomIntInclusive(0, OVERCAST_MIN_TIME);
      }
 
      m_Weather.GetOvercast().Set(phmnValue, phmnTime, phmnLength);
 
      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()));
 
      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 <= RAIN_THRESHOLD)
      {
        m_Weather.GetRain().Set(0.0, RAIN_TIME_MIN, RAIN_TIME_MAX);
        Debug.WeatherLog(string.Format("Enoch::Weather::Rain::ForceEnd:: (%1) %2 -> 0", g_Game.GetDayTime(), actual));
        return true;
      }
 
      if (actualOvercast > STORM_THRESHOLD)
      {
        phmnValue = Math.RandomFloatInclusive(0.8, 1.0);
        phmnTime = Math.RandomInt(RAIN_TIME_MIN, RAIN_TIME_MAX);
        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(RAIN_TIME_MIN, RAIN_TIME_MAX);
          phmnLength = 0;
        }
        else if (m_chance < 60)
        {
          phmnValue = Math.RandomFloatInclusive(0.2, 0.4);
          phmnTime = Math.RandomInt(RAIN_TIME_MIN, RAIN_TIME_MAX);
          phmnLength = 0;
        }
        else if (m_chance < 85)
        {
          phmnValue = Math.RandomFloatInclusive(0.0, 0.2);
          phmnTime = Math.RandomInt(RAIN_TIME_MIN, RAIN_TIME_MAX);
          phmnLength = 0;
        }
        else //also have the chance to not have rain at all
        {
          phmnValue = 0;
          phmnTime = Math.RandomInt(RAIN_TIME_MIN, RAIN_TIME_MAX);
          phmnLength = 120;
        }
      }
      else if (actualOvercast < STORM_THRESHOLD)
      {
        if (m_chance < 15)
        {
          phmnValue = Math.RandomFloatInclusive(0.4, 0.6);
          phmnTime = Math.RandomInt(RAIN_TIME_MIN, RAIN_TIME_MAX);
          phmnLength = 0;
        }
        else if (m_chance < 50)
        {
          phmnValue = Math.RandomFloatInclusive(0.2, 0.4);
          phmnTime = Math.RandomInt(RAIN_TIME_MIN, RAIN_TIME_MAX);
          phmnLength = 0;
        }
        else if (m_chance < 90)
        {
          phmnValue = Math.RandomFloatInclusive(0.6, 0.8);
          phmnTime = Math.RandomInt(RAIN_TIME_MIN, RAIN_TIME_MAX);
          phmnLength = 0;
        }
        else //also have the chance to not have rain at all
        {
          phmnValue = 0;
          phmnTime = Math.RandomInt(RAIN_TIME_MIN, RAIN_TIME_MAX);
          phmnLength = 120;
        }
      }
      else
      {
        if (m_chance < 50)
        {
          phmnValue = Math.RandomFloatInclusive(0.9, 1.0);
          phmnTime = Math.RandomInt(RAIN_TIME_MIN, RAIN_TIME_MAX);
          phmnLength = 0;
        }
        else
        {
          phmnValue = Math.RandomFloatInclusive(0.8, 0.9);
          phmnTime = Math.RandomInt(RAIN_TIME_MIN, RAIN_TIME_MAX);
          phmnLength = 0;
        }
      }
 
      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:
      int year, month, day, hour, minute;
      GetGame().GetWorld().GetDate(year, month, day, hour, minute);
      if ((hour >= 1) && (hour <= 5))
        m_Weather.GetFog().Set(0.1, 1800, 0);
      else
        m_Weather.GetFog().Set(0.0, 1800, 0);
 
      Debug.WeatherLog(string.Format("Enoch::Weather::Fog:: (%1) %2", g_Game.GetDayTime(), actual));
 
      return true;
    }
    return false;
  }
};