missionServer.c

Go to the documentation of this file.

 
//: string  uid of the player
typedef Param2<int, string> LogoutInfo;
 
class MissionServer extends MissionBase
{
  ref array<Man> m_Players;
  ref array<ref CorpseData> m_DeadPlayersArray;
  ref map<PlayerBase, ref LogoutInfo> m_LogoutPlayers;
  ref map<PlayerBase, ref LogoutInfo> m_NewLogoutPlayers;
  ref RainProcurementHandler m_RainProcHandler;
  const int SCHEDULER_PLAYERS_PER_TICK = 5;
  int m_currentPlayer;
  int m_RespawnMode;
 
  // -----------------------
  // ARTILLERY SOUNDS SETUP
  // -----------------------
  private float m_ArtyBarrageTimer = 0; // This is not to be edited in Init.c this is just to increment time
 
  // Variables to be modified in Init.c
  protected bool m_PlayArty = false; // Toggle if Off map artillery sounds are played
  protected float m_ArtyDelay = 0; // Set how much time there is between two barrages (in seconds)
  protected int m_MinSimultaneousStrikes = 0; // The MIN of simultaneous shots on the map (Will be clamped between 1 and max shots)
  protected int m_MaxSimultaneousStrikes = 0; // The MAX of simultaneous shots on the map (Will be clamped between 1 and max amount of coords)
  protected ref array<vector> m_FiringPos; // Where we should fire from. On Init set the relevant data
 
  //All Chernarus firing coordinates
  protected const ref array<vector> CHERNARUS_STRIKE_POS = {
    "-500.00 165.00 5231.69",
    "-500.00 300.00 9934.41",
    "10406.86 192.00 15860.00",
    "4811.75 370.00 15860.00",
    "-500.00 453.00 15860.00"
  };
 
  //All livonia firing coordinates
  protected const ref array<vector> LIVONIA_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"
  };
  // -----------------------
  // END OF ARTILLERY SETUP
  // -----------------------
 
  PlayerBase m_player;
  MissionBase m_mission;
  PluginAdditionalInfo m_moduleDefaultCharacter;
 
  void MissionServer()
  {
    GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).CallLater(this.UpdatePlayersStats, 30000, true);
 
    m_DeadPlayersArray = new array<ref CorpseData>;
    UpdatePlayersStats();
    m_Players = new array<Man>;
 
    m_LogoutPlayers = new map<PlayerBase, ref LogoutInfo>;
    m_NewLogoutPlayers = new map<PlayerBase, ref LogoutInfo>;
    m_RainProcHandler = new RainProcurementHandler(this);
  }
 
  void ~MissionServer()
  {
    GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).Remove(this.UpdatePlayersStats);
  }
 
  override void OnInit()
  {
    super.OnInit();
    CfgGameplayHandler.LoadData();
    PlayerSpawnHandler.LoadData();
    UndergroundAreaLoader.SpawnAllTriggerCarriers();
    //Either pass consts in Init.c or insert all desired coords (or do both ;))
    m_FiringPos = new array<vector>();
  }
 
  override void OnMissionStart()
  {
    super.OnMissionStart();
 
    // We will load the Effect areas on Default mission start
    EffectAreaLoader.CreateZones();
  }
 
  override void OnUpdate(float timeslice)
  {
    UpdateDummyScheduler();
    TickScheduler(timeslice);
    UpdateLogoutPlayers();
    m_WorldData.UpdateBaseEnvTemperature(timeslice); // re-calculate base enviro temperature
    m_RainProcHandler.Update(timeslice);
 
    RandomArtillery(timeslice);
 
    super.OnUpdate(timeslice);
  }
 
  override void OnGameplayDataHandlerLoad()
  {
    m_RespawnMode = CfgGameplayHandler.GetDisableRespawnDialog();
    GetGame().SetDebugMonitorEnabled(GetGame().ServerConfigGetInt("enableDebugMonitor"));
 
    InitialiseWorldData();
  }
 
 
  void RandomArtillery(float deltaTime)
  {
    // ARTY barrage
    if (m_PlayArty)
    {
      // We only perform timer checks and increments if we enabled the artillery barrage
      if (m_ArtyBarrageTimer > m_ArtyDelay)
      {
        //We clamp to guarantee 1 and never have multiple shots on same pos, even in case of entry error
        m_MaxSimultaneousStrikes = Math.Clamp(m_MaxSimultaneousStrikes, 1, m_FiringPos.Count());
        m_MinSimultaneousStrikes = Math.Clamp(m_MinSimultaneousStrikes, 1, m_MaxSimultaneousStrikes);
 
        // Variables to be used in this scope
        int randPos; // Select random position
        Param1<vector> pos; // The value to be sent through RPC
        array<ref Param> params; // The RPC params
 
        if (m_MaxSimultaneousStrikes == 1)
        {
          // We only have one set of coordinates to send
          randPos = Math.RandomIntInclusive(0, m_FiringPos.Count() - 1);
          pos = new Param1<vector>(m_FiringPos[randPos]);
          params = new array<ref Param>;
          params.Insert(pos);
          GetGame().RPC(null, ERPCs.RPC_SOUND_ARTILLERY, params, true);
        }
        else
        {
          //We will do some extra steps to
          /*
            1. Send multiple coords (Send one RPC per coord set)
            2. Ensure we don't have duplicates
          */
          array<int> usedIndices = new array<int>; // Will store all previusly fired upon indices
 
          // We determine how many positions fire between MIN and MAX
          int randFireNb = Math.RandomIntInclusive(m_MinSimultaneousStrikes, m_MaxSimultaneousStrikes);
          for (int i = 0; i < randFireNb; i++)
          {
            randPos = Math.RandomIntInclusive(0, m_FiringPos.Count() - 1);
 
            if (usedIndices.Count() <= 0 || usedIndices.Find(randPos) < 0) //We do not find the index or array is empty
            {
              // We prepare to send the message
              pos = new Param1<vector>(m_FiringPos[randPos]);
              params = new array<ref Param>;
 
              // We send the message with this set of coords
              params.Insert(pos);
              GetGame().RPC(null, ERPCs.RPC_SOUND_ARTILLERY, params, true);
 
              // We store the last used value
              usedIndices.Insert(randPos);
            }
          }
        }
 
        // Reset timer for new loop
        m_ArtyBarrageTimer = 0.0;
      }
 
      m_ArtyBarrageTimer += deltaTime;
    }
  }
 
  override bool IsServer()
  {
    return true;
  }
 
  override bool IsPlayerDisconnecting(Man player)
  {
    return (m_LogoutPlayers && m_LogoutPlayers.Contains(PlayerBase.Cast(player))) || (m_NewLogoutPlayers && m_NewLogoutPlayers.Contains(PlayerBase.Cast(player)));
  }
 
  void UpdatePlayersStats()
  {
    PluginLifespan moduleLifespan;
    Class.CastTo(moduleLifespan, GetPlugin(PluginLifespan));
    array<Man> players = new array<Man>();
    GetGame().GetPlayers(players);
 
    foreach (Man man : players)
    {
      PlayerBase player;
      if (Class.CastTo(player, man))
      {
        player.StatUpdateByTime(AnalyticsManagerServer.STAT_PLAYTIME);
        player.StatUpdateByPosition(AnalyticsManagerServer.STAT_DISTANCE);
 
        moduleLifespan.UpdateLifespan(player);
      }
    }
 
    UpdateCorpseStatesServer();
  }
 
  protected void AddNewPlayerLogout(PlayerBase player, notnull LogoutInfo info)
  {
    m_LogoutPlayers.Insert(player, info);
    m_NewLogoutPlayers.Remove(player);
  }
 
  // check if logout finished for some players
  void UpdateLogoutPlayers()
  {
    for (int i = 0; i < m_LogoutPlayers.Count();)
    {
      LogoutInfo info = m_LogoutPlayers.GetElement(i);
 
      if (GetGame().GetTime() >= info.param1)
      {
        PlayerIdentity identity;
        PlayerBase player = m_LogoutPlayers.GetKey(i);
        if (player)
        {
          identity = player.GetIdentity();
          m_LogoutPlayers.Remove(player);
        }
        else
          m_LogoutPlayers.RemoveElement(i);
 
        // disable reconnecting to old char
        // GetGame().RemoveFromReconnectCache(info.param2);
 
        PlayerDisconnected(player, identity, info.param2);
      }
      else
        ++i;
    }
  }
 
  override void OnEvent(EventType eventTypeId, Param params)
  {
    PlayerIdentity identity;
    PlayerBase player;
    int counter = 0;
 
    switch (eventTypeId)
    {
    case ClientPrepareEventTypeID:
      ClientPrepareEventParams clientPrepareParams;
      Class.CastTo(clientPrepareParams, params);
      CfgGameplayHandler.SyncDataSendEx(clientPrepareParams.param1);
      UndergroundAreaLoader.SyncDataSend(clientPrepareParams.param1);
      OnClientPrepareEvent(clientPrepareParams.param1, clientPrepareParams.param2, clientPrepareParams.param3, clientPrepareParams.param4, clientPrepareParams.param5);
      break;
 
    case ClientNewEventTypeID:
      ClientNewEventParams newParams;
      Class.CastTo(newParams, params);
      player = OnClientNewEvent(newParams.param1, newParams.param2, newParams.param3);
      if (!player)
      {
        Debug.Log("ClientNewEvent: Player is empty");
        return;
      }
      identity = newParams.param1;
      InvokeOnConnect(player, identity);
      SyncEvents.SendPlayerList();
 
      ControlPersonalLight(player);
      SyncGlobalLighting(player);
 
      break;
 
    case ClientReadyEventTypeID:
      ClientReadyEventParams readyParams;
      Class.CastTo(readyParams, params);
      identity = readyParams.param1;
      Class.CastTo(player, readyParams.param2);
      if (!player)
      {
        Debug.Log("ClientReadyEvent: Player is empty");
        return;
      }
 
      OnClientReadyEvent(identity, player);
      InvokeOnConnect(player, identity);
      // Send list of players at all clients
      SyncEvents.SendPlayerList();
      ControlPersonalLight(player);
      SyncGlobalLighting(player);
      break;
 
    case ClientRespawnEventTypeID:
      ClientRespawnEventParams respawnParams;
      Class.CastTo(respawnParams, params);
      identity = respawnParams.param1;
      Class.CastTo(player, respawnParams.param2);
      if (!player)
      {
        Debug.Log("ClientRespawnEvent: Player is empty");
        return;
      }
 
      OnClientRespawnEvent(identity, player);
      break;
 
    case ClientReconnectEventTypeID:
      ClientReconnectEventParams reconnectParams;
      Class.CastTo(reconnectParams, params);
 
      identity = reconnectParams.param1;
      Class.CastTo(player, reconnectParams.param2);
      if (!player)
      {
        Debug.Log("ClientReconnectEvent: Player is empty");
        return;
      }
 
      OnClientReconnectEvent(identity, player);
      break;
 
    case ClientDisconnectedEventTypeID:
      ClientDisconnectedEventParams discoParams;
      Class.CastTo(discoParams, params);
 
      identity = discoParams.param1;
      Class.CastTo(player, discoParams.param2);
      int logoutTime = discoParams.param3;
      bool authFailed = discoParams.param4;
 
      if (!player)
      {
        Debug.Log("ClientDisconnectenEvent: Player is empty");
        return;
      }
 
      OnClientDisconnectedEvent(identity, player, logoutTime, authFailed);
      break;
 
    case LogoutCancelEventTypeID:
      LogoutCancelEventParams logoutCancelParams;
 
      Class.CastTo(logoutCancelParams, params);
      Class.CastTo(player, logoutCancelParams.param1);
      identity = player.GetIdentity();
      if (identity)
      {
        // disable reconnecting to old char
        // GetGame().RemoveFromReconnectCache(identity.GetId());
        Print("[Logout]: Player " + identity.GetId() + " cancelled");
      }
      else
        Print("[Logout]: Player cancelled");
      m_LogoutPlayers.Remove(player);
      m_NewLogoutPlayers.Remove(player);
      break;
    }
  }
 
  void InvokeOnConnect(PlayerBase player, PlayerIdentity identity)
  {
    Debug.Log("InvokeOnConnect:" + this.ToString(), "Connect");
    if (player)
      player.OnConnect();
  }
 
  void InvokeOnDisconnect(PlayerBase player)
  {
    Debug.Log("InvokeOnDisconnect:" + this.ToString(), "Connect");
    if (player)
      player.OnDisconnect();
  }
 
  void OnClientPrepareEvent(PlayerIdentity identity, out bool useDB, out vector pos, out float yaw, out int preloadTimeout)
  {
    if (GetHive())
    {
      // use character from database
      useDB = true;
    }
    else
    {
      // use following data without database
      useDB = false;
      pos = "1189.3 0.0 5392.48";
      yaw = 0;
    }
  }
 
  // Enables/Disables personal light on the given player.
  void ControlPersonalLight(PlayerBase player)
  {
    if (player)
    {
      bool is_personal_light = ! GetGame().ServerConfigGetInt("disablePersonalLight");
      Param1<bool> personal_light_toggle = new Param1<bool>(is_personal_light);
      GetGame().RPCSingleParam(player, ERPCs.RPC_TOGGLE_PERSONAL_LIGHT, personal_light_toggle, true, player.GetIdentity());
    }
    else
      Error("Error! Player was not initialized at the right time. Thus cannot send RPC command to enable or disable personal light!");
  }
 
  // syncs global lighting setup from the server (lightingConfig server config parameter)
  void SyncGlobalLighting(PlayerBase player)
  {
    if (player)
    {
      int lightingID = GetGame().ServerConfigGetInt("lightingConfig");
      Param1<int> lightID = new Param1<int>(lightingID);
      GetGame().RPCSingleParam(player, ERPCs.RPC_SEND_LIGHTING_SETUP, lightID, true, player.GetIdentity());
    }
  }
 
  bool ProcessLoginData(ParamsReadContext ctx)
  {
    //creates temporary server-side structure for handling default character spawn
    return GetGame().GetMenuDefaultCharacterData(false).DeserializeCharacterData(ctx);
  }
 
  //
  PlayerBase CreateCharacter(PlayerIdentity identity, vector pos, ParamsReadContext ctx, string characterName)
  {
    Entity playerEnt;
    playerEnt = GetGame().CreatePlayer(identity, characterName, pos, 0, "NONE");//Creates random player
    Class.CastTo(m_player, playerEnt);
 
    GetGame().SelectPlayer(identity, m_player);
 
    return m_player;
  }
 
  void EquipCharacter(MenuDefaultCharacterData char_data)
  {
    int slot_ID;
    string attachment_type;
    for (int i = 0; i < DefaultCharacterCreationMethods.GetAttachmentSlotsArray().Count(); i++)
    {
      slot_ID = DefaultCharacterCreationMethods.GetAttachmentSlotsArray().Get(i);
      attachment_type = "";
      if (m_RespawnMode != GameConstants.RESPAWN_MODE_CUSTOM || !char_data.GetAttachmentMap().Find(slot_ID, attachment_type) || !VerifyAttachmentType(slot_ID, attachment_type)) //todo insert verification fn here
      {
        //randomize
        if (DefaultCharacterCreationMethods.GetConfigArrayCountFromSlotID(slot_ID) > 0)
          attachment_type = DefaultCharacterCreationMethods.GetConfigAttachmentTypes(slot_ID).GetRandomElement();
        else //undefined, moving on
          continue;
      }
 
      if (attachment_type != "")
        m_player.GetInventory().CreateAttachmentEx(attachment_type, slot_ID);
    }
 
    StartingEquipSetup(m_player, true);
  }
 
  void StartingEquipSetup(PlayerBase player, bool clothesChosen)
  {
  }
 
  bool VerifyAttachmentType(int slot_ID, string attachment_type)
  {
    return DefaultCharacterCreationMethods.GetConfigAttachmentTypes(slot_ID).Find(attachment_type) > -1;
  }
 
  PlayerBase OnClientNewEvent(PlayerIdentity identity, vector pos, ParamsReadContext ctx)
  {
    string characterType = GetGame().CreateRandomPlayer();
    bool generateRandomEquip = false;
 
    // get login data for new character
    if (ProcessLoginData(ctx) && (m_RespawnMode == GameConstants.RESPAWN_MODE_CUSTOM) && !GetGame().GetMenuDefaultCharacterData(false).IsRandomCharacterForced())
    {
      if (GetGame().ListAvailableCharacters().Find(GetGame().GetMenuDefaultCharacterData().GetCharacterType()) > -1)
        characterType = GetGame().GetMenuDefaultCharacterData().GetCharacterType();
    }
    else
      generateRandomEquip = true;
 
    if (PlayerSpawnHandler.IsInitialized())
    {
      PlayerSpawnPreset presetData = PlayerSpawnHandler.GetRandomCharacterPreset();
      if (presetData && presetData.IsValid())
      {
        string presetCharType = presetData.GetRandomCharacterType();
        if (presetCharType == string.Empty)
          presetCharType = characterType;
        if (CreateCharacter(identity, pos, ctx, presetCharType) != null)
        {
          PlayerSpawnHandler.ProcessEquipmentData(m_player, presetData);
          return m_player;
        }
        else
          ErrorEx("Failed to create character from type: " + presetCharType + ", using default spawning method");
      }
      else
        ErrorEx("Failed to load PlayerSpawnPreset data properly, using default spawning method");
    }
 
    if (CreateCharacter(identity, pos, ctx, characterType))
    {
      if (generateRandomEquip)
        GetGame().GetMenuDefaultCharacterData().GenerateRandomEquip();
      EquipCharacter(GetGame().GetMenuDefaultCharacterData());
    }
 
    return m_player;
  }
 
  void OnClientReadyEvent(PlayerIdentity identity, PlayerBase player)
  {
    GetGame().SelectPlayer(identity, player);
 
#ifdef DIAG_DEVELOPER
    if (FeatureTimeAccel.m_CurrentTimeAccel)
      GetGame().RPCSingleParam(player, ERPCs.DIAG_TIMEACCEL_CLIENT_SYNC, FeatureTimeAccel.m_CurrentTimeAccel, true, identity);
#endif
  }
 
  void OnClientRespawnEvent(PlayerIdentity identity, PlayerBase player)
  {
    if (player)
    {
      if (player.IsUnconscious() || player.IsRestrained())
      {
        // kill character
        player.SetHealth("", "", 0.0);
      }
    }
 
#ifdef DIAG_DEVELOPER
    if (FeatureTimeAccel.m_CurrentTimeAccel)
      GetGame().RPCSingleParam(player, ERPCs.DIAG_TIMEACCEL_CLIENT_SYNC, FeatureTimeAccel.m_CurrentTimeAccel, true, identity);
#endif
  }
 
  void OnClientReconnectEvent(PlayerIdentity identity, PlayerBase player)
  {
    if (player)
      player.OnReconnect();
  }
 
  void OnClientDisconnectedEvent(PlayerIdentity identity, PlayerBase player, int logoutTime, bool authFailed)
  {
    bool disconnectNow = true;
 
    // TODO: get out of vehicle
    // using database and no saving if authorization failed
    if (GetHive() && !authFailed)
    {
      if (player.IsAlive())
      {
        if (!m_LogoutPlayers.Contains(player) && !m_NewLogoutPlayers.Contains(player))
        {
          Print("[Logout]: New player " + identity.GetId() + " with logout time " + logoutTime.ToString());
 
          // send statistics to client
          player.StatSyncToClient();
 
          // inform client about logout time
          GetGame().SendLogoutTime(player, logoutTime);
 
          // wait for some time before logout and save
          LogoutInfo params = new LogoutInfo(GetGame().GetTime() + logoutTime * 1000, identity.GetId());
 
          m_NewLogoutPlayers.Insert(player, params);
          GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).CallLater(AddNewPlayerLogout, 0, false, player, params);
 
          // allow reconnecting to old char only if not in cars, od ladders etc. as they cannot be properly synchronized for reconnect
          //if (!player.GetCommand_Vehicle() && !player.GetCommand_Ladder())
          //{
          // GetGame().AddToReconnectCache(identity);
          //}
          // wait until logout timer runs out
          disconnectNow = false;
        }
        return;
      }
    }
 
    if (disconnectNow)
    {
      Print("[Logout]: New player " + identity.GetId() + " with instant logout");
 
      // inform client about instant logout
      GetGame().SendLogoutTime(player, 0);
 
      PlayerDisconnected(player, identity, identity.GetId());
    }
  }
 
  void PlayerDisconnected(PlayerBase player, PlayerIdentity identity, string uid)
  {
    // Note: At this point, identity can be already deleted
    if (!player)
    {
      Print("[Logout]: Skipping player " + uid + ", already removed");
      return;
    }
 
    // disable reconnecting to old char
    //GetGame().RemoveFromReconnectCache(uid);
 
    // now player can't cancel logout anymore, so call everything needed upon disconnect
    InvokeOnDisconnect(player);
 
    Print("[Logout]: Player " + uid + " finished");
 
    if (GetHive())
    {
      // save player
      player.Save();
 
      // unlock player in DB
      GetHive().CharacterExit(player);
    }
 
    // handle player's existing char in the world
    player.ReleaseNetworkControls();
    HandleBody(player);
 
    // remove player from server
    GetGame().DisconnectPlayer(identity, uid);
    // Send list of players at all clients
    GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(SyncEvents.SendPlayerList, 1000);
  }
 
  bool ShouldPlayerBeKilled(PlayerBase player)
  {
    if (player.IsUnconscious() || player.IsRestrained())
    {
      switch (player.GetKickOffReason())
      {
      case EClientKicked.SERVER_EXIT:
        return false;
      case EClientKicked.KICK_ALL_ADMIN:
        return false;
      case EClientKicked.KICK_ALL_SERVER:
        return false;
      case EClientKicked.SERVER_SHUTDOWN:
        return false;
      default:
        return true;
      }
    }
 
    return false;
  }
 
  void HandleBody(PlayerBase player)
  {
    if (player.IsAlive())
    {
      if (ShouldPlayerBeKilled(player))
      {
        player.SetHealth("", "", 0.0);//kill
      }
      else
      {
        player.Delete();// remove the body
      }
    }
  }
 
  void TickScheduler(float timeslice)
  {
    GetGame().GetWorld().GetPlayerList(m_Players);
    int players_count = m_Players.Count();
    int tick_count_max = Math.Min(players_count, SCHEDULER_PLAYERS_PER_TICK);
 
    for (int i = 0; i < tick_count_max; i++)
    {
      if (m_currentPlayer >= players_count)
        m_currentPlayer = 0;
 
      PlayerBase currentPlayer = PlayerBase.Cast(m_Players.Get(m_currentPlayer));
 
      if (currentPlayer)
        currentPlayer.OnTick();
      m_currentPlayer++;
    }
  }
 
  //--------------------------------------------------
  override bool InsertCorpse(Man player)
  {
    CorpseData corpse_data = new CorpseData(PlayerBase.Cast(player), GetGame().GetTime());
    return m_DeadPlayersArray.Insert(corpse_data) >= 0;
  }
 
  void UpdateCorpseStatesServer()
  {
    if (m_DeadPlayersArray.Count() == 0)//nothing to process, abort
      return;
    int current_time = GetGame().GetTime();
    array<int> invalid_corpses = new array<int>;
    CorpseData corpse_data;
 
    for (int i = 0; i < m_DeadPlayersArray.Count(); i++)
    {
      corpse_data = m_DeadPlayersArray.Get(i);
      if (!corpse_data || (corpse_data && (!corpse_data.m_Player || !corpse_data.m_bUpdate)))
        invalid_corpses.Insert(i);
      else if (corpse_data.m_bUpdate && current_time - corpse_data.m_iLastUpdateTime >= 30000)
      {
        corpse_data.UpdateCorpseState();
        corpse_data.m_iLastUpdateTime = current_time;
      }
    }
 
    //cleanup
    if (invalid_corpses.Count() > 0)
    {
      for (i = invalid_corpses.Count() - 1; i > -1; i--)
        m_DeadPlayersArray.Remove(invalid_corpses.Get(i));
    }
  }
  //--------------------------------------------------
 
  override void SyncRespawnModeInfo(PlayerIdentity identity)
  {
    ScriptRPC rpc = new ScriptRPC();
    rpc.Write(m_RespawnMode);
    rpc.Send(null, ERPCs.RPC_SERVER_RESPAWN_MODE, true, identity);
  }
 
  override RainProcurementHandler GetRainProcurementHandler()
  {
    return m_RainProcHandler;
  }
}