StateManager.c

Go to the documentation of this file.

enum AnimType
{
  FULL_BODY = 1,
  ADDITIVE,
}
 
enum SymptomIDs
{
  SYMPTOM_COUGH = 1,
  SYMPTOM_VOMIT,
  SYMPTOM_BLINDNESS,
  SYMPTOM_BULLET_HIT,
  SYMPTOM_BLEEDING_SOURCE,
  SYMPTOM_BLOODLOSS,
  SYMPTOM_SNEEZE,
  SYMPTOM_FEVERBLUR,
  SYMPTOM_LAUGHTER,
  SYMPTOM_UNCONSCIOUS,
  SYMPTOM_FREEZE,
  SYMPTOM_HOT,
  SYMPTOM_PAIN_LIGHT,
  SYMPTOM_PAIN_HEAVY,
  SYMPTOM_HAND_SHIVER,
};
 
enum SymptomTypes
{
  PRIMARY,
  SECONDARY
};
 
enum EAnimPlayState
{
  OK,
  POSTPONED,
  FAILED,
};
 
const int DEBUG_PADDING_OFFSET = 2;
const int MAX_QUEUE_SIZE = 5;
 
class SymptomManager
{
  PlayerBase m_Player;
  ref map<int, ref SymptomBase> m_AvailableSymptoms;
  ref map<int, int> m_ActiveSymptomTypes;//for each type(symptom id), keep track of how many times it is in queue
 
  ref array<ref SymptomBase> m_SymptomQueuePrimary;
  ref array<ref SymptomBase> m_SymptomQueueSecondary;
 
  ref map<int, SymptomBase > m_SymptomsUIDs;
 
 
  ref array<ref Param> m_SymptomQueueServerDbg;
  ref array<ref Param> m_SymptomQueueServerDbgPrimary;
  ref array<ref Param> m_SymptomQueueServerDbgSecondary;
  //ref array<string> m_SymptomQueueSecondaryServerDbg;
  ref Timer m_Timer;
 
  int m_ActiveSymptomIndexPrimary = -1;
  int m_CurrentCommandID;
 
  const int STORAGE_VERSION = 121;
 
  bool m_ShowDebug = false;
  bool m_ShowDebug2 = false;
 
  ref SmptAnimMetaBase m_AnimMeta;
 
  void Init()
  {
    RegisterSymptom(new CoughSymptom);
    RegisterSymptom(new VomitSymptom);
    RegisterSymptom(new BlindnessSymptom);
    RegisterSymptom(new SneezeSymptom);
    RegisterSymptom(new FeverBlurSymptom);
    RegisterSymptom(new BloodLoss);
    RegisterSymptom(new LaughterSymptom);
    RegisterSymptom(new FreezeSymptom);
    RegisterSymptom(new HotSymptom);
    RegisterSymptom(new PainLightSymptom);
    RegisterSymptom(new PainHeavySymptom);
    RegisterSymptom(new HandShiversSymptom);
    //RegisterSymptom(new BulletHitSymptom);
  }
 
  int GetStorageVersion()
  {
    return STORAGE_VERSION;
  }
 
 
  void AutoactivateSymptoms()
  {
    if (GetGame().IsClient())
      return;
 
    QueueUpSecondarySymptom(SymptomIDs.SYMPTOM_BLOODLOSS);
  }
 
  void SymptomManager(PlayerBase player)
  {
    m_ActiveSymptomTypes = new map<int, int>;
    m_SymptomsUIDs = new map<int, SymptomBase >;
    m_SymptomQueuePrimary = new array<ref SymptomBase>;
    m_SymptomQueueSecondary = new array<ref SymptomBase>;
    m_SymptomQueueServerDbg = new array<ref Param>;
    m_SymptomQueueServerDbgPrimary = new array<ref Param>;
    m_SymptomQueueServerDbgSecondary = new array<ref Param>;
    m_AvailableSymptoms = new map<int, ref SymptomBase>;
    m_Player = player;
    Init();
    AutoactivateSymptoms();
  }
 
  void OnPlayerKilled()
  {
    for (int i = 0; i < m_SymptomQueuePrimary.Count(); i++)
      m_SymptomQueuePrimary.Get(i).OnOwnerKilled();
 
    for (i = 0; i < m_SymptomQueueSecondary.Count(); i++)
    {
      if (m_SymptomQueueSecondary.Get(i)) m_SymptomQueueSecondary.Get(i).OnOwnerKilled();
    }
  }
 
  SymptomBase GetSymptomByUID(int SYMPTOM_uid)
  {
    return m_SymptomsUIDs.Get(SYMPTOM_uid);
  }
 
 
  void ~SymptomManager()
  {
  }
 
  PlayerBase GetPlayer()
  {
    return m_Player;
  }
 
  void RegisterSymptom(SymptomBase Symptom)
  {
    Symptom.Init(this, m_Player, 0);
    int id = Symptom.GetType();
 
    if (m_AvailableSymptoms.Contains(id))
    {
      Error("SymptomBase Symptom already registered !");
      return;
    }
 
    m_AvailableSymptoms.Insert(id, Symptom);
    //PrintString("inserting id: "+ToString(id));
  }
 
  void OnAnimationFinished(eAnimFinishType type = eAnimFinishType.SUCCESS)
  {
    if (m_AnimMeta)
      m_AnimMeta.AnimFinished(type);
  }
 
  void OnAnimationStarted()
  {
    if (GetCurrentPrimaryActiveSymptom())
      GetCurrentPrimaryActiveSymptom().AnimationStart();
  }
 
  int CreateUniqueID()
  {
    int uid = Math.RandomInt(1, 2147483647);
    if (!IsUIDUsed(uid)) return uid;
    else return CreateUniqueID();
  }
 
  bool IsUIDUsed(int uid)
  {
    return m_SymptomsUIDs.Contains(uid);
  }
 
  string GetSymptomName(int symptom_id)
  {
    return m_AvailableSymptoms.Get(symptom_id).GetName();
  }
 
  SmptAnimMetaBase SpawnAnimMetaObject(int symptom_id)
  {
    SmptAnimMetaBase animMeta = m_AvailableSymptoms.Get(symptom_id).SpawnAnimMetaObject();
    animMeta.m_StateType = symptom_id;
    return animMeta;
  }
 
  void RequestSymptomExit(int SYMPTOM_uid)
  {
    if (m_SymptomsUIDs.Get(SYMPTOM_uid)) m_SymptomsUIDs.Get(SYMPTOM_uid).RequestDestroy();
  }
 
  bool IsSymptomPrimary(int symptom_id)
  {
    return m_AvailableSymptoms.Get(symptom_id).IsPrimary();
  }
 
  void OnInputUserDataReceived(ParamsReadContext ctx)
  {
  }
 
  int GetCurrentCommandID()
  {
    return m_CurrentCommandID;
  }
 
  void OnTick(float deltatime, int pCurrentCommandID, HumanMovementState movement_state)
  {
    // pCurrentCommandID might be the initial value, but the system itself requires
    // current value, so retrieve the current value from player instead
    m_CurrentCommandID = m_Player.GetCurrentCommandID();
    if (m_ActiveSymptomIndexPrimary == -1)
      m_ActiveSymptomIndexPrimary = FindFirstAvailableSymptomIndex();
 
    UpdateActiveSymptoms(deltatime);
 
    if (m_AnimMeta)
    {
      if (m_AnimMeta.IsDestroyReqested())
        m_AnimMeta = null;
    }
 
    if (m_AnimMeta)
    {
 
      //anim requested
      if (!m_AnimMeta.IsPlaying())
      {
        // not playing yet and not possible to play
        SymptomBase symptom = m_AvailableSymptoms.Get(m_AnimMeta.m_StateType);
        if (symptom && !symptom.CanActivate())
          m_AnimMeta = null;
        else if (m_AnimMeta.PlayRequest() == EAnimPlayState.FAILED)
          OnAnimationFinished(eAnimFinishType.FAILURE);
      }
      else
        m_AnimMeta.Update(movement_state);
    }
 
#ifdef DIAG_DEVELOPER
#ifndef SERVER //must be here !!!
    if (DiagMenu.GetBool(DiagMenuIDs.MISC_PLAYER_SYMPTOMS_SHOW))
    {
      //DisplayDebug(true);
      array<ref Param> primary_debug = PrepareClientDebug(m_SymptomQueuePrimary);
      array<ref Param> secondary_debug = PrepareClientDebug(m_SymptomQueueSecondary);
 
      DisplayDebug1("Symptoms Client", 50, primary_debug, secondary_debug);
      DisplayDebug2("Symptoms Server", 300, m_SymptomQueueServerDbgPrimary, m_SymptomQueueServerDbgSecondary);
      ShowAvailableSymptoms();
    }
    else
    {
      CleanDebug1("Symptoms Client", 50);
      CleanDebug2("Symptoms Server", 300);
      CleanAvailableSymptoms();
    }
#endif
#endif
  }
 
  void SetAnimation(ParamsReadContext ctx)
  {
    if (m_AnimMeta)
    {
      // animation meta already exists
      // pass
    }
    else
    {
      int state_type;
      if (ctx.Read(state_type))
      {
        m_AnimMeta = SpawnAnimMetaObject(state_type);
        if (m_AnimMeta)
          m_AnimMeta.Init(ctx, this, m_Player);
      }
    }
  }
 
  void UpdateActiveSymptoms(float deltatime)
  {
    //if( GetGame().IsClient() && !m_Player.IsPlayer() ) return;
    //primary
    if (GetCurrentPrimaryActiveSymptom())
    {
      if (!GetCurrentPrimaryActiveSymptom().IsActivated())
      {
        if (GetCurrentPrimaryActiveSymptom().CanActivate())
          GetCurrentPrimaryActiveSymptom().Activate();
      }
      if (GetCurrentPrimaryActiveSymptom().IsActivated())
        GetCurrentPrimaryActiveSymptom().Update(deltatime);
    }
    //secondary
    for (int i = 0; i < m_SymptomQueueSecondary.Count(); i++)
    {
      if (m_SymptomQueueSecondary.Get(i) && !m_SymptomQueueSecondary.Get(i).IsActivated())
        m_SymptomQueueSecondary.Get(i).Activate();
      else
      {
        if (m_SymptomQueueSecondary.Get(i)) m_SymptomQueueSecondary.Get(i).Update(deltatime);
      }
    }
  }
 
 
  void OnSymptomExit(SymptomBase Symptom, int uid)
  {
    bool is_primary;
    if (Symptom)
    {
      is_primary = Symptom.IsPrimary();
      DecreaseSymptomCount(Symptom.GetType());
    }
 
    if (m_SymptomsUIDs.Contains(uid))
      m_SymptomsUIDs.Remove(uid);
    else
      Debug.LogError("Symptom with this UID does not exist", "PlayerSymptoms");
 
    if (is_primary)
    {
      for (int i = 0; i < m_SymptomQueuePrimary.Count(); i++)
      {
        if (m_SymptomQueuePrimary.Get(i) == Symptom)
        {
          m_SymptomQueuePrimary.RemoveOrdered(i);
          break;
        }
      }
    }
    else
    {
      for (i = 0; i < m_SymptomQueueSecondary.Count(); i++)
      {
        if (m_SymptomQueueSecondary.Get(i) == Symptom)
        {
          m_SymptomQueueSecondary.RemoveOrdered(i);
          break;
        }
      }
    }
    m_ActiveSymptomIndexPrimary = -1;
#ifdef DIAG_DEVELOPER
    if (GetGame()) SendServerDebugToClient();
#endif
  }
 
 
  int GetSymptomMaxCount(int symptom_id)
  {
    return m_AvailableSymptoms.Get(symptom_id).GetMaxCount();
  }
 
 
  int GetSymptomCount(int symptom_id)
  {
    if (m_ActiveSymptomTypes.Contains(symptom_id))
      return m_ActiveSymptomTypes.Get(symptom_id);
    else
      return -1;
  }
 
  void IncreaseSymptomCount(int symptom_id)
  {
    if (m_ActiveSymptomTypes.Contains(symptom_id))
      m_ActiveSymptomTypes.Set(symptom_id, m_ActiveSymptomTypes.Get(symptom_id) + 1);
    else
      m_ActiveSymptomTypes.Insert(symptom_id, 1);
  }
 
  void DecreaseSymptomCount(int symptom_id)
  {
    if (m_ActiveSymptomTypes.Contains(symptom_id))
    {
      if (m_ActiveSymptomTypes.Get(symptom_id) == 1)
        m_ActiveSymptomTypes.Remove(symptom_id);
      else
        m_ActiveSymptomTypes.Set(symptom_id, m_ActiveSymptomTypes.Get(symptom_id) - 1);
    }
  }
 
  SymptomBase SpawnSymptom(int symptom_id, int uid = -1)
  {
    if (m_AvailableSymptoms.Get(symptom_id))
    {
      SymptomBase Symptom = SymptomBase.Cast(m_AvailableSymptoms.Get(symptom_id).ClassName().ToType().Spawn());
      if (uid == -1)
        uid = CreateUniqueID();
      Symptom.Init(this, m_Player, uid);
      if (m_SymptomsUIDs.Contains(uid))
        Error("Symptoms: Unique ID already exists !");
      m_SymptomsUIDs.Insert(uid, Symptom);
      IncreaseSymptomCount(symptom_id);
      return Symptom;
    }
 
    if (!Symptom)
      Error("Symptom not registered");
 
    return NULL;
  }
 
  void CleanUpPrimaryQueue()
  {
    for (int i = 0; i < m_SymptomQueuePrimary.Count(); i++)
      m_SymptomQueuePrimary.Get(i).RequestDestroy();
 
  }
 
  SymptomBase QueueUpPrimarySymptom(int symptom_id, int uid = -1)
  {
    SymptomBase Symptom;
    if ((GetSymptomCount(symptom_id) >= GetSymptomMaxCount(symptom_id)) && GetSymptomMaxCount(symptom_id) != -1)
      return null;
    for (int i = 0; i < m_SymptomQueuePrimary.Count(); i++)
    {
      if (m_SymptomQueuePrimary.Get(i).CanBeInterupted() && ComparePriority(GetSymptomPriority(symptom_id), m_SymptomQueuePrimary.Get(i).GetPriority()) == 1)
      {
        Symptom = SpawnSymptom(symptom_id, uid);
        m_SymptomQueuePrimary.InsertAt(Symptom, i);
 
        if (m_SymptomQueuePrimary.Count() > MAX_QUEUE_SIZE)
        {
          m_SymptomQueuePrimary.Get(MAX_QUEUE_SIZE).RequestDestroy();// no need to remove from the array, that's done via Symptom callback on destruct
        }
        break;
      }
    }
    if (!Symptom && m_SymptomQueuePrimary.Count() < MAX_QUEUE_SIZE)
    {
      Symptom = SpawnSymptom(symptom_id, uid);
      m_SymptomQueuePrimary.Insert(Symptom);
    }
#ifdef DIAG_DEVELOPER
    SendServerDebugToClient();
#endif
    return Symptom;
  }
 
  void QueueUpSecondarySymptom(int symptom_id, int uid = -1)
  {
    QueueUpSecondarySymptomEx(symptom_id, uid);
  }
 
  SymptomBase QueueUpSecondarySymptomEx(int symptom_id, int uid = -1)
  {
    if ((GetSymptomCount(symptom_id) >= GetSymptomMaxCount(symptom_id)) && GetSymptomMaxCount(symptom_id) != -1)
      return null;
 
    if (m_AvailableSymptoms.Get(symptom_id).IsPrimary())
      return null;
 
    SymptomBase Symptom = SpawnSymptom(symptom_id, uid);
 
    m_SymptomQueueSecondary.Insert(Symptom);
    return Symptom;
  }
 
  void RemoveSecondarySymptom(int symptom_id)
  {
    for (int i = 0; i < m_SymptomQueueSecondary.Count(); i++)
    {
      if (m_SymptomQueueSecondary.Get(i) && m_SymptomQueueSecondary.Get(i).GetType() == symptom_id)
      {
        m_SymptomQueueSecondary.Get(i).RequestDestroy();
        return;
      }
    }
  }
 
  SymptomBase GetCurrentPrimaryActiveSymptom()
  {
    if (GetGame().IsServer())
    {
      if (m_ActiveSymptomIndexPrimary >= 0 && m_ActiveSymptomIndexPrimary < m_SymptomQueuePrimary.Count())
      {
        if (m_SymptomQueuePrimary.Get(m_ActiveSymptomIndexPrimary)) return m_SymptomQueuePrimary.Get(m_ActiveSymptomIndexPrimary);
      }
    }
    if (!GetGame().IsDedicatedServer())
    {
      if (m_SymptomQueuePrimary.Count() > 0)
        return m_SymptomQueuePrimary.Get(0);
    }
    return NULL;
  }
 
  int FindFirstAvailableSymptomIndex()
  {
    for (int i = 0; i < m_SymptomQueuePrimary.Count(); i++)
    {
      if (m_SymptomQueuePrimary.Get(i).CanActivate())
        return i;
    }
    return -1;
  }
 
  int ComparePriority(int prio1, int prio2)
  {
    if (prio1 > prio2)
      return 1;
    else if (prio2 > prio1)
      return 2;
    return 0;
  }
 
  int GetSymptomPriority(int symptom_id)
  {
    return m_AvailableSymptoms.Get(symptom_id).GetPriority();
  }
 
  void OnRPC(int rpc_type, ParamsReadContext ctx)
  {
    ctx.Read(CachedObjectsParams.PARAM2_INT_INT);
    int symptom_id = CachedObjectsParams.PARAM2_INT_INT.param1;
    int uid = CachedObjectsParams.PARAM2_INT_INT.param2;
 
    bool is_primary = m_AvailableSymptoms.Get(symptom_id).IsPrimary();
 
    if (rpc_type == ERPCs.RPC_PLAYER_SYMPTOM_ON)
    {
      if (is_primary)
      {
        CleanUpPrimaryQueue();
        QueueUpPrimarySymptom(symptom_id, uid);
      }
      else
        QueueUpSecondarySymptom(symptom_id, uid);
    }
    else if (rpc_type == ERPCs.RPC_PLAYER_SYMPTOM_OFF)
    {
      if (is_primary)
        CleanUpPrimaryQueue();
      else
        RemoveSecondarySymptom(symptom_id);
    }
  }
 
  void OnStoreSave(ParamsWriteContext ctx)
  {
    array<int> m_SaveQueue = new array<int>;
 
    for (int i = 0; i < m_SymptomQueuePrimary.Count(); i++)
    {
      if (m_SymptomQueuePrimary.Get(i).IsPersistent())
        m_SaveQueue.Insert(m_SymptomQueuePrimary.Get(i).GetType());
    }
 
    for (i = 0; i < m_SymptomQueueSecondary.Count(); i++)
    {
      if (m_SymptomQueueSecondary.Get(i).IsPersistent())
        m_SaveQueue.Insert(m_SymptomQueueSecondary.Get(i).GetType());
    }
 
    ctx.Write(m_SaveQueue);
  }
 
  bool OnStoreLoad(ParamsReadContext ctx, int version)
  {
    array<int> m_SaveQueue;
 
    if (ctx.Read(m_SaveQueue))
    {
      for (int i = 0; i < m_SaveQueue.Count(); i++)
      {
        int id = m_SaveQueue.Get(i);
 
        if (IsSymptomPrimary(id))
          QueueUpPrimarySymptom(id);
        else
          QueueUpSecondarySymptom(id);
      }
      return true;
    }
    else
      return false;
  }
 
#ifdef DIAG_DEVELOPER
  void OnRPCDebug(int rpc_type, ParamsReadContext ctx)
  {
    switch (rpc_type)
    {
    case ERPCs.DIAG_PLAYER_SYMPTOMS_DEBUG_ON:
    {
      if (ctx.Read(CachedObjectsParams.PARAM1_INT))
      {
        if (IsSymptomPrimary(CachedObjectsParams.PARAM1_INT.param1))
          QueueUpPrimarySymptom(CachedObjectsParams.PARAM1_INT.param1);
        else
          QueueUpSecondarySymptom(CachedObjectsParams.PARAM1_INT.param1);
      }
      break;
    }
 
    case ERPCs.DIAG_PLAYER_SYMPTOMS_DEBUG_OFF:
    {
      if (ctx.Read(CachedObjectsParams.PARAM1_INT))
        RequestSymptomExit(CachedObjectsParams.PARAM1_INT.param1);
      break;
    }
 
    case ERPCs.DIAG_PLAYER_SYMPTOMS_DEBUG:
    {
      int primary_Symptoms_count;
      int secondary_Symptoms_count;
 
      int symptom_id;
 
      if (ctx.Read(CachedObjectsParams.PARAM1_INT))
        primary_Symptoms_count = CachedObjectsParams.PARAM1_INT.param1;
 
      if (ctx.Read(CachedObjectsParams.PARAM1_INT))
        secondary_Symptoms_count = CachedObjectsParams.PARAM1_INT.param1;
 
      m_SymptomQueueServerDbg.Clear();
      m_SymptomQueueServerDbgPrimary.Clear();
      m_SymptomQueueServerDbgSecondary.Clear();
 
      int overall_count = primary_Symptoms_count + secondary_Symptoms_count;
      for (int i = 0; i < overall_count ; ++i)
      {
        Param3<bool, int, int> p3 = new Param3<bool, int, int>(false, 0, 0);
        ctx.Read(p3);
        bool is_primary = p3.param1;
 
        if (is_primary)
        {
          m_SymptomQueueServerDbgPrimary.Insert(p3);// m_SymptomQueueServerDbg.Insert(p3);
        }
        else
          m_SymptomQueueServerDbgSecondary.Insert(p3);
        //PrintString("elements m_SymptomQueueServerDbgPrimary:" + m_SymptomQueueServerDbgPrimary.Count());
        //PrintString("elements m_SymptomQueueServerDbgSecondary:" + m_SymptomQueueServerDbgSecondary.Count());
 
      }
      /*
        for(i = 0; i < secondary_Symptoms_count; i++)
        {
        ctx.Read(CachedObjectsParams.PARAM1_STRING);
        m_SymptomQueueSecondaryServerDbg.Insert(CachedObjectsParams.PARAM1_STRING.param1);
        }*/
      break;
    }
    }
  }
 
  void SendServerDebugToClient()
  {
    array<ref Param> debug_list = new array<ref Param>;
 
    Param1<int> p1 = new Param1<int>(0);
    Param1<int> p2 = new Param1<int>(0);
 
    p1.param1 = m_SymptomQueuePrimary.Count();
    p2.param1 = m_SymptomQueueSecondary.Count();
 
    debug_list.Insert(p1);
    debug_list.Insert(p2);
 
    Param3<bool, int, int> p;
 
    bool is_primary;
    int symptom_id;
    int SYMPTOM_uid;
 
    foreach (SymptomBase symptom : m_SymptomQueuePrimary)
    {
      is_primary = symptom.IsPrimary();
      symptom_id = symptom.GetType();
      SYMPTOM_uid = symptom.GetUID();
 
      p = new Param3<bool, int, int>(is_primary, symptom_id, SYMPTOM_uid);
      debug_list.Insert(p);
    }
 
    foreach (SymptomBase secSymptom : m_SymptomQueueSecondary)
    {
      is_primary = secSymptom.IsPrimary();
      symptom_id = secSymptom.GetType();
      SYMPTOM_uid = secSymptom.GetUID();
 
      p = new Param3<bool, int, int>(is_primary, symptom_id, SYMPTOM_uid);
      debug_list.Insert(p);
    }
 
    GetGame().RPC(GetPlayer(), ERPCs.DIAG_PLAYER_SYMPTOMS_DEBUG, debug_list, true);
  }
 
  void DebugRequestExitSymptom(int SYMPTOM_uid)
  {
    CachedObjectsParams.PARAM1_INT.param1 = SYMPTOM_uid;
    if (GetPlayer())
      GetGame().RPCSingleParam(GetPlayer(), ERPCs.DIAG_PLAYER_SYMPTOMS_DEBUG_OFF, CachedObjectsParams.PARAM1_INT, true, GetPlayer().GetIdentity());
  }
 
  array<ref Param> PrepareClientDebug(array<ref SymptomBase> Symptoms)
  {
    array<ref Param> debug_array = new array<ref Param>;
 
    Param3<bool, int, int> p3;
 
    for (int i = 0; i < Symptoms.Count(); i++)
    {
      bool is_primary = Symptoms.Get(i).IsPrimary();
      int symptom_id = Symptoms.Get(i).GetType();
      int SYMPTOM_uid = Symptoms.Get(i).GetUID();
 
      p3 = new Param3<bool, int, int>(is_primary, symptom_id, SYMPTOM_uid);
      debug_array.Insert(p3);
    }
    return debug_array;
  }
 
  void DisplayDebug1(string name, int y_offset, array<ref Param> Symptoms_primary, array<ref Param> Symptoms_secondary)
  {
    string primary;
    Param3<bool, int, int> p3 = new Param3<bool, int, int>(false, 0, 0);
 
    DbgUI.BeginCleanupScope();
    DbgUI.Begin(name, 50, y_offset);
    DbgUI.Text("Primary: ");
 
    bool is_primary;
    int symptom_id;
    int SYMPTOM_uid;
    string SYMPTOM_name;
 
    for (int i = 0; i < Symptoms_primary.Count(); i++)
    {
      p3 = Param3<bool, int, int>.Cast(Symptoms_primary.Get(i));
 
      is_primary = p3.param1;
      symptom_id = p3.param2;
      SYMPTOM_uid = p3.param3;
      SYMPTOM_name = GetSymptomName(symptom_id);
 
      primary += SYMPTOM_name + " | ";
    }
 
    DbgUI.Text(primary);
    DbgUI.Text("Secondary: ");
    for (i = 0; i < Symptoms_secondary.Count(); i++)
    {
      p3 = Param3<bool, int, int>.Cast(Symptoms_secondary.Get(i));
 
      is_primary = p3.param1;
      symptom_id = p3.param2;
      SYMPTOM_uid = p3.param3;
      SYMPTOM_name = GetSymptomName(symptom_id);
      DbgUI.Text(SYMPTOM_name);
    }
 
    DbgUI.End();
    DbgUI.EndCleanupScope();
  }
 
  void DisplayDebug2(string name, int y_offset, array<ref Param> Symptoms_primary, array<ref Param> Symptoms_secondary)
  {
    string primary;
    Param3<bool, int, int> p3 = new Param3<bool, int, int>(false, 0, 0);
 
    DbgUI.BeginCleanupScope();
    DbgUI.Begin(name, 50, y_offset);
    DbgUI.Text("Primary: ");
 
    bool is_primary;
    int symptom_id;
    int SYMPTOM_uid;
    string SYMPTOM_name;
 
    for (int i = 0; i < Symptoms_primary.Count(); i++)
    {
      p3 = Param3<bool, int, int>.Cast(Symptoms_primary.Get(i));
 
      is_primary = p3.param1;
      symptom_id = p3.param2;
      SYMPTOM_uid = p3.param3;
      SYMPTOM_name = GetSymptomName(symptom_id);
 
      if (DbgUI.Button(i.ToString() + " " + SYMPTOM_name, 80))
        DebugRequestExitSymptom(SYMPTOM_uid);
    }
 
    DbgUI.Text("Secondary: ");
    for (i = 0; i < Symptoms_secondary.Count(); i++)
    {
      p3 = Param3<bool, int, int>.Cast(Symptoms_secondary.Get(i));
 
      is_primary = p3.param1;
      symptom_id = p3.param2;
      SYMPTOM_uid = p3.param3;
      SYMPTOM_name = GetSymptomName(symptom_id);
 
      if (DbgUI.Button(i.ToString() + " " + SYMPTOM_name, 80))
        DebugRequestExitSymptom(SYMPTOM_uid);
    }
 
    DbgUI.End();
    DbgUI.EndCleanupScope();
  }
 
  void ShowAvailableSymptoms()
  {
    DbgUI.BeginCleanupScope();
    DbgUI.Begin("available Symptoms", 300, 50);
 
    for (int i = 0; i < m_AvailableSymptoms.Count(); i++)
    {
      SymptomBase Symptom = m_AvailableSymptoms.GetElement(i);
      string SYMPTOM_name = Symptom.GetName();
      int symptom_id = Symptom.GetType();
 
      if (DbgUI.Button(i.ToString() + " " + SYMPTOM_name, 80))
        DebugRequestActivateSymptom(symptom_id);
    }
 
    DbgUI.End();
    DbgUI.EndCleanupScope();
  }
 
  void CleanAvailableSymptoms()
  {
    DbgUI.BeginCleanupScope();
    DbgUI.Begin("available Symptoms", 300, 50);
    DbgUI.End();
    DbgUI.EndCleanupScope();
  }
 
  void CleanDebug1(string name, int y_offset)
  {
    DbgUI.BeginCleanupScope();
    DbgUI.Begin(name, 50, y_offset);
    DbgUI.End();
    DbgUI.EndCleanupScope();
  }
 
  void CleanDebug2(string name, int y_offset)
  {
    DbgUI.BeginCleanupScope();
    DbgUI.Begin(name, 50, y_offset);
    DbgUI.End();
    DbgUI.EndCleanupScope();
  }
 
  void DebugRequestActivateSymptom(int symptom_id)
  {
    CachedObjectsParams.PARAM1_INT.param1 = symptom_id;
    if (GetPlayer())
      GetGame().RPCSingleParam(GetPlayer(), ERPCs.DIAG_PLAYER_SYMPTOMS_DEBUG_ON, CachedObjectsParams.PARAM1_INT, true, GetPlayer().GetIdentity());
  }
 
#endif
}