Класс SymptomManager

Закрытые члены
void	Init ()
int	GetStorageVersion ()
void	AutoactivateSymptoms ()
void	SymptomManager (PlayerBase player)
void	OnPlayerKilled ()
SymptomBase	GetSymptomByUID (int SYMPTOM_uid)
PlayerBase	GetPlayer ()
void	RegisterSymptom (SymptomBase Symptom)
void	OnAnimationFinished (eAnimFinishType type=eAnimFinishType.SUCCESS)
void	OnAnimationStarted ()
int	CreateUniqueID ()
bool	IsUIDUsed (int uid)
string	GetSymptomName (int symptom_id)
SmptAnimMetaBase	SpawnAnimMetaObject (int symptom_id)
void	RequestSymptomExit (int SYMPTOM_uid)
	Exits a specific Symptom with a given UID.
bool	IsSymptomPrimary (int symptom_id)
void	OnInputUserDataReceived (ParamsReadContext ctx)
int	GetCurrentCommandID ()
void	OnTick (float deltatime, int pCurrentCommandID, HumanMovementState movement_state)
void	SetAnimation (ParamsReadContext ctx)
void	UpdateActiveSymptoms (float deltatime)
void	OnSymptomExit (SymptomBase Symptom, int uid)
int	GetSymptomMaxCount (int symptom_id)
int	GetSymptomCount (int symptom_id)
void	IncreaseSymptomCount (int symptom_id)
void	DecreaseSymptomCount (int symptom_id)
SymptomBase	SpawnSymptom (int symptom_id, int uid=-1)
void	CleanUpPrimaryQueue ()
SymptomBase	QueueUpPrimarySymptom (int symptom_id, int uid=-1)
void	QueueUpSecondarySymptom (int symptom_id, int uid=-1)
SymptomBase	QueueUpSecondarySymptomEx (int symptom_id, int uid=-1)
void	RemoveSecondarySymptom (int symptom_id)
	Removes a single Symptom.
SymptomBase	GetCurrentPrimaryActiveSymptom ()
int	FindFirstAvailableSymptomIndex ()
int	ComparePriority (int prio1, int prio2)
int	GetSymptomPriority (int symptom_id)
void	OnRPC (int rpc_type, ParamsReadContext ctx)
void	OnStoreSave (ParamsWriteContext ctx)
bool	OnStoreLoad (ParamsReadContext ctx, int version)

Закрытые данные
PlayerBase	m_Player
ref map< int, ref SymptomBase >	m_AvailableSymptoms
ref map< int, int >	m_ActiveSymptomTypes
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 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

Подробное описание

Конструктор(ы)

SymptomManager()

void SymptomManager ( PlayerBase player )

inlineprivate

    {
        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_AvailableSymptoms     = new map<int, ref SymptomBase>();
        
        m_SymptomQueueServerDbgPrimary      = new array<ref Param>();
        m_SymptomQueueServerDbgSecondary    = new array<ref Param>();
 
        m_Player = player;
 
        Init();
        AutoactivateSymptoms();
    }

Перекрестные ссылки AutoactivateSymptoms(), Init(), m_ActiveSymptomTypes, m_AvailableSymptoms, m_Player, m_SymptomQueuePrimary, m_SymptomQueueSecondary, m_SymptomQueueServerDbg, m_SymptomQueueServerDbgPrimary, m_SymptomQueueServerDbgSecondary и m_SymptomsUIDs.

Методы

AutoactivateSymptoms()

void AutoactivateSymptoms ( )

inlineprivate

    {
        if ( GetGame().IsClient() ) 
        {
            return;
        }
        
        QueueUpSecondarySymptom(SymptomIDs.SYMPTOM_BLOODLOSS);
    }

Перекрестные ссылки GetGame() и QueueUpSecondarySymptom().

Используется в SymptomManager().

CleanUpPrimaryQueue()

void CleanUpPrimaryQueue ( )

inlineprivate

    {
        foreach (SymptomBase symptom : m_SymptomQueuePrimary)
        {
            symptom.RequestDestroy();
        }
    }

Перекрестные ссылки m_SymptomQueuePrimary.

Используется в OnRPC().

ComparePriority()

int ComparePriority ( int prio1, int prio2 )

inlineprivate

    {
        if ( prio1 > prio2 )
        {
            return 1;
        }
        else if ( prio2 > prio1 )
        {
            return 2;
        }
        return 0;
    }

Используется в QueueUpPrimarySymptom().

CreateUniqueID()

int CreateUniqueID ( )

inlineprivate

    {
        int uid = Math.RandomInt(1, 2147483647);
        if (!IsUIDUsed(uid))
            return uid;
        else
            return CreateUniqueID();
    }

Перекрестные ссылки CreateUniqueID(), IsUIDUsed() и Math::RandomInt().

Используется в CreateUniqueID() и SpawnSymptom().

DecreaseSymptomCount()

void DecreaseSymptomCount ( int symptom_id )

inlineprivate

    {
        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);
        }
    }

Перекрестные ссылки m_ActiveSymptomTypes.

Используется в OnSymptomExit().

FindFirstAvailableSymptomIndex()

int FindFirstAvailableSymptomIndex ( )

inlineprivate

    {
        for (int i = 0; i < m_SymptomQueuePrimary.Count();i++)
        {
            if ( m_SymptomQueuePrimary.Get(i).CanActivate() )
            {
                return i;
            }
        }
        return -1;
    }

Перекрестные ссылки m_SymptomQueuePrimary.

Используется в OnTick().

GetCurrentCommandID()

int GetCurrentCommandID ( )

inlineprivate

    {
        return m_CurrentCommandID;
    }

Перекрестные ссылки m_CurrentCommandID.

Используется в VomitSymptom::CanActivate().

GetCurrentPrimaryActiveSymptom()

SymptomBase GetCurrentPrimaryActiveSymptom ( )

inlineprivate

    {
        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;
    }

Перекрестные ссылки GetGame(), m_ActiveSymptomIndexPrimary и m_SymptomQueuePrimary.

Используется в AnimFinished(), OnAnimationStarted() и UpdateActiveSymptoms().

GetPlayer()

PlayerBase GetPlayer ( )

inlineprivate

    {
        return m_Player;
    }

Перекрестные ссылки m_Player.

GetStorageVersion()

int GetStorageVersion ( )

inlineprivate

    {
        return STORAGE_VERSION;
    }

Перекрестные ссылки STORAGE_VERSION.

GetSymptomByUID()

SymptomBase GetSymptomByUID ( int SYMPTOM_uid )

inlineprivate

    {
        return m_SymptomsUIDs.Get(SYMPTOM_uid);
    }

Перекрестные ссылки m_SymptomsUIDs.

GetSymptomCount()

int GetSymptomCount ( int symptom_id )

inlineprivate

    {
        if ( m_ActiveSymptomTypes.Contains(symptom_id) )
            return m_ActiveSymptomTypes.Get(symptom_id);
        else 
            return -1;
    }

Перекрестные ссылки m_ActiveSymptomTypes.

Используется в QueueUpPrimarySymptom() и QueueUpSecondarySymptomEx().

GetSymptomMaxCount()

int GetSymptomMaxCount ( int symptom_id )

inlineprivate

    {
        return m_AvailableSymptoms.Get(symptom_id).GetMaxCount();
    }

Перекрестные ссылки m_AvailableSymptoms.

Используется в QueueUpPrimarySymptom() и QueueUpSecondarySymptomEx().

GetSymptomName()

string GetSymptomName ( int symptom_id )

inlineprivate

    {
        return m_AvailableSymptoms.Get(symptom_id).GetName();
    }

Перекрестные ссылки m_AvailableSymptoms.

GetSymptomPriority()

int GetSymptomPriority ( int symptom_id )

inlineprivate

    {
        return m_AvailableSymptoms.Get(symptom_id).GetPriority();
    }

Перекрестные ссылки m_AvailableSymptoms.

Используется в QueueUpPrimarySymptom().

IncreaseSymptomCount()

void IncreaseSymptomCount ( int symptom_id )

inlineprivate

    {
        if ( m_ActiveSymptomTypes.Contains(symptom_id) )
        {
            m_ActiveSymptomTypes.Set(symptom_id, m_ActiveSymptomTypes.Get(symptom_id) + 1);
        }
        else
        {
            m_ActiveSymptomTypes.Insert(symptom_id, 1);
        }
    }

Перекрестные ссылки m_ActiveSymptomTypes.

Используется в SpawnSymptom().

Init()

void Init ( )

inlineprivate

    {
        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 DeafnessCompleteSymptom);
        RegisterSymptom(new HMP3Symptom);
        RegisterSymptom(new GaspSymptom);
    }

Перекрестные ссылки RegisterSymptom().

Используется в SymptomManager().

IsSymptomPrimary()

bool IsSymptomPrimary ( int symptom_id )

inlineprivate

    {
        return m_AvailableSymptoms.Get(symptom_id).IsPrimary();
    }

Перекрестные ссылки m_AvailableSymptoms.

Используется в OnStoreLoad().

IsUIDUsed()

bool IsUIDUsed ( int uid )

inlineprivate

    {
        return m_SymptomsUIDs.Contains(uid);
    }

Перекрестные ссылки m_SymptomsUIDs.

Используется в CreateUniqueID().

OnAnimationFinished()

void OnAnimationFinished ( eAnimFinishType type = eAnimFinishType.SUCCESS )

inlineprivate

    {
        if (m_AnimMeta)
        {
            m_AnimMeta.AnimFinished(type);
        }
    }

Перекрестные ссылки m_AnimMeta.

Используется в OnTick(), PlayRequest() и Update().

OnAnimationStarted()

void OnAnimationStarted ( )

inlineprivate

    {
        if (GetCurrentPrimaryActiveSymptom())
            GetCurrentPrimaryActiveSymptom().AnimationStart();
    }

Перекрестные ссылки SymptomBase::AnimationStart() и GetCurrentPrimaryActiveSymptom().

Используется в Update().

OnInputUserDataReceived()

void OnInputUserDataReceived ( ParamsReadContext ctx )

inlineprivate

    {   
    }

OnPlayerKilled()

void OnPlayerKilled ( )

inlineprivate

    {
        foreach (SymptomBase symptomPrimary : m_SymptomQueuePrimary)
            symptomPrimary.OnOwnerKilled();
        
        foreach (SymptomBase symptomSecondary : m_SymptomQueueSecondary)
            symptomSecondary.OnOwnerKilled();
    }

Перекрестные ссылки m_SymptomQueuePrimary и m_SymptomQueueSecondary.

OnRPC()

void OnRPC ( int rpc_type, ParamsReadContext ctx )

inlineprivate

    {
        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 );
            }
        }
    }

Перекрестные ссылки CleanUpPrimaryQueue(), m_AvailableSymptoms, CachedObjectsParams::PARAM2_INT_INT, QueueUpPrimarySymptom(), QueueUpSecondarySymptom() и RemoveSecondarySymptom().

OnStoreLoad()

bool OnStoreLoad ( ParamsReadContext ctx, int version )

inlineprivate

    {
        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;
        }               
    }

Перекрестные ссылки IsSymptomPrimary(), QueueUpPrimarySymptom() и QueueUpSecondarySymptom().

OnStoreSave()

void OnStoreSave ( ParamsWriteContext ctx )

inlineprivate

    {
        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 );
    }

Перекрестные ссылки m_SymptomQueuePrimary и m_SymptomQueueSecondary.

OnSymptomExit()

void OnSymptomExit ( SymptomBase Symptom, int uid )

inlineprivate

    {
        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;
        m_Player.SetActivePrimarySymptomID(0);
        
        #ifdef DIAG_DEVELOPER
        if ( GetGame() ) SendServerDebugToClient();
        #endif
    }

Перекрестные ссылки DecreaseSymptomCount(), GetGame(), Debug::LogError(), m_ActiveSymptomIndexPrimary, m_Player, m_SymptomQueuePrimary, m_SymptomQueueSecondary и m_SymptomsUIDs.

Используется в SymptomBase::OnDestructed().

OnTick()

void OnTick ( float deltatime, int pCurrentCommandID, HumanMovementState movement_state )

inlineprivate

    {
        // 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();
            
            if (m_ActiveSymptomIndexPrimary != -1 && m_SymptomQueuePrimary.Get(m_ActiveSymptomIndexPrimary).IsSyncToRemotes())
                m_Player.SetActivePrimarySymptomID(m_SymptomQueuePrimary.Get(m_ActiveSymptomIndexPrimary).GetType());
        }
        
        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();
        }
        
        int HMPRange = DiagMenu.GetRangeValue(DiagMenuIDs.MISC_PLAYER_SYMPTOMS_TOGGLE_HMP);
        if (HMPRange == 1 && m_ActiveSymptomTypes.Get(SymptomIDs.SYMPTOM_HMP_SEVERE) == 0)
        {
            QueueUpSecondarySymptomEx(SymptomIDs.SYMPTOM_HMP_SEVERE);
        }
        else if (HMPRange == 0 && m_ActiveSymptomTypes.Get(SymptomIDs.SYMPTOM_HMP_SEVERE) > 0)
        {
            RemoveSecondarySymptom(SymptomIDs.SYMPTOM_HMP_SEVERE);
        }
        #endif
        #endif
    }

Перекрестные ссылки FindFirstAvailableSymptomIndex(), DiagMenu::GetBool(), DiagMenu::GetRangeValue(), m_ActiveSymptomIndexPrimary, m_ActiveSymptomTypes, m_AnimMeta, m_AvailableSymptoms, m_CurrentCommandID, m_Player, m_SymptomQueuePrimary, m_SymptomQueueSecondary, m_SymptomQueueServerDbgPrimary, m_SymptomQueueServerDbgSecondary, OnAnimationFinished(), QueueUpSecondarySymptomEx(), RemoveSecondarySymptom() и UpdateActiveSymptoms().

QueueUpPrimarySymptom()

SymptomBase QueueUpPrimarySymptom ( int symptom_id, int uid = -1 )

inlineprivate

    {
        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;
    }

Перекрестные ссылки ComparePriority(), GetSymptomCount(), GetSymptomMaxCount(), GetSymptomPriority(), m_SymptomQueuePrimary, MAX_QUEUE_SIZE и SpawnSymptom().

Используется в OnRPC() и OnStoreLoad().

QueueUpSecondarySymptom()

void QueueUpSecondarySymptom ( int symptom_id, int uid = -1 )

inlineprivate

    {
         QueueUpSecondarySymptomEx(symptom_id, uid);
    }

Перекрестные ссылки QueueUpSecondarySymptomEx().

Используется в AutoactivateSymptoms(), OnRPC() и OnStoreLoad().

QueueUpSecondarySymptomEx()

SymptomBase QueueUpSecondarySymptomEx ( int symptom_id, int uid = -1 )

inlineprivate

    {
        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;
    }

Перекрестные ссылки GetSymptomCount(), GetSymptomMaxCount(), m_AvailableSymptoms, m_SymptomQueueSecondary и SpawnSymptom().

Используется в OnTick() и QueueUpSecondarySymptom().

RegisterSymptom()

void RegisterSymptom ( SymptomBase Symptom )

inlineprivate

    {
        Symptom.Init(this, m_Player,0);
        int id = Symptom.GetType();
        
        if (m_AvailableSymptoms.Contains(id))
        {
            ErrorEx(string.Format("Symptom %1 already registered!", Symptom.GetName()));
            return;
        }
        
        m_AvailableSymptoms.Insert(id, Symptom);
    }

Перекрестные ссылки ErrorEx, m_AvailableSymptoms и m_Player.

Используется в Init().

RemoveSecondarySymptom()

void RemoveSecondarySymptom ( int symptom_id )

inlineprivate

Removes a single Symptom.

    {
        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;
            }
        }
    }

Перекрестные ссылки m_SymptomQueueSecondary.

Используется в OnRPC() и OnTick().

RequestSymptomExit()

void RequestSymptomExit ( int SYMPTOM_uid )

inlineprivate

Exits a specific Symptom with a given UID.

    {
        if (m_SymptomsUIDs.Get(SYMPTOM_uid))
            m_SymptomsUIDs.Get(SYMPTOM_uid).RequestDestroy();
    }

Перекрестные ссылки m_SymptomsUIDs.

SetAnimation()

void SetAnimation ( ParamsReadContext ctx )

inlineprivate

    {
        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);
                }
            }
        }
    }

Перекрестные ссылки m_AnimMeta, m_Player и SpawnAnimMetaObject().

SpawnAnimMetaObject()

SmptAnimMetaBase SpawnAnimMetaObject ( int symptom_id )

inlineprivate

    {
        SmptAnimMetaBase animMeta = m_AvailableSymptoms.Get(symptom_id).SpawnAnimMetaObject();
        animMeta.m_StateType = symptom_id;
 
        return animMeta;
    }

Перекрестные ссылки m_AvailableSymptoms.

Используется в SetAnimation().

SpawnSymptom()

SymptomBase SpawnSymptom ( int symptom_id, int uid = -1 )

inlineprivate

    {
        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) ) 
                ErrorEx(string.Format("Symptoms: Unique ID (=%1) already exists!", uid));
 
            m_SymptomsUIDs.Insert(uid, symptom);
            IncreaseSymptomCount(symptom_id);
 
            return symptom;
        }
        
        if (!symptom) 
        {
            Error("Symptom not registered");
        }
        
        return null;
    }

Перекрестные ссылки CreateUniqueID(), Error(), ErrorEx, IncreaseSymptomCount(), m_AvailableSymptoms, m_Player и m_SymptomsUIDs.

Используется в QueueUpPrimarySymptom() и QueueUpSecondarySymptomEx().

UpdateActiveSymptoms()

void UpdateActiveSymptoms ( float deltatime )

inlineprivate

    {   
        //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);
            }
        }
    }

Перекрестные ссылки SymptomBase::Activate(), GetCurrentPrimaryActiveSymptom(), m_SymptomQueueSecondary и SymptomBase::Update().

Используется в OnTick().

Поля

m_ActiveSymptomIndexPrimary

int m_ActiveSymptomIndexPrimary = -1

private

Используется в GetCurrentPrimaryActiveSymptom(), OnSymptomExit() и OnTick().

m_ActiveSymptomTypes

ref map<int, int> m_ActiveSymptomTypes

private

Используется в DecreaseSymptomCount(), GetSymptomCount(), IncreaseSymptomCount(), OnTick() и SymptomManager().

m_AnimMeta

ref SmptAnimMetaBase m_AnimMeta

private

Используется в OnAnimationFinished(), OnTick() и SetAnimation().

m_AvailableSymptoms

ref map<int, ref SymptomBase> m_AvailableSymptoms

private

Используется в GetSymptomMaxCount(), GetSymptomName(), GetSymptomPriority(), IsSymptomPrimary(), OnRPC(), OnTick(), QueueUpSecondarySymptomEx(), RegisterSymptom(), SpawnAnimMetaObject(), SpawnSymptom() и SymptomManager().

m_CurrentCommandID

int m_CurrentCommandID

private

Используется в GetCurrentCommandID() и OnTick().

m_Player

PlayerBase m_Player

private

Используется в GetPlayer(), OnSymptomExit(), OnTick(), RegisterSymptom(), SetAnimation(), SpawnSymptom() и SymptomManager().

m_ShowDebug

bool m_ShowDebug = false

private

m_ShowDebug2

bool m_ShowDebug2 = false

private

m_SymptomQueuePrimary

ref array<ref SymptomBase> m_SymptomQueuePrimary

private

Используется в CleanUpPrimaryQueue(), FindFirstAvailableSymptomIndex(), GetCurrentPrimaryActiveSymptom(), OnPlayerKilled(), OnStoreSave(), OnSymptomExit(), OnTick(), QueueUpPrimarySymptom() и SymptomManager().

m_SymptomQueueSecondary

ref array<ref SymptomBase> m_SymptomQueueSecondary

private

Используется в OnPlayerKilled(), OnStoreSave(), OnSymptomExit(), OnTick(), QueueUpSecondarySymptomEx(), RemoveSecondarySymptom(), SymptomManager() и UpdateActiveSymptoms().

m_SymptomQueueServerDbg

ref array<ref Param> m_SymptomQueueServerDbg

private

Используется в SymptomManager().

m_SymptomQueueServerDbgPrimary

ref array<ref Param> m_SymptomQueueServerDbgPrimary

private

Используется в OnTick() и SymptomManager().

m_SymptomQueueServerDbgSecondary

ref array<ref Param> m_SymptomQueueServerDbgSecondary

private

Используется в OnTick() и SymptomManager().

m_SymptomsUIDs

ref map<int , SymptomBase > m_SymptomsUIDs

private

Используется в GetSymptomByUID(), IsUIDUsed(), OnSymptomExit(), RequestSymptomExit(), SpawnSymptom() и SymptomManager().

m_Timer

ref Timer m_Timer

private

STORAGE_VERSION

const int STORAGE_VERSION = 121

private

Используется в GetStorageVersion().

---

Объявления и описания членов класса находятся в файле:

• D:/Ishodniki/scripts/4_World/Classes/PlayerSymptoms/StateManager.c