Land_Underground_WaterReservoir.c

Go to the documentation of this file.

class WaterLevelSettings
{
  int WaterLevel;
  float Duration;
 
  void WaterLevelSettings(int pWaterLevel, float pDuration)
  {
    WaterLevel = pWaterLevel;
    Duration = pDuration;
  }
}
 
class PressureLevelSettings
{
  int PressureLevel;
  float Duration;
 
  void PressureLevelSettings(int pPressureLevel, float pDuration)
  {
    PressureLevel = pPressureLevel;
    Duration = pDuration;
  }
}
 
class WaterLevelSnapshot
{
  float WaterHeight;
  float RemainingDuration;
}
 
class Land_Underground_WaterReservoir : BuildingBase
{
  protected const string OBJECT_NAME_WATER_PLANE = "Land_Underground_WaterReservoir_Water";
 
  protected const int WL_MIN = 0;
  protected const int WL_ABOVE_PIPES = 1;
  protected const int WL_AVERAGE = 2;
  protected const int WL_MAX = 3;
 
  protected const int PL_MIN = 0;
  protected const int PL_AVERAGE = 1;
  protected const int PL_MAX = 2;
 
  protected const int VALVES_COUNT = 2;
  protected const int VALVE_INDEX_DRAIN = 0;
  protected const int VALVE_INDEX_FILL = 1;
 
  protected const int PIPES_BROKEN_COUNT = 2;
  protected const int PIPE_INDEX_BROKEN1 = 0; 
  protected const int PIPE_INDEX_BROKEN2 = 1; 
 
  protected const string ANIM_PHASE_VALVE_GAUGE_DRAIN = "ValveGauge1";
  protected const string ANIM_PHASE_VALVE_GAUGE_FILL = "ValveGauge2";
  protected const string ANIM_PHASE_VALVE_DRAIN = "Valve1";
  protected const string ANIM_PHASE_VALVE_FILL = "Valve2";
  protected const string VALVE_NAME_DRAIN = "valve1";
  protected const string VALVE_NAME_FILL = "valve2";
  protected const string PIPE_NAME_BROKEN1 = "pipe_broken_1";
  protected const string PIPE_NAME_BROKEN2 = "pipe_broken_2";
  protected const string PIPE_NAME_LEAKING_DRAIN = "pipe_leaking_1";
  protected const string PIPE_NAME_LEAKING_FILL = "pipe_leaking_2";
 
  protected const string SOUND_NAME_PIPE_CREAKING = "WaterObjectUndergroundPipeCreaking_SoundSet";
  protected const string SOUND_NAME_VALVE_MANIPULATION = "WaterObjectUndergroundValve_SoundSet";
  protected const string SOUND_NAME_PIPE_SPRINKLING_START = "WaterObjectUndergroundPipeSprinkling_Start_SoundSet";
  protected const string SOUND_NAME_PIPE_SPRINKLING_END = "WaterObjectUndergroundPipeSprinkling_End_SoundSet";
  protected const string SOUND_NAME_PIPE_SPRINKLING_LOOP1 = "WaterObjectUndergroundPipeSprinkling_Loop1_SoundSet";
  protected const string SOUND_NAME_PIPE_SPRINKLING_LOOP2 = "WaterObjectUndergroundPipeSprinkling_Loop2_SoundSet";
  protected const string SOUND_NAME_UPIPE_SPRINKLING_START = "WaterObjectUndergroundUnderwaterPipe_Start_SoundSet";
  protected const string SOUND_NAME_UPIPE_SPRINKLING_END = "WaterObjectUndergroundUnderwaterPipe_End_SoundSet";
  protected const string SOUND_NAME_UPIPE_SPRINKLING_LOOP = "WaterObjectUndergroundUnderwaterPipe_Loop_SoundSet";
  protected const string SOUND_NAME_WATER_FILL_LOOP = "WaterObjectUndergroundUnderwaterFill_Loop_SoundSet";
  protected const string SOUND_NAME_WATER_DRAIN_LOOP = "WaterObjectUndergroundUnderwaterEmpty_Loop_SoundSet";
 
  protected const int PARTICLE_DRAIN_PIPE_MAX_PRESSURE = ParticleList.WATER_SPILLING;
  protected const int PARTICLE_FILL_PIPE_MAX_PRESSURE = ParticleList.WATER_SPILLING;
  protected const int PARTICLE_FILL_PIPE_JET = ParticleList.WATER_JET;
  protected const int PARTICLE_FILL_PIPE_JET_WEAK = ParticleList.WATER_JET_WEAK;
 
  protected ref array<ref WaterLevelSettings> m_DrainValveWaterStageSettings;
  protected ref array<ref PressureLevelSettings> m_DrainValvePressureStageSettings;
  protected ref array<ref PressureLevelSettings> m_DrainValvePressureDeanimationSettings; 
  protected ref array<ref WaterLevelSettings> m_FillValveWaterStageSettings;
  protected ref array<ref PressureLevelSettings> m_FillValvePressureStageSettings;
  protected ref array<ref PressureLevelSettings> m_FillValvePressureDeanimationSettings; 
  protected ref WaterLevelSnapshot m_WaterLevelSnapshot;
 
  protected int m_DrainValveWaterLevelStageIndex;
  protected int m_DrainValvePressureLevelStageIndex;
  protected int m_FillValveWaterLevelStageIndex;
  protected int m_FillValvePressureLevelStageIndex;
 
  protected static const string WATER_LEVEL_MAX = "water_level_max";
  protected static const string WATER_LEVEL_AVERAGE = "water_level_average";
  protected static const string WATER_LEVEL_ABOVE_PIPES = "water_level_above_pipes";
  protected static const string WATER_LEVEL_MIN = "water_level_min";
 
  protected const int WATER_LEVELS_COUNT = 4;
  protected const string WATER_LEVELS[WATER_LEVELS_COUNT] = {
    WATER_LEVEL_MAX,
    WATER_LEVEL_AVERAGE,
    WATER_LEVEL_ABOVE_PIPES,
    WATER_LEVEL_MIN
  };
 
  protected int m_ValveStatesPacked;
  protected int m_ValveStatesPackedPrev;
  protected int m_ValveManipulatedIndex;
  protected int m_ValveManipulatedIndexPrev;
  protected ref array<string> m_ValveNames;
  protected ref array<bool> m_ValveStates;
  protected ref map<string, vector> m_WaterLevelsAvailable;
  protected int m_WaterLevelActual;
  protected int m_WaterLevelPrev;
  protected ref array<bool> m_PressureAnimationRequests;
  protected ref array<bool> m_PressureDeanimationRequests;
  protected ref array<float> m_WaterLevelTimesAccumulated;
  protected ref array<float> m_PressureTimesAccumulated;
  protected int m_LastActiveValve;
 
  protected Object m_SpawnedWaterObject;
  protected vector m_WaterLevelDefault;
  protected float m_WaterLevelHeightActual;
 
  protected bool m_ValveManipulationSoundRequested;
  protected ref EffectSound m_ValveManipulationSound;
  protected ref array<EffectSound> m_PipeSounds;
 
  protected bool m_PipeCreakingSoundRequested;
  protected ref EffectSound m_PipeCreakingSounds;
 
  protected bool m_PipeUnderwaterSoundRunning
  protected ref EffectSound m_PipeUnderwaterSound;
 
  protected ref EffectSound m_WaterLevelMovementSound;
 
  protected const int PIPE_CREAKING_MIN_TIME_DELAY_MS = 10000;
  protected const int PIPE_CREAKING_MAX_TIME_DELAY_MS = 15000;
  protected const int PIPE_CREAKING_SOUND_LOCATIONS_COUNT = 4;
  protected const string PIPE_CREAKING_SOUND_LOCATIONS[PIPE_CREAKING_SOUND_LOCATIONS_COUNT] = {
    "pipe_creaking_sound_pos_1",
    "pipe_creaking_sound_pos_2",
    "pipe_creaking_sound_pos_3",
    "pipe_creaking_sound_pos_4"
  };
 
  protected ref ParticleSourceArray m_ValveParticles;
  protected ref ParticleSourceArray m_PipeBrokenParticles;
 
  void Land_Underground_WaterReservoir()
  {
    SetEventMask(EntityEvent.POSTSIMULATE);
 
    Init();
  }
 
  void ~Land_Underground_WaterReservoir()
  {
    CleanSoundEffects();
    CleanVisualEffects();
  }
 
  override void EOnPostSimulate(IEntity other, float timeSlice)
  {
#ifndef SERVER
    HandleSoundEffects();
    HandleVisualEffects();
#endif
 
    if (!GetGame().IsServer())
      return;
 
    int valve;
    float waterHeight, pressureLevel;
    WaterLevelSettings wlStageSettings, wlStageSettingsPrev;
    PressureLevelSettings plStageSettings, plStageSettingsPrev;
 
    for (valve = 0; valve < VALVES_COUNT; ++valve)
    {
      if (m_LastActiveValve != INDEX_NOT_FOUND && m_LastActiveValve != valve && m_ValveStates[valve] == true)
      {
        wlStageSettings = ActualWaterLevelStageSettings(valve);
        m_WaterLevelSnapshot = new WaterLevelSnapshot();
        m_WaterLevelSnapshot.WaterHeight = m_WaterLevelHeightActual;
        m_WaterLevelSnapshot.RemainingDuration = Math.Clamp(wlStageSettings.Duration - m_WaterLevelTimesAccumulated[valve], 0, wlStageSettings.Duration);
        m_ValveStates[valve] = false;
        m_PressureDeanimationRequests[valve] = true; 
        break;
      }
    }
 
    for (valve = 0; valve < VALVES_COUNT; ++valve)
    {
      if (m_ValveStates[valve] == true)
      {
        wlStageSettingsPrev = PreviousWaterLevelStageSettings(valve);
        wlStageSettings = ActualWaterLevelStageSettings(valve);
 
        if (wlStageSettings.Duration == -1.0)
        {
          m_ValveStates[valve] = false;
          m_WaterLevelTimesAccumulated[valve] = 0;
          m_WaterLevelSnapshot = null;
          SyncValveVariables();
          return;
        }
 
        float adjustedWaterHeight = WaterLevelToHeight(wlStageSettingsPrev.WaterLevel);
        float adjustedDuration = wlStageSettings.Duration;
        if (m_WaterLevelSnapshot)
        {
          adjustedWaterHeight = m_WaterLevelSnapshot.WaterHeight;
          adjustedDuration = wlStageSettings.Duration + m_WaterLevelSnapshot.RemainingDuration;
        }
 
        if (m_WaterLevelTimesAccumulated[valve] <= adjustedDuration)
        {
          float start = adjustedWaterHeight;
          float target = WaterLevelToHeight(wlStageSettings.WaterLevel);
          waterHeight = Math.Lerp(start, target, Easing.EaseInOutSine(m_WaterLevelTimesAccumulated[valve] / adjustedDuration));
          SetWaterLevelHeight(waterHeight);
        }
        else
        {
          m_WaterLevelTimesAccumulated[valve] = 0;
          m_WaterLevelSnapshot = null;
          AdvanceToNextWaterLevelStageSettings(valve);
          SetSynchDirty();
        }
 
        m_WaterLevelTimesAccumulated[valve] = m_WaterLevelTimesAccumulated[valve] + AdjustTime(timeSlice);
      }
      else
      {
        m_WaterLevelTimesAccumulated[valve] = 0;
        SyncValveVariables();
      }
    }
 
    int allValvesStates = 0;
 
    for (valve = 0; valve < VALVES_COUNT; ++valve)
    {
      if (m_PressureAnimationRequests[valve] == true)
      {
        bool hasToBeDeanimated = m_PressureAnimationRequests[valve] == m_PressureDeanimationRequests[valve];
        plStageSettingsPrev = PreviousPressureLevelStageSettings(valve, hasToBeDeanimated);
        plStageSettings = ActualPressureLevelStageSettings(valve, hasToBeDeanimated);
 
        if (plStageSettings.Duration == -1.0)
        {
          m_PressureTimesAccumulated[valve] = 0;
          m_PressureAnimationRequests[valve] = false;
          SyncValveVariables();
          return;
        }
 
        if (m_PressureTimesAccumulated[valve] <= plStageSettings.Duration)
        {
          float plStart = PressureLevelToValue(plStageSettingsPrev.PressureLevel);
          float plTarget = PressureLevelToValue(plStageSettings.PressureLevel);
          pressureLevel = Math.Lerp(plStart, plTarget, m_PressureTimesAccumulated[valve] / plStageSettings.Duration);
          SetValvePressureLevelGauge(valve, pressureLevel);
        }
        else
        {
          m_PressureTimesAccumulated[valve] = 0;
          if (hasToBeDeanimated && IsValvePressureLevelGaugeAtBase(valve))
          {
            m_PressureDeanimationRequests[valve] = false;
            SetDefaultPressureLevelStageSettings(valve);
          }
          else
          {
            AdvanceToNextPressureLevelStageSettings(valve);
            SetSynchDirty();
          }
        }
 
        m_PressureTimesAccumulated[valve] = m_PressureTimesAccumulated[valve] + AdjustTime(timeSlice);
      }
      else
        m_PressureTimesAccumulated[valve] = 0;
 
 
      allValvesStates += m_PressureAnimationRequests[valve];
      if (allValvesStates == false)
        SyncValveVariables();
    }
  }
 
  override void OnVariablesSynchronized()
  {
    super.OnVariablesSynchronized();
 
    m_ValveStates = UnpackBitsToArrayOfBoolStates(m_ValveStatesPacked, VALVES_COUNT);
 
    if (!m_ValveManipulationSoundRequested)
      PlayValveManipulationSound();
 
    if (m_ValveManipulatedIndex == -1)
      m_ValveManipulationSoundRequested = false;
  }
 
  override void SetActions()
  {
    super.SetActions();
 
    AddAction(ActionTurnValveUndergroundReservoir);
  }
 
  override bool HasTurnableValveBehavior()
  {
    return true;
  }
 
  protected void Init()
  {
    m_ValveNames = new array<string>();
    m_ValveStates = new array<bool>();
    m_PressureAnimationRequests = new array<bool>();
    m_PressureDeanimationRequests = new array<bool>();
    m_WaterLevelTimesAccumulated = new array<float>();
    m_PressureTimesAccumulated = new array<float>();
    m_WaterLevelsAvailable = new map<string, vector>();
    m_DrainValveWaterStageSettings = new array<ref WaterLevelSettings>();
    m_DrainValvePressureStageSettings = new array<ref PressureLevelSettings>();
    m_DrainValvePressureDeanimationSettings = new array<ref PressureLevelSettings>();
    m_FillValveWaterStageSettings = new array<ref WaterLevelSettings>();
    m_FillValvePressureStageSettings = new array<ref PressureLevelSettings>();
    m_FillValvePressureDeanimationSettings = new array<ref PressureLevelSettings>();
    m_WaterLevelSnapshot = null;
 
    m_WaterLevelActual = WL_AVERAGE;
    m_WaterLevelPrev = WL_AVERAGE;
 
    m_LastActiveValve = INDEX_NOT_FOUND;
    m_ValveManipulatedIndex = -1;
    m_ValveManipulatedIndexPrev = -1;
 
    m_PipeSounds = new array<EffectSound>();
    m_ValveParticles = new ParticleSourceArray();
    m_PipeBrokenParticles = new ParticleSourceArray();
 
    int i = 0;
    for (i = 0; i < VALVES_COUNT; ++i)
    {
      m_ValveNames.Insert("none");
      m_ValveStates.Insert(false);
      m_PressureAnimationRequests.Insert(false);
      m_PressureDeanimationRequests.Insert(false);
      m_WaterLevelTimesAccumulated.Insert(-1);
      m_PressureTimesAccumulated.Insert(-1);
      m_PipeSounds.Insert(null);
      m_ValveParticles.Insert(null);
    }
 
    for (i = 0; i < PIPES_BROKEN_COUNT; ++i)
      m_PipeBrokenParticles.Insert(null);
 
    RegisterNetSyncVariableInt("m_ValveStatesPacked", 0);
    RegisterNetSyncVariableInt("m_ValveManipulatedIndex", -1, VALVES_COUNT - 1);
    RegisterNetSyncVariableInt("m_WaterLevelActual", WL_MIN, WL_MAX);
    RegisterNetSyncVariableInt("m_WaterLevelPrev", WL_MIN, WL_MAX);
 
    GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(LateInit, 250);
  }
 
  protected void LateInit()
  {
    RegisterValve(VALVE_NAME_DRAIN, VALVE_INDEX_DRAIN);
    RegisterValve(VALVE_NAME_FILL, VALVE_INDEX_FILL);
 
    TranslateMemoryPointsToWaterLevels();
 
    ConfigureValvesAndGaugesCourse();
 
    m_WaterLevelDefault = m_WaterLevelsAvailable[WATER_LEVEL_AVERAGE];
 
    if (GetGame().IsServer())
    {
      m_SpawnedWaterObject = GetGame().CreateObjectEx(OBJECT_NAME_WATER_PLANE, m_WaterLevelDefault, ECE_CREATEPHYSICS);
      m_SpawnedWaterObject.SetOrientation(GetOrientation());
      SetWaterLevelHeight(m_WaterLevelDefault[1]);
    }
 
    GetGame().RegisterNetworkStaticObject(this);
    SetSynchDirty();
  }
 
  protected void ConfigureValvesAndGaugesCourse()
  {
    m_DrainValveWaterStageSettings.Insert(new WaterLevelSettings(WL_AVERAGE, -1.0));
    m_DrainValveWaterStageSettings.Insert(new WaterLevelSettings(WL_MIN, 40.0));
    m_DrainValveWaterStageSettings.Insert(new WaterLevelSettings(WL_MIN, 200.0));
    m_DrainValveWaterStageSettings.Insert(new WaterLevelSettings(WL_AVERAGE, 360.0));
 
    m_DrainValvePressureStageSettings.Insert(new PressureLevelSettings(PL_MIN, -1.0));
    m_DrainValvePressureStageSettings.Insert(new PressureLevelSettings(PL_MAX, 40.0));
    m_DrainValvePressureStageSettings.Insert(new PressureLevelSettings(PL_MAX, 200.0));
    m_DrainValvePressureStageSettings.Insert(new PressureLevelSettings(PL_MIN, 360.0));
 
    m_DrainValvePressureDeanimationSettings.Insert(new PressureLevelSettings(PL_AVERAGE, -1));
    m_DrainValvePressureDeanimationSettings.Insert(new PressureLevelSettings(PL_MIN, 5.0));
 
    m_FillValveWaterStageSettings.Insert(new WaterLevelSettings(WL_AVERAGE, -1.0));
    m_FillValveWaterStageSettings.Insert(new WaterLevelSettings(WL_MAX, 40.0));
    m_FillValveWaterStageSettings.Insert(new WaterLevelSettings(WL_MAX, 100.0));
    m_FillValveWaterStageSettings.Insert(new WaterLevelSettings(WL_AVERAGE, 40.0));
 
    m_FillValvePressureStageSettings.Insert(new PressureLevelSettings(PL_MAX, -1.0));
    m_FillValvePressureStageSettings.Insert(new PressureLevelSettings(PL_MIN, 40.0));
    m_FillValvePressureStageSettings.Insert(new PressureLevelSettings(PL_MIN, 100.0));
    m_FillValvePressureStageSettings.Insert(new PressureLevelSettings(PL_MAX, 40.0));
 
    m_FillValvePressureDeanimationSettings.Insert(new PressureLevelSettings(PL_AVERAGE, -1.0));
    m_FillValvePressureDeanimationSettings.Insert(new PressureLevelSettings(PL_MAX, 5.0));
  }
 
  override bool IsValveTurnable(int pValveIndex)
  {
    return !IsValveActive(pValveIndex) && IsValvePressureLevelGaugeAtBase(pValveIndex);
  }
 
  protected bool IsAnyValveActive()
  {
    for (int i = 0; i < m_ValveStates.Count(); ++i)
    {
      if (m_ValveStates[i])
        return true;
    }
 
    return false;
  }
 
  protected bool IsValveActive(int pValveIndex)
  {
    return pValveIndex >= 0 && pValveIndex <= VALVES_COUNT && m_ValveStates[pValveIndex];
  }
 
  override int GetTurnableValveIndex(int pComponentIndex)
  {
    string targetedValveName = GetActionComponentName(pComponentIndex);
    for (int i = 0; i < m_ValveNames.Count(); ++i)
    {
      if (m_ValveNames[i] == targetedValveName)
        return i;
    }
 
    return INDEX_NOT_FOUND;
  }
 
  void OnValveManipulationStart(int pValveIndex)
  {
    if (GetGame().IsServer())
    {
      AnimateValve(pValveIndex, 1);
      m_ValveManipulatedIndex = pValveIndex;
      SetSynchDirty();
    }
  }
 
  void OnValveManipulationEnd(int pValveIndex)
  {
    if (GetGame().IsServer())
    {
      switch (pValveIndex)
      {
      case VALVE_INDEX_DRAIN:
        m_ValveStates[pValveIndex] = true;
        m_PressureAnimationRequests[pValveIndex] = true;
        m_DrainValveWaterLevelStageIndex = 1;
        m_DrainValvePressureLevelStageIndex = 1;
        SetLastActiveValve(pValveIndex);
        AnimateValve(pValveIndex, 0);
        break;
      case VALVE_INDEX_FILL:
        m_ValveStates[pValveIndex] = true;
        m_PressureAnimationRequests[pValveIndex] = true;
        m_FillValveWaterLevelStageIndex = 1;
        m_FillValvePressureLevelStageIndex = 1;
        AnimateValve(pValveIndex, 0);
        SetLastActiveValve(pValveIndex);
        break;
      }
 
      SyncValveVariables();
    }
  }
 
  void OnValveManipulationCanceled(int pValveIndex)
  {
    if (GetGame().IsServer())
    {
      AnimateValve(pValveIndex, 0);
      m_ValveManipulatedIndex = -1;
      SetSynchDirty();
    }
  }
 
  array<vector> GetValveAligningPointsWS(int pValveIndex)
  {
    vector posPoint, dirPoint = vector.Zero;
 
    switch (pValveIndex)
    {
    case VALVE_INDEX_DRAIN:
      posPoint = GetMemoryPointPosition(string.Format("%1_align_pos", VALVE_NAME_DRAIN));
      dirPoint = GetMemoryPointPosition(string.Format("%1_align_dir", VALVE_NAME_DRAIN));
      break;
    case VALVE_INDEX_FILL:
      posPoint = GetMemoryPointPosition(string.Format("%1_align_pos", VALVE_NAME_FILL));
      dirPoint = GetMemoryPointPosition(string.Format("%1_align_dir", VALVE_NAME_FILL));
      break;
    }
 
    array<vector> valvePositions = new array<vector>();
    valvePositions.Insert(posPoint);
    valvePositions.Insert(dirPoint);
 
    return valvePositions;
  }
 
  protected void SetLastActiveValve(int pValveIndex)
  {
    m_LastActiveValve = pValveIndex;
  }
 
  protected void SetWaterLevelHeight(float pHeight)
  {
    if (GetGame() && GetGame().IsServer())
    {
      vector pos = Vector(m_WaterLevelDefault[0], pHeight, m_WaterLevelDefault[2]);
      m_WaterLevelHeightActual = pHeight;
      m_WaterLevelActual = HeightToWaterLevel(pHeight);
 
      if (m_SpawnedWaterObject)
        m_SpawnedWaterObject.SetPosition(pos);
    }
  }
 
  protected void RegisterValve(string pCompName, int pIndex)
  {
    m_ValveNames.Set(pIndex, pCompName);
    m_ValveStates.Set(pIndex, false);
    m_PressureAnimationRequests.Set(pIndex, 0);
    m_PressureDeanimationRequests.Set(pIndex, 0);
    m_WaterLevelTimesAccumulated.Set(pIndex, 0);
    m_PressureTimesAccumulated.Set(pIndex, false);
    m_PipeSounds.Set(pIndex, null);
  }
 
  protected void TranslateMemoryPointsToWaterLevels()
  {
    m_WaterLevelsAvailable.Clear();
    for (int i = 0; i < WATER_LEVELS_COUNT; ++i)
    {
      if (MemoryPointExists(WATER_LEVELS[i]))
      {
        if (!m_WaterLevelsAvailable.Contains(WATER_LEVELS[i]))
          m_WaterLevelsAvailable.Insert(WATER_LEVELS[i], ModelToWorld(GetMemoryPointPos(WATER_LEVELS[i])));
      }
    }
  }
 
  protected float WaterLevelToHeight(int pWaterLevel)
  {
    switch (pWaterLevel)
    {
    case WL_MIN:
      return m_WaterLevelsAvailable[WATER_LEVEL_MIN][1];
    case WL_ABOVE_PIPES:
      return m_WaterLevelsAvailable[WATER_LEVEL_ABOVE_PIPES][1];
    case WL_AVERAGE:
      return m_WaterLevelsAvailable[WATER_LEVEL_AVERAGE][1];
    case WL_MAX:
      return m_WaterLevelsAvailable[WATER_LEVEL_MAX][1];
    }
 
    return 0;
  }
 
  protected int HeightToWaterLevel(float pHeight)
  {
    if (pHeight <= m_WaterLevelsAvailable[WATER_LEVEL_MIN][1])
      return WL_MIN;
    else if (pHeight > m_WaterLevelsAvailable[WATER_LEVEL_MIN][1] && pHeight <= m_WaterLevelsAvailable[WATER_LEVEL_ABOVE_PIPES][1])
      return WL_ABOVE_PIPES;
    else if (pHeight > m_WaterLevelsAvailable[WATER_LEVEL_ABOVE_PIPES][1] && pHeight <= m_WaterLevelsAvailable[WATER_LEVEL_AVERAGE][1])
      return WL_AVERAGE;
    else if (pHeight < m_WaterLevelsAvailable[WATER_LEVEL_MAX][1] && pHeight >= m_WaterLevelsAvailable[WATER_LEVEL_AVERAGE][1])
      return WL_AVERAGE;
 
    return WL_MAX;
  }
 
  protected float PressureLevelToValue(int pPressureLevel)
  {
    switch (pPressureLevel)
    {
    case PL_MIN:
      return 0.0;
    case PL_AVERAGE:
      return 0.5;
    case PL_MAX:
      return 1.0;
    }
 
    return 0.0;
  }
 
  protected WaterLevelSettings PreviousWaterLevelStageSettings(int pValveIndex)
  {
    WaterLevelSettings wlStageSettings;
 
    switch (pValveIndex)
    {
    case VALVE_INDEX_DRAIN:
      if (m_DrainValveWaterLevelStageIndex > 0)
        wlStageSettings = m_DrainValveWaterStageSettings.Get(m_DrainValveWaterLevelStageIndex - 1);
      else
        wlStageSettings = m_DrainValveWaterStageSettings.Get(m_DrainValveWaterLevelStageIndex);
      break;
    case VALVE_INDEX_FILL:
      if (m_FillValveWaterLevelStageIndex > 0)
        wlStageSettings = m_FillValveWaterStageSettings.Get(m_FillValveWaterLevelStageIndex - 1);
      else
        wlStageSettings = m_FillValveWaterStageSettings.Get(m_FillValveWaterLevelStageIndex);
      break;
    }
 
    m_WaterLevelPrev = wlStageSettings.WaterLevel;
    SetSynchDirty();
 
    return wlStageSettings;
  }
 
  protected WaterLevelSettings ActualWaterLevelStageSettings(int pValveIndex)
  {
    WaterLevelSettings wlStageSettings;
 
    switch (pValveIndex)
    {
    case VALVE_INDEX_DRAIN:
      wlStageSettings = m_DrainValveWaterStageSettings.Get(m_DrainValveWaterLevelStageIndex);
      break;
    case VALVE_INDEX_FILL:
      wlStageSettings = m_FillValveWaterStageSettings.Get(m_FillValveWaterLevelStageIndex);
      break;
    }
 
    return wlStageSettings;
  }
 
  protected void AdvanceToNextWaterLevelStageSettings(int pValveIndex)
  {
    switch (pValveIndex)
    {
    case VALVE_INDEX_DRAIN:
      if (m_DrainValveWaterLevelStageIndex < m_DrainValveWaterStageSettings.Count() - 1)
        m_DrainValveWaterLevelStageIndex++;
      else
        m_DrainValveWaterLevelStageIndex = 0;
      break;
    case VALVE_INDEX_FILL:
      if (m_FillValveWaterLevelStageIndex < m_FillValveWaterStageSettings.Count() - 1)
        m_FillValveWaterLevelStageIndex++;
      else
        m_FillValveWaterLevelStageIndex = 0;
      break;
    }
  }
 
  protected PressureLevelSettings PreviousPressureLevelStageSettings(int pValveIndex, bool pDeanimationRequest = false)
  {
    PressureLevelSettings plStageSettings;
 
    switch (pValveIndex)
    {
    case VALVE_INDEX_DRAIN:
      if (pDeanimationRequest)
      {
        plStageSettings = m_FillValvePressureDeanimationSettings[0];
        return plStageSettings;
      }
 
      if (m_DrainValvePressureLevelStageIndex > 0)
        plStageSettings = m_DrainValvePressureStageSettings.Get(m_DrainValvePressureLevelStageIndex - 1);
      else
        plStageSettings = m_DrainValvePressureStageSettings.Get(m_DrainValvePressureLevelStageIndex);
      break;
    case VALVE_INDEX_FILL:
      if (pDeanimationRequest)
      {
        plStageSettings = m_FillValvePressureDeanimationSettings[0];
        return plStageSettings;
      }
 
      if (m_FillValvePressureLevelStageIndex > 0)
        plStageSettings = m_FillValvePressureStageSettings.Get(m_FillValvePressureLevelStageIndex - 1);
      else
        plStageSettings = m_FillValvePressureStageSettings.Get(m_FillValvePressureLevelStageIndex);
      break;
    }
 
    return plStageSettings;
  }
 
  protected PressureLevelSettings ActualPressureLevelStageSettings(int pValveIndex, bool pDeanimationRequest = false)
  {
    PressureLevelSettings plStageSettings;
 
    switch (pValveIndex)
    {
    case VALVE_INDEX_DRAIN:
      if (pDeanimationRequest)
      {
        plStageSettings = m_DrainValvePressureDeanimationSettings[1];
        return plStageSettings;
      }
 
      plStageSettings = m_DrainValvePressureStageSettings.Get(m_DrainValvePressureLevelStageIndex);
      break;
    case VALVE_INDEX_FILL:
      if (pDeanimationRequest)
      {
        plStageSettings = m_FillValvePressureDeanimationSettings[1];
        return plStageSettings;
      }
 
      plStageSettings = m_FillValvePressureStageSettings.Get(m_FillValvePressureLevelStageIndex);
      break;
    }
 
    return plStageSettings;
  }
 
  protected void AdvanceToNextPressureLevelStageSettings(int pValveIndex)
  {
    switch (pValveIndex)
    {
    case VALVE_INDEX_DRAIN:
      if (m_DrainValvePressureLevelStageIndex < m_DrainValvePressureStageSettings.Count() - 1)
        m_DrainValvePressureLevelStageIndex++;
      else
        m_DrainValvePressureLevelStageIndex = 0;
      break;
    case VALVE_INDEX_FILL:
      if (m_FillValvePressureLevelStageIndex < m_FillValvePressureStageSettings.Count() - 1)
        m_FillValvePressureLevelStageIndex++;
      else
        m_FillValvePressureLevelStageIndex = 0;
      break;
    }
  }
 
  protected void SetDefaultPressureLevelStageSettings(int pValveIndex)
  {
    switch (pValveIndex)
    {
    case VALVE_INDEX_DRAIN:
      m_DrainValvePressureLevelStageIndex = 0;
      break;
    case VALVE_INDEX_FILL:
      m_FillValvePressureLevelStageIndex = 0;
      break;
    }
  }
 
  protected void AnimateValve(int pValveIndex, float pPhase)
  {
    switch (pValveIndex)
    {
    case VALVE_INDEX_DRAIN:
      SetAnimationPhase(ANIM_PHASE_VALVE_DRAIN, pPhase);
      break;
    case VALVE_INDEX_FILL:
      SetAnimationPhase(ANIM_PHASE_VALVE_FILL, pPhase);
      break;
    }
  }
 
  protected void SetValvePressureLevelGauge(int pValveIndex, float pValue)
  {
    switch (pValveIndex)
    {
    case VALVE_INDEX_DRAIN:
      SetAnimationPhase(ANIM_PHASE_VALVE_GAUGE_DRAIN, pValue);
      break;
    case VALVE_INDEX_FILL:
      SetAnimationPhase(ANIM_PHASE_VALVE_GAUGE_FILL, pValue);
      break;
    }
  }
 
  protected float GetValvePressureLevelGauge(int pValveIndex)
  {
    switch (pValveIndex)
    {
    case VALVE_INDEX_DRAIN:
      return GetAnimationPhase(ANIM_PHASE_VALVE_GAUGE_DRAIN);
      break;
    case VALVE_INDEX_FILL:
      return GetAnimationPhase(ANIM_PHASE_VALVE_GAUGE_FILL);
      break;
    }
 
    return 0;
  }
 
  protected bool IsValvePressureLevelGaugeAtBase(int pValveIndex)
  {
    switch (pValveIndex)
    {
    case VALVE_INDEX_DRAIN:
      return GetValvePressureLevelGauge(pValveIndex) <= 0.01;
      break;
    case VALVE_INDEX_FILL:
      return GetValvePressureLevelGauge(pValveIndex) >= 0.99;
      break;
    }
 
    return 0.0;
  }
 
  protected float AdjustTime(float originalTime)
  {
#ifdef DIAG_DEVELOPER
    float timeAccel = 1;
    if (FeatureTimeAccel.GetFeatureTimeAccelEnabled(ETimeAccelCategories.UNDERGROUND_RESERVOIR))
    {
      timeAccel = FeatureTimeAccel.GetFeatureTimeAccelValue();
      return originalTime * timeAccel;
    }
#endif
    return originalTime;
  }
 
  protected vector GetMemoryPointPosition(string pMemoryPoint)
  {
    vector pos = vector.Zero;
 
    if (MemoryPointExists(pMemoryPoint))
    {
      pos = GetMemoryPointPos(pMemoryPoint);
      pos = ModelToWorld(pos);
    }
    else
      ErrorEx(string.Format("Memory point %1 not found, falling back to vector.Zero", pMemoryPoint));
 
    return pos;
  }
 
  protected void HandleSoundEffects()
  {
    HandleSoundEffectsPipeCreaking();
    HandleSoundEffectsPipeSprinkling();
    HandleSoundEffectsUnderwaterPipeSounds();
    HandleSoundEffectsWaterLevelMovementSounds();
  }
 
  protected void PlayValveManipulationSound()
  {
    switch (m_ValveManipulatedIndex)
    {
    case VALVE_INDEX_DRAIN:
      m_ValveManipulationSoundRequested = PlaySoundSetAtMemoryPoint(m_ValveManipulationSound, SOUND_NAME_VALVE_MANIPULATION, VALVE_NAME_DRAIN);
      break;
    case VALVE_INDEX_FILL:
      m_ValveManipulationSoundRequested = PlaySoundSetAtMemoryPoint(m_ValveManipulationSound, SOUND_NAME_VALVE_MANIPULATION, VALVE_NAME_FILL);
      break;
    }
  }
 
  protected void HandleSoundEffectsPipeCreaking()
  {
    if (IsAnyValveActive())
    {
      if ((m_PipeCreakingSounds == null && !m_PipeCreakingSoundRequested) || !m_PipeCreakingSoundRequested)
      {
        m_PipeCreakingSoundRequested = true;
        int randomDelay = Math.RandomInt(PIPE_CREAKING_MIN_TIME_DELAY_MS, PIPE_CREAKING_MAX_TIME_DELAY_MS);
        GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(PlayPipeCreakingSoundOnLocation, randomDelay, false);
      }
    }
    else
    {
      if (m_PipeCreakingSounds)
      {
        StopSoundSet(m_PipeCreakingSounds);
        m_PipeCreakingSounds = null;
      }
    }
  }
 
  protected void HandleSoundEffectsPipeSprinkling()
  {
    if (!m_PipeSounds || m_PipeSounds.Count() == 0)
      return;
 
    EffectSound sndDrain, sndFill;
    float drainPressureLevel = GetValvePressureLevelGauge(VALVE_INDEX_DRAIN);
    if (drainPressureLevel >= 0.4 && drainPressureLevel < 0.8)
    {
      if (m_PipeSounds[VALVE_INDEX_DRAIN] == null)
      {
        PlaySoundSetAtMemoryPoint(sndDrain, SOUND_NAME_PIPE_SPRINKLING_START, VALVE_NAME_DRAIN, false, 0.0, 0.5);
        m_PipeSounds[VALVE_INDEX_DRAIN] = sndDrain;
        StopSoundSet(m_PipeSounds[VALVE_INDEX_DRAIN]);
        m_PipeSounds[VALVE_INDEX_DRAIN] = null;
        PlaySoundSetAtMemoryPointLooped(sndDrain, SOUND_NAME_PIPE_SPRINKLING_LOOP1, VALVE_NAME_DRAIN, 0.5, 0.5);
        m_PipeSounds[VALVE_INDEX_DRAIN] = sndDrain;
      }
    }
 
    if (drainPressureLevel < 0.4)
    {
      if (m_PipeSounds[VALVE_INDEX_DRAIN] != null)
      {
        StopSoundSet(m_PipeSounds[VALVE_INDEX_DRAIN]);
        m_PipeSounds[VALVE_INDEX_DRAIN] = null;
      }
    }
 
 
    float fillPressureLevel = GetValvePressureLevelGauge(VALVE_INDEX_FILL);
    if (fillPressureLevel >= 0.4)
    {
      if (m_PipeSounds[VALVE_INDEX_FILL] == null)
      {
        PlaySoundSetAtMemoryPoint(sndFill, SOUND_NAME_PIPE_SPRINKLING_START, VALVE_NAME_FILL, false, 0.0, 0.5);
        StopSoundSet(m_PipeSounds[VALVE_INDEX_FILL]);
        m_PipeSounds[VALVE_INDEX_FILL] = null;
        PlaySoundSetAtMemoryPointLooped(sndFill, SOUND_NAME_PIPE_SPRINKLING_LOOP2, VALVE_NAME_FILL, 0.5, 0.5);
        m_PipeSounds[VALVE_INDEX_FILL] = sndFill;
      }
    }
 
    if (fillPressureLevel < 0.4)
    {
      if (m_PipeSounds[VALVE_INDEX_FILL] != null)
      {
        StopSoundSet(m_PipeSounds[VALVE_INDEX_FILL]);
        m_PipeSounds[VALVE_INDEX_FILL] = null;
      }
    }
  }
 
  protected void HandleSoundEffectsUnderwaterPipeSounds()
  {
    if (IsValveActive(VALVE_INDEX_FILL))
    {
      if ((m_WaterLevelActual == WL_ABOVE_PIPES) || (m_WaterLevelActual == WL_MAX && m_WaterLevelPrev == WL_AVERAGE))
      {
        if (m_PipeUnderwaterSound == null)
        {
          PlaySoundSetAtMemoryPoint(m_PipeUnderwaterSound, SOUND_NAME_UPIPE_SPRINKLING_START, PIPE_NAME_BROKEN1, false, 0.0, 0.5);
          StopSoundSet(m_PipeUnderwaterSound);
          m_PipeUnderwaterSound = null;
          m_PipeUnderwaterSoundRunning = PlaySoundSetAtMemoryPointLooped(m_PipeUnderwaterSound, SOUND_NAME_UPIPE_SPRINKLING_LOOP, PIPE_NAME_BROKEN1, 0.0, 0.5);
        }
      }
      else if (m_WaterLevelActual == m_WaterLevelPrev)
      {
        if (m_PipeUnderwaterSound)
        {
          StopSoundSet(m_PipeUnderwaterSound);
          if (m_PipeUnderwaterSoundRunning)
          {
            PlaySoundSetAtMemoryPoint(m_PipeUnderwaterSound, SOUND_NAME_UPIPE_SPRINKLING_END, PIPE_NAME_BROKEN1, false, 0.0, 0.5);
            m_PipeUnderwaterSoundRunning = false;
          }
        }
      }
    }
  }
 
  protected void HandleSoundEffectsWaterLevelMovementSounds()
  {
    if (m_WaterLevelActual < m_WaterLevelPrev)
    {
      if (m_WaterLevelMovementSound == null)
        PlaySoundSetAtMemoryPointLooped(m_WaterLevelMovementSound, SOUND_NAME_WATER_DRAIN_LOOP, PIPE_NAME_BROKEN1, 0.0, 0.5);
    }
    else if (m_WaterLevelActual > m_WaterLevelPrev)
    {
      if (m_WaterLevelMovementSound == null)
        PlaySoundSetAtMemoryPointLooped(m_WaterLevelMovementSound, SOUND_NAME_WATER_FILL_LOOP, PIPE_NAME_BROKEN1, 0.0, 0.5);
    }
    else if (m_WaterLevelActual == m_WaterLevelPrev)
    {
      if (m_WaterLevelMovementSound)
        StopSoundSet(m_WaterLevelMovementSound);
    }
  }
 
  protected void CleanSoundEffects()
  {
    SEffectManager.DestroySound(m_PipeSounds[VALVE_INDEX_DRAIN]);
    SEffectManager.DestroySound(m_PipeSounds[VALVE_INDEX_FILL]);
  }
 
  protected void PlayPipeCreakingSoundOnLocation()
  {
    m_PipeCreakingSoundRequested = false;
    int index = Math.RandomInt(0, PIPE_CREAKING_SOUND_LOCATIONS_COUNT);
    PlaySoundSetAtMemoryPoint(m_PipeCreakingSounds, SOUND_NAME_PIPE_CREAKING, PIPE_CREAKING_SOUND_LOCATIONS[index]);
  }
 
  protected void HandleVisualEffects()
  {
    if (GetValvePressureLevelGauge(VALVE_INDEX_DRAIN) >= 0.4)
    {
      if (m_ValveParticles[VALVE_INDEX_DRAIN] == null)
        m_ValveParticles[VALVE_INDEX_DRAIN] = ParticleManager.GetInstance().PlayInWorldEx(PARTICLE_DRAIN_PIPE_MAX_PRESSURE, null, GetMemoryPointPosition(PIPE_NAME_LEAKING_DRAIN), GetOrientation() + "0 -90 165", true);
    }
 
    if (GetValvePressureLevelGauge(VALVE_INDEX_DRAIN) <= 0.4)
    {
      if (m_ValveParticles[VALVE_INDEX_DRAIN] != null)
      {
        m_ValveParticles[VALVE_INDEX_DRAIN].StopParticle();
        m_ValveParticles[VALVE_INDEX_DRAIN] = null;
      }
    }
 
    if (GetValvePressureLevelGauge(VALVE_INDEX_FILL) >= 0.4)
    {
      if (m_ValveParticles[VALVE_INDEX_FILL] == null)
        m_ValveParticles[VALVE_INDEX_FILL] = ParticleManager.GetInstance().PlayInWorldEx(PARTICLE_FILL_PIPE_MAX_PRESSURE, null, GetMemoryPointPosition(PIPE_NAME_LEAKING_FILL), GetOrientation() + "0 90 -90", true);
    }
 
    if (GetValvePressureLevelGauge(VALVE_INDEX_FILL) <= 0.4)
    {
      if (m_ValveParticles[VALVE_INDEX_FILL] != null)
      {
        m_ValveParticles[VALVE_INDEX_FILL].StopParticle();
        m_ValveParticles[VALVE_INDEX_FILL] = null;
      }
    }
 
 
    if (IsValveActive(VALVE_INDEX_FILL))
    {
      if ((m_WaterLevelActual == WL_ABOVE_PIPES) || (m_WaterLevelActual == WL_MAX && m_WaterLevelPrev == WL_AVERAGE))
      {
        if (m_PipeBrokenParticles[PIPE_INDEX_BROKEN1] == null)
          m_PipeBrokenParticles[PIPE_INDEX_BROKEN1] = ParticleManager.GetInstance().PlayInWorldEx(PARTICLE_FILL_PIPE_JET, null, GetMemoryPointPosition(PIPE_NAME_BROKEN1), GetOrientation() + "0 0 0", true);
 
        if (m_PipeBrokenParticles[PIPE_INDEX_BROKEN2])
        {
          m_PipeBrokenParticles[PIPE_INDEX_BROKEN2].StopParticle();
          m_PipeBrokenParticles[PIPE_INDEX_BROKEN2] = null;
        }
      }
    }
 
    if ((m_WaterLevelActual == WL_ABOVE_PIPES && m_WaterLevelPrev == WL_AVERAGE))
    {
      if (m_PipeBrokenParticles[PIPE_INDEX_BROKEN2] == null)
        m_PipeBrokenParticles[PIPE_INDEX_BROKEN2] = ParticleManager.GetInstance().PlayInWorldEx(PARTICLE_FILL_PIPE_JET_WEAK, null, GetMemoryPointPosition(PIPE_NAME_BROKEN2), GetOrientation() + "0 0 0", true);
    }
 
    if (m_WaterLevelActual >= WL_AVERAGE)
    {
      for (int pipe = 0; pipe < m_PipeBrokenParticles.Count(); ++pipe)
      {
        if (m_PipeBrokenParticles[pipe])
        {
          m_PipeBrokenParticles[pipe].StopParticle();
          m_PipeBrokenParticles[pipe] = null;
        }
      }
    }
  }
 
  protected void CleanVisualEffects()
  {
    for (int valve = 0; valve < VALVES_COUNT; ++valve)
    {
      if (m_ValveParticles[valve])
      {
        m_ValveParticles[valve].StopParticle();
        m_ValveParticles[valve] = null;
      }
    }
 
    for (int pipe = 0; pipe < m_PipeBrokenParticles.Count(); ++pipe)
    {
      if (m_PipeBrokenParticles[pipe])
      {
        m_PipeBrokenParticles[pipe].StopParticle();
        m_PipeBrokenParticles[pipe] = null;
      }
    }
  }
 
 
  protected void ResetState()
  {
    SetWaterLevelHeight(m_WaterLevelsAvailable[WATER_LEVEL_AVERAGE][1]);
    SetValvePressureLevelGauge(VALVE_INDEX_DRAIN, 0.0);
    SetValvePressureLevelGauge(VALVE_INDEX_FILL, 1.0);
    m_DrainValveWaterLevelStageIndex = 0;
    m_DrainValvePressureLevelStageIndex = 0;
    m_FillValveWaterLevelStageIndex = 0;
    m_FillValvePressureLevelStageIndex = 0;
    m_ValveStates = {0, 0};
    m_PressureAnimationRequests = {0, 0};
    m_PressureDeanimationRequests = {0, 0};
    m_WaterLevelTimesAccumulated = {0, 0};
    m_PressureTimesAccumulated = {0, 0};
    m_LastActiveValve = -1;
    m_WaterLevelHeightActual = WaterLevelToHeight(WL_AVERAGE);
    m_PipeCreakingSoundRequested = false;
    m_ValveManipulatedIndex = -1;
    m_ValveManipulatedIndexPrev = -1;
    SetSynchDirty();
    CleanSoundEffects();
  }
 
  protected void SyncValveVariables()
  {
    if (GetGame())
    {
      m_ValveStatesPacked = PackArrayOfBoolStatesIntoBits(m_ValveStates);
      if (m_ValveStatesPacked != m_ValveStatesPackedPrev)
      {
        m_ValveStatesPackedPrev = m_ValveStatesPacked;
        SetSynchDirty();
      }
    }
  }
 
  protected int PackArrayOfBoolStatesIntoBits(array<bool> pStates)
  {
    int packedBits = 0;
 
    for (int i = 0; i < pStates.Count(); ++i)
    {
      if (pStates[i] == true)
        packedBits |= 1 << i;
    }
 
    return packedBits;
  }
 
  protected array<bool> UnpackBitsToArrayOfBoolStates(int pPackedBits, int pArrayLength)
  {
    array<bool> unpackedBools = new array<bool>();
    for (int i = 0; i < pArrayLength; ++i)
    {
      if ((pPackedBits & 1 << i) != 0)
        unpackedBools.Insert(true);
      else
        unpackedBools.Insert(false);
    }
 
    return unpackedBools;
  }
 
#ifdef DEVELOPER
  override protected string GetDebugText()
  {
    string debug_output = "";
    debug_output += string.Format("\nm_WaterLevelActual: %1", m_WaterLevelActual);
    debug_output += string.Format("\nm_WaterLevelPrev: %1", m_WaterLevelPrev);
    debug_output += string.Format("\nm_ValveManipulatedIndex: %1", m_ValveManipulatedIndex);
 
    int valve;
    for (valve = 0; valve < VALVES_COUNT; ++valve)
      debug_output += string.Format("\nvalve %1 state:%2 | pressure req: %2", valve, m_ValveStates[valve], m_PressureAnimationRequests[valve]);
 
    return debug_output;
  }
 
  override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
  {
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SPECIALIZED_ACTION1, "Reset state", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SPECIALIZED_ACTION2, "Drain", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SPECIALIZED_ACTION3, "Fill", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.LIGHT_GREY));
 
    super.GetDebugActions(outputList);
  }
 
  override bool OnAction(int action_id, Man player, ParamsReadContext ctx)
  {
    if (super.OnAction(action_id, player, ctx))
      return true;
    if (GetGame().IsServer() || !GetGame().IsMultiplayer())
    {
      if (action_id == EActions.SPECIALIZED_ACTION1)
      {
        ResetState();
        ActualWaterLevelStageSettings(VALVE_INDEX_DRAIN);
        PreviousWaterLevelStageSettings(VALVE_INDEX_DRAIN);
        ActualWaterLevelStageSettings(VALVE_INDEX_FILL);
        PreviousWaterLevelStageSettings(VALVE_INDEX_FILL);
      }
      else if (action_id == EActions.SPECIALIZED_ACTION2)
      {
        ResetState();
        m_ValveStates[VALVE_INDEX_DRAIN] = 1;
        m_PressureAnimationRequests[VALVE_INDEX_DRAIN] = 1;
        m_DrainValveWaterLevelStageIndex = 1;
        m_DrainValvePressureLevelStageIndex = 1;
        SetLastActiveValve(VALVE_INDEX_DRAIN);
      }
      else if (action_id == EActions.SPECIALIZED_ACTION3)
      {
        ResetState();
        m_ValveStates[VALVE_INDEX_FILL] = 1;
        m_PressureAnimationRequests[VALVE_INDEX_FILL] = 1;
        m_FillValveWaterLevelStageIndex = 1;
        m_FillValvePressureLevelStageIndex = 1;
        SetLastActiveValve(VALVE_INDEX_FILL);
        SetSynchDirty();
      }
    }
    return false;
  }
 
 
#endif
}
 
class Land_Underground_WaterReservoir_Water : BuildingBase {}