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
}